System.Threading.{Semaphore|EventWaitHandle|Mutex}.TryOpenExisiting().

mcs/class/System/System.Threading/Semaphore.cs

@@ -29,6 +29,7 @@
 using System.Runtime.ConstrainedExecution;
 using System.Runtime.InteropServices;
 using System.Security.AccessControl;
+using System.Security.Permissions;
 using System.Runtime.CompilerServices;
 using System.IO;
 
@@ -140,6 +141,7 @@ namespace System.Threading {
 
 		// static methods
 
+#if !MOBILE
 		public static Semaphore OpenExisting (string name)
 		{
 			return OpenExisting (name, SemaphoreRights.Synchronize | SemaphoreRights.Modify);
@@ -167,6 +169,53 @@ namespace System.Threading {
 			
 			return(new Semaphore (handle));
 		}
+
+		[SecurityPermissionAttribute (SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+		public static bool TryOpenExisting (string name, out Semaphore result)
+		{
+			return TryOpenExisting (name, SemaphoreRights.Synchronize | SemaphoreRights.Modify, out result);
+		}
+
+		[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
+		public static bool TryOpenExisting (string name, SemaphoreRights rights, out Semaphore result)
+		{
+			if (name == null)
+				throw new ArgumentNullException ("name");
+			if ((name.Length == 0) || (name.Length > 260))
+				throw new ArgumentException ("name", Locale.GetText ("Invalid length [1-260]."));
+			
+			MonoIOError error;
+			IntPtr handle = OpenSemaphore_internal (name, rights, out error);
+
+			if (handle == (IntPtr)null) {
+				result = null;
+				return false;
+			}
+
+			result = new Semaphore (handle);
+			return true;
+		}
+#else
+		public static Semaphore OpenExisting (string name)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public static Semaphore OpenExisting (string name, SemaphoreRights rights)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public static bool TryOpenExisting (string name, out Semaphore result)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public static bool TryOpenExisting (string name, SemaphoreRights rights, out Semaphore result)
+		{
+			throw new NotSupportedException ();
+		}
+#endif
 	}
 }
 

mcs/class/corlib/System.Threading/EventWaitHandle.cs

@@ -29,9 +29,7 @@
 
 using System.IO;
 using System.Runtime.InteropServices;
-#if !NET_2_1
 using System.Security.AccessControl;
-#endif
 
 namespace System.Threading
 {
@@ -57,6 +55,8 @@ namespace System.Threading
 			Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, null, out created);
 		}
 		
+#if !MOBILE
+		
 		public EventWaitHandle (bool initialState, EventResetMode mode,
 					string name)
 		{
@@ -71,7 +71,8 @@ namespace System.Threading
 			bool manual = IsManualReset (mode);
 			Handle = NativeEventCalls.CreateEvent_internal (manual, initialState, name, out createdNew);
 		}
-#if !NET_2_1
+
+
 		[MonoTODO ("Use access control in CreateEvent_internal")]
 		public EventWaitHandle (bool initialState, EventResetMode mode,
 					string name, out bool createdNew,
@@ -119,7 +120,56 @@ namespace System.Threading
 			
 			return(new EventWaitHandle (handle));
 		}
+
+		public static bool TryOpenExisting (string name, out EventWaitHandle result)
+		{
+			return TryOpenExisting (
+				name, EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify, out result);
+		}
+
+		public static bool TryOpenExisting (string name, EventWaitHandleRights rights,
+		                                    out EventWaitHandle result)
+		{
+			if (name == null) {
+				throw new ArgumentNullException ("name");
+			}
+			if ((name.Length == 0) || (name.Length > 260)) {
+				throw new ArgumentException ("name", Locale.GetText ("Invalid length [1-260]."));
+			}
+			
+			MonoIOError error;
+			IntPtr handle = NativeEventCalls.OpenEvent_internal (name, rights, out error);
+			if (handle == (IntPtr)null) {
+				result = null;
+				return false;
+			}
+
+			result = new EventWaitHandle (handle);
+			return true;
+		}
+#else
+		public static EventWaitHandle OpenExisting (string name)
+		{
+			throw new NotSupportedException (); 
+		}
+
+		public static EventWaitHandle OpenExisting (string name, EventWaitHandleRights rights)
+		{
+			throw new NotSupportedException (); 
+		}
+
+		public static bool TryOpenExisting (string name, out EventWaitHandle result)
+		{
+			throw new NotSupportedException (); 
+		}
+
+		public static bool TryOpenExisting (string name, EventWaitHandleRights rights,
+		                                    out EventWaitHandle result)
+		{
+			throw new NotSupportedException (); 
+		}
 #endif
+
 		public bool Reset ()
 		{
 			/* This needs locking since another thread could dispose the handle */

mcs/class/corlib/System.Threading/Mutex.cs

@@ -34,34 +34,32 @@ using System.Security.Permissions;
 using System.Runtime.ConstrainedExecution;
 using System.IO;
 using System.Runtime.InteropServices;
-#if !NET_2_1
 using System.Security.AccessControl;
-#endif
 
 namespace System.Threading
 {
 	[ComVisible (true)]
 	public sealed class Mutex : WaitHandle 
 	{
+		[MethodImplAttribute(MethodImplOptions.InternalCall)]
+		private static extern bool ReleaseMutex_internal(IntPtr handle);
+		
+#if !MOBILE
 		[MethodImplAttribute(MethodImplOptions.InternalCall)]
 		private static extern IntPtr  CreateMutex_internal(
 		                                         bool initiallyOwned,
 		                                         string name,
 							 out bool created);
 
-		[MethodImplAttribute(MethodImplOptions.InternalCall)]
-		private static extern bool ReleaseMutex_internal(IntPtr handle);
-
-#if !NET_2_1
 		[MethodImplAttribute (MethodImplOptions.InternalCall)]
 		private static extern IntPtr OpenMutex_internal (string name, MutexRights rights, out MonoIOError error);
+#endif
 		
 		private Mutex (IntPtr handle)
 		{
 			Handle = handle;
 		}
-#endif
-		
+
 		[ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.MayFail)]
 		public Mutex() {
 			bool created;
@@ -77,6 +75,7 @@ namespace System.Threading
 						    out created);
 		}
 
+#if !MOBILE
 		[ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.MayFail)]
 		[SecurityPermission (SecurityAction.LinkDemand, UnmanagedCode = true)]
 		public Mutex (bool initiallyOwned, string name)
@@ -92,7 +91,6 @@ namespace System.Threading
 			Handle = CreateMutex_internal (initiallyOwned, name, out createdNew);
 		}
 
-#if !NET_2_1
 		[MonoTODO ("Use MutexSecurity in CreateMutex_internal")]
 		[ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.MayFail)]
 		public Mutex (bool initiallyOwned, string name, out bool createdNew, MutexSecurity mutexSecurity)
