Remove empty try's (#13493)

* Remove empty try's

* Remove some dead comments

* more

Author: danmoseley

src/mscorlib/shared/System/DateTime.cs

@@ -1025,11 +1025,7 @@ public int Month
         }
 
         // Returns a DateTime representing the current date and time. The
-        // resolution of the returned value depends on the system timer. For
-        // Windows NT 3.5 and later the timer resolution is approximately 10ms,
-        // for Windows NT 3.1 it is approximately 16ms, and for Windows 95 and 98
-        // it is approximately 55ms.
-        //
+        // resolution of the returned value depends on the system timer.
         public static DateTime Now
         {
             get

src/mscorlib/shared/System/DateTimeOffset.cs

@@ -129,11 +129,7 @@ public DateTimeOffset(int year, int month, int day, int hour, int minute, int se
         }
 
         // Returns a DateTimeOffset representing the current date and time. The
-        // resolution of the returned value depends on the system timer. For
-        // Windows NT 3.5 and later the timer resolution is approximately 10ms,
-        // for Windows NT 3.1 it is approximately 16ms, and for Windows 95 and 98
-        // it is approximately 55ms.
-        //
+        // resolution of the returned value depends on the system timer.
         public static DateTimeOffset Now
         {
             get

src/mscorlib/shared/System/IO/FileStream.Windows.cs

@@ -742,9 +742,8 @@ private unsafe void WriteCore(byte[] buffer, int offset, int count)
                 else
                 {
                     // ERROR_INVALID_PARAMETER may be returned for writes
-                    // where the position is too large (i.e. writing at Int64.MaxValue 
-                    // on Win9x) OR for synchronous writes to a handle opened 
-                    // asynchronously.
+                    // where the position is too large or for synchronous writes 
+                    // to a handle opened asynchronously.
                     if (errorCode == ERROR_INVALID_PARAMETER)
                         throw new IOException(SR.IO_FileTooLongOrHandleNotSync);
                     throw Win32Marshal.GetExceptionForWin32Error(errorCode);

src/mscorlib/src/Microsoft/Win32/RegistryKey.cs

@@ -458,9 +458,7 @@ public Object GetValue(String name)
          * Note that <var>name</var> can be null or "", at which point the
          * unnamed or default value of this Registry key is returned, if any.
          * The default values for RegistryKeys are OS-dependent.  NT doesn't
-         * have them by default, but they can exist and be of any type.  On
-         * Win95, the default value is always an empty key of type REG_SZ.
-         * Win98 supports default values of any type, but defaults to REG_SZ.
+         * have them by default, but they can exist and be of any type. 
          *
          * @param name Name of value to retrieve.
          * @param defaultValue Value to return if <i>name</i> doesn't exist.

src/mscorlib/src/System/Diagnostics/Stacktrace.cs

@@ -247,9 +247,6 @@ private void OnDeserialized(StreamingContext context)
 
     // Class which represents a description of a stack trace
     // There is no good reason for the methods of this class to be virtual.  
-    // In order to ensure trusted code can trust the data it gets from a 
-    // StackTrace, we use an InheritanceDemand to prevent partially-trusted
-    // subclasses.
     public class StackTrace
     {
         private StackFrame[] frames;

src/mscorlib/src/System/Environment.cs

@@ -241,44 +241,38 @@ private unsafe static char[] GetEnvironmentCharArray()
         {
             char[] block = null;
 
-            // Make sure pStrings is not leaked with async exceptions
             RuntimeHelpers.PrepareConstrainedRegions();
+
+            char* pStrings = null;
+
             try
             {
-            }
-            finally
-            {
-                char* pStrings = null;
-
-                try
+                pStrings = Win32Native.GetEnvironmentStrings();
+                if (pStrings == null)
                 {
-                    pStrings = Win32Native.GetEnvironmentStrings();
-                    if (pStrings == null)
-                    {
-                        throw new OutOfMemoryException();
-                    }
+                    throw new OutOfMemoryException();
+                }
 
-                    // Format for GetEnvironmentStrings is:
-                    // [=HiddenVar=value\0]* [Variable=value\0]* \0
-                    // See the description of Environment Blocks in MSDN's
-                    // CreateProcess page (null-terminated array of null-terminated strings).
+                // Format for GetEnvironmentStrings is:
+                // [=HiddenVar=value\0]* [Variable=value\0]* \0
+                // See the description of Environment Blocks in MSDN's
+                // CreateProcess page (null-terminated array of null-terminated strings).
 
-                    // Search for terminating \0\0 (two unicode \0's).
-                    char* p = pStrings;
-                    while (!(*p == '\0' && *(p + 1) == '\0'))
-                        p++;
+                // Search for terminating \0\0 (two unicode \0's).
+                char* p = pStrings;
+                while (!(*p == '\0' && *(p + 1) == '\0'))
+                    p++;
 
-                    int len = (int)(p - pStrings + 1);
-                    block = new char[len];
+                int len = (int)(p - pStrings + 1);
+                block = new char[len];
 
-                    fixed (char* pBlock = block)
-                        string.wstrcpy(pBlock, pStrings, len);
-                }
-                finally
-                {
-                    if (pStrings != null)
-                        Win32Native.FreeEnvironmentStrings(pStrings);
-                }
+                fixed (char* pBlock = block)
+                    string.wstrcpy(pBlock, pStrings, len);
+            }
+            finally
+            {
+                if (pStrings != null)
+                    Win32Native.FreeEnvironmentStrings(pStrings);
             }
 
             return block;

src/mscorlib/src/System/Reflection/RuntimeConstructorInfo.cs

@@ -57,8 +57,7 @@ internal INVOCATION_FLAGS InvocationFlags
                         // this should be an invocable method, determine the other flags that participate in invocation
                         invocationFlags |= RuntimeMethodHandle.GetSecurityFlags(this);
 
-                        // Check for attempt to create a delegate class, we demand unmanaged
-                        // code permission for this since it's hard to validate the target address.
+                        // Check for attempt to create a delegate class.
                         if (typeof(Delegate).IsAssignableFrom(DeclaringType))
                             invocationFlags |= INVOCATION_FLAGS.INVOCATION_FLAGS_IS_DELEGATE_CTOR;
                     }

src/mscorlib/src/System/Runtime/InteropServices/CriticalHandle.cs

@@ -130,13 +130,7 @@ with the following type of signature (CreateFile follows this model).
 
 namespace System.Runtime.InteropServices
 {
-    // This class should not be serializable - it's a handle.  We require unmanaged
-    // code permission to subclass CriticalHandle to prevent people from writing a 
-    // subclass and suddenly being able to run arbitrary native code with the
-    // same signature as CloseHandle.  This is technically a little redundant, but
-    // we'll do this to ensure we've cut off all attack vectors.  Similarly, all
-    // methods have a link demand to ensure untrusted code cannot directly edit
-    // or alter a handle.
+    // This class should not be serializable - it's a handle
     public abstract class CriticalHandle : CriticalFinalizerObject, IDisposable
     {
         // ! Do not add or rearrange fields as the EE depends on this layout.

src/mscorlib/src/System/Runtime/InteropServices/SafeBuffer.cs

@@ -173,15 +173,10 @@ public void AcquirePointer(ref byte* pointer)
 
             pointer = null;
             RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-            }
-            finally
-            {
-                bool junk = false;
-                DangerousAddRef(ref junk);
-                pointer = (byte*)handle;
-            }
+
+            bool junk = false;
+            DangerousAddRef(ref junk);
+            pointer = (byte*)handle;
         }
 
         public void ReleasePointer()

src/mscorlib/src/System/Runtime/MemoryFailPoint.cs

@@ -241,24 +241,20 @@ public MemoryFailPoint(int sizeInMegabytes)
                         // Attempt to grow the OS's page file.  Note that we ignore
                         // any allocation routines from the host intentionally.
                         RuntimeHelpers.PrepareConstrainedRegions();
-                        try
-                        {
-                        }
-                        finally
+
+                        // This shouldn't overflow due to the if clauses above.
+                        UIntPtr numBytes = new UIntPtr(segmentSize);
+                        unsafe
                         {
-                            // This shouldn't overflow due to the if clauses above.
-                            UIntPtr numBytes = new UIntPtr(segmentSize);
-                            unsafe
+                            void* pMemory = Win32Native.VirtualAlloc(null, numBytes, Win32Native.MEM_COMMIT, Win32Native.PAGE_READWRITE);
+                            if (pMemory != null)
                             {
-                                void* pMemory = Win32Native.VirtualAlloc(null, numBytes, Win32Native.MEM_COMMIT, Win32Native.PAGE_READWRITE);
-                                if (pMemory != null)
-                                {
-                                    bool r = Win32Native.VirtualFree(pMemory, UIntPtr.Zero, Win32Native.MEM_RELEASE);
-                                    if (!r)
-                                        __Error.WinIOError();
-                                }
+                                bool r = Win32Native.VirtualFree(pMemory, UIntPtr.Zero, Win32Native.MEM_RELEASE);
+                                if (!r)
+                                    __Error.WinIOError();
                             }
                         }
+
                         continue;
 
                     case 2:
@@ -304,14 +300,9 @@ public MemoryFailPoint(int sizeInMegabytes)
                 CheckForFreeAddressSpace(segmentSize, true);
 
             RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-            }
-            finally
-            {
-                SharedStatics.AddMemoryFailPointReservation((long)size);
-                _mustSubtractReservation = true;
-            }
+
+            SharedStatics.AddMemoryFailPointReservation((long)size);
+            _mustSubtractReservation = true;
 #endif
         }
 
@@ -414,14 +405,9 @@ private void Dispose(bool disposing)
             if (_mustSubtractReservation)
             {
                 RuntimeHelpers.PrepareConstrainedRegions();
-                try
-                {
-                }
-                finally
-                {
-                    SharedStatics.AddMemoryFailPointReservation(-((long)_reservedMemory));
-                    _mustSubtractReservation = false;
-                }
+
+                SharedStatics.AddMemoryFailPointReservation(-((long)_reservedMemory));
+                _mustSubtractReservation = false;
             }
 
             /*

src/mscorlib/src/System/Runtime/Reliability/CriticalFinalizerObject.cs

@@ -11,7 +11,6 @@
 ** (i.e. the finalizer is guaranteed to run, won't be aborted by the host and is
 ** run after the finalizers of other objects collected at the same time).
 **
-** You must possess UnmanagedCode permission in order to derive from this class.
 **
 ** 
 ===========================================================*/

src/mscorlib/src/System/Threading/ThreadPool.cs

@@ -790,16 +790,11 @@ internal void SetWaitObject(WaitHandle waitObject)
         {
             // needed for DangerousAddRef
             RuntimeHelpers.PrepareConstrainedRegions();
-            try
+
+            m_internalWaitObject = waitObject;
+            if (waitObject != null)
             {
-            }
-            finally
-            {
-                m_internalWaitObject = waitObject;
-                if (waitObject != null)
-                {
-                    m_internalWaitObject.SafeWaitHandle.DangerousAddRef(ref bReleaseNeeded);
-                }
+                m_internalWaitObject.SafeWaitHandle.DangerousAddRef(ref bReleaseNeeded);
             }
         }
 
@@ -810,47 +805,43 @@ WaitHandle waitObject          // object to be notified when all callbacks to de
             bool result = false;
             // needed for DangerousRelease
             RuntimeHelpers.PrepareConstrainedRegions();
-            try
-            {
-            }
-            finally
+
+            // lock(this) cannot be used reliably in Cer since thin lock could be
+            // promoted to syncblock and that is not a guaranteed operation
+            bool bLockTaken = false;
+            do
             {
-                // lock(this) cannot be used reliably in Cer since thin lock could be
-                // promoted to syncblock and that is not a guaranteed operation
-                bool bLockTaken = false;
-                do
+                if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
                 {
-                    if (Interlocked.CompareExchange(ref m_lock, 1, 0) == 0)
+                    bLockTaken = true;
+                    try
                     {
-                        bLockTaken = true;
-                        try
+                        if (ValidHandle())
                         {
-                            if (ValidHandle())
+                            result = UnregisterWaitNative(GetHandle(), waitObject == null ? null : waitObject.SafeWaitHandle);
+                            if (result == true)
                             {
-                                result = UnregisterWaitNative(GetHandle(), waitObject == null ? null : waitObject.SafeWaitHandle);
-                                if (result == true)
+                                if (bReleaseNeeded)
                                 {
-                                    if (bReleaseNeeded)
-                                    {
-                                        m_internalWaitObject.SafeWaitHandle.DangerousRelease();
-                                        bReleaseNeeded = false;
-                                    }
-                                    // if result not true don't release/suppress here so finalizer can make another attempt
-                                    SetHandle(InvalidHandle);
-                                    m_internalWaitObject = null;
-                                    GC.SuppressFinalize(this);
+                                    m_internalWaitObject.SafeWaitHandle.DangerousRelease();
+                                    bReleaseNeeded = false;
                                 }
+                                // if result not true don't release/suppress here so finalizer can make another attempt
+                                SetHandle(InvalidHandle);
+                                m_internalWaitObject = null;
+                                GC.SuppressFinalize(this);
                             }
                         }
-                        finally
-                        {
-                            m_lock = 0;
-                        }
                     }
-                    Thread.SpinWait(1);     // yield to processor
+                    finally
+                    {
+                        m_lock = 0;
+                    }
                 }
-                while (!bLockTaken);
+                Thread.SpinWait(1);     // yield to processor
             }
+            while (!bLockTaken);
+
             return result;
         }