Merge pull request #2653 from lambdageek/dev/exception_type-1

[mono.git] / mcs / class / corlib / System.Threading / EventWaitHandle.cs

diff --git a/mcs/class/corlib/System.Threading/EventWaitHandle.cs b/mcs/class/corlib/System.Threading/EventWaitHandle.cs
index a614e8799dc4c5924011ff004faee6ce205e357f..fba21dc3ce56b3a51a69c083fef85fc8fa16763c 100644 (file)
--- a/mcs/class/corlib/System.Threading/EventWaitHandle.cs
+++ b/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,14 +120,82 @@ 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 EventWaitHandle (bool initialState, EventResetMode mode, string name)
+               {
+                       throw new NotSupportedException ();
+               }
+               
+               public EventWaitHandle (bool initialState, EventResetMode mode,
+                                       string name, out bool createdNew)
+               {
+                       throw new NotSupportedException ();
+               }
+               
+               
+               public EventWaitHandle (bool initialState, EventResetMode mode,
+                                       string name, out bool createdNew,
+                                       EventWaitHandleSecurity eventSecurity)
+               {
+                       throw new NotSupportedException ();
+               }
+
+               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 */
                        lock (this) {
                                CheckDisposed ();
                        
-                               return (NativeEventCalls.ResetEvent_internal (Handle));
+                               return NativeEventCalls.ResetEvent (SafeWaitHandle);
                        }
                }
                
@@ -135,9 +204,23 @@ namespace System.Threading
                        lock (this) {
                                CheckDisposed ();
                        
-                               return (NativeEventCalls.SetEvent_internal (Handle));
+                               return NativeEventCalls.SetEvent (SafeWaitHandle);
                        }
                }
+
+               internal void CheckDisposed ()
+               {
+                       if (disposed)
+                               throw new ObjectDisposedException (GetType ().FullName);
+               }
+
+               bool disposed;
+               protected override void Dispose(bool explicitDisposing)
+               {
+                       base.Dispose (explicitDisposing);
+                       disposed = true;
+               }
+
 #if !NET_2_1
                public void SetAccessControl (EventWaitHandleSecurity eventSecurity)
                {