@@ -140,6 +138,51 @@ namespace System.Threading
 			
 			return(new Mutex (handle));
 		}
+
+		public static bool TryOpenExisting (string name, out Mutex result)
+		{
+			return TryOpenExisting (name, MutexRights.Synchronize | MutexRights.Modify, out result);
+		}
+
+		public static bool TryOpenExisting (string name, MutexRights rights, out Mutex result)
+		{
+			if (name == null) {
+				throw new ArgumentNullException ("name");
+			}
+			if ((name.Length == 0) || (name.Length > 260)) {
+				throw new ArgumentException ("name", Locale.GetText ("Invalid length [1-260]."));
+			}
+			
+			MonoIOError error;
+			IntPtr handle = OpenMutex_internal (name, rights, out error);
+			if (handle == (IntPtr)null) {
+				result = null;
+				return false;
+			}
+
+			result = new Mutex (handle);
+			return true;
+		}
+#else
+		public static Mutex OpenExisting (string name)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public static Mutex OpenExisting (string name, MutexRights rights)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public static bool TryOpenExisting (string name, out Mutex result)
+		{
+			throw new NotSupportedException ();
+		}
+
+		public static bool TryOpenExisting (string name, MutexRights rights, out Mutex result)
+		{
+			throw new NotSupportedException ();
+		}
 #endif
 
 		[ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.MayFail)]

mcs/class/corlib/System.Threading/NativeEventCalls.cs

@@ -34,7 +34,7 @@
 using System;
 using System.Runtime.CompilerServices;
 
-#if !NET_2_1
+#if !MOBILE
 using System.Security.AccessControl;
 using System.IO;
 #endif
@@ -55,7 +55,7 @@ namespace System.Threading
 		[MethodImplAttribute(MethodImplOptions.InternalCall)]
 		public static extern void CloseEvent_internal (IntPtr handle);
 
-#if !NET_2_1
+#if !MOBILE
 		[MethodImplAttribute (MethodImplOptions.InternalCall)]
 		public static extern IntPtr OpenEvent_internal (string name, EventWaitHandleRights rights, out MonoIOError error);
 #endif