We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Threading \ Semaphore

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  16. namespace System.Threading
  17. {
  18.     using System.IO;
  19.     using System.IO.Ports;
  20.     using Microsoft.Win32;
  21.     using Microsoft.Win32.SafeHandles;
  22.     using System.Runtime.InteropServices;
  23.     using System.Threading;
  24.     using System.Security.Permissions;
  25.     using System.Runtime.Versioning;
  26.     using System.Runtime.ConstrainedExecution;
  27.    
  28.    
  29.     [HostProtection(Synchronization = true, ExternalThreading = true)]
  30.     [ComVisibleAttribute(false)]
  31.     public sealed class Semaphore : WaitHandle
  32.     {
  33.         private static int MAX_PATH = 260;
  34.         // creates a nameless semaphore object
  35.         // Win32 only takes maximum count of Int32.MaxValue
  36.         [ResourceExposure(ResourceScope.None)]
  37.         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  38.         public Semaphore(int initialCount, int maximumCount) : this(initialCount, maximumCount, null)
  39.         {
  40.         }
  41.        
  42.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  43.         [ResourceExposure(ResourceScope.Machine)]
  44.         [ResourceConsumption(ResourceScope.Machine)]
  45.         public Semaphore(int initialCount, int maximumCount, string name)
  46.         {
  47.             if (initialCount < 0) {
  48.                 throw new ArgumentOutOfRangeException("initialCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
  49.             }
  50.            
  51.             if (maximumCount < 1) {
  52.                 throw new ArgumentOutOfRangeException("maximumCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
  53.             }
  54.            
  55.             if (initialCount > maximumCount) {
  56.                 throw new ArgumentException(SR.GetString(SR.Argument_SemaphoreInitialMaximum));
  57.             }
  58.            
  59.             if (null != name && MAX_PATH < name.Length) {
  60.                 throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
  61.             }
  62.             SafeWaitHandle myHandle = SafeNativeMethods.CreateSemaphore(null, initialCount, maximumCount, name);
  63.            
  64.             if (myHandle.IsInvalid) {
  65.                 int errorCode = Marshal.GetLastWin32Error();
  66.                
  67.                 if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
  68.                     throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
  69.                
  70.                 InternalResources.WinIOError();
  71.             }
  72.             this.SafeWaitHandle = myHandle;
  73.         }
  74.        
  75.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  76.         [ResourceExposure(ResourceScope.Machine)]
  77.         [ResourceConsumption(ResourceScope.Machine)]
  78.         public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew)
  79.         {
  80.             if (initialCount < 0) {
  81.                 throw new ArgumentOutOfRangeException("initialCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
  82.             }
  83.            
  84.             if (maximumCount < 1) {
  85.                 throw new ArgumentOutOfRangeException("maximumCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
  86.             }
  87.            
  88.             if (initialCount > maximumCount) {
  89.                 throw new ArgumentException(SR.GetString(SR.Argument_SemaphoreInitialMaximum));
  90.             }
  91.            
  92.             if (null != name && MAX_PATH < name.Length) {
  93.                 throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
  94.             }
  95.             SafeWaitHandle myHandle;
  96.             myHandle = SafeNativeMethods.CreateSemaphore(null, initialCount, maximumCount, name);
  97.             int errorCode = Marshal.GetLastWin32Error();
  98.             if (myHandle.IsInvalid) {
  99.                 if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
  100.                     throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
  101.                 InternalResources.WinIOError();
  102.             }
  103.             createdNew = errorCode != NativeMethods.ERROR_ALREADY_EXISTS;
  104.             this.SafeWaitHandle = myHandle;
  105.         }
  106.        
  107.         private Semaphore(SafeWaitHandle handle)
  108.         {
  109.             this.SafeWaitHandle = handle;
  110.         }
  111.        
  112.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  113.         [ResourceExposure(ResourceScope.Machine)]
  114.         [ResourceConsumption(ResourceScope.Machine)]
  115.         public static Semaphore OpenExisting(string name)
  116.         {
  117.             if (name == null) {
  118.                 throw new ArgumentNullException("name");
  119.             }
  120.             if (name.Length == 0) {
  121.                 throw new ArgumentException(SR.GetString(SR.InvalidNullEmptyArgument, "name"), "name");
  122.             }
  123.             if (null != name && MAX_PATH < name.Length) {
  124.                 throw new ArgumentException(SR.GetString(SR.Argument_WaitHandleNameTooLong));
  125.             }
  126.             //Pass false to OpenSemaphore to prevent inheritedHandles
  127.             SafeWaitHandle myHandle = SafeNativeMethods.OpenSemaphore(NativeMethods.SEMAPHORE_MODIFY_STATE | NativeMethods.SYNCHRONIZE, false, name);
  128.            
  129.             if (myHandle.IsInvalid) {
  130.                 int errorCode = Marshal.GetLastWin32Error();
  131.                
  132.                 if (NativeMethods.ERROR_FILE_NOT_FOUND == errorCode || NativeMethods.ERROR_INVALID_NAME == errorCode)
  133.                     throw new WaitHandleCannotBeOpenedException();
  134.                 if (null != name && 0 != name.Length && NativeMethods.ERROR_INVALID_HANDLE == errorCode)
  135.                     throw new WaitHandleCannotBeOpenedException(SR.GetString(SR.WaitHandleCannotBeOpenedException_InvalidHandle, name));
  136.                 //this is for passed through NativeMethods Errors
  137.                 InternalResources.WinIOError();
  138.             }
  139.             return new Semaphore(myHandle);
  140.         }
  141.        
  142.        
  143.         // increase the count on a semaphore, returns previous count
  144.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  145.         [PrePrepareMethod()]
  146.         public int Release()
  147.         {
  148.             return Release(1);
  149.         }
  150.        
  151.         // increase the count on a semaphore, returns previous count
  152.         [ResourceExposure(ResourceScope.None)]
  153.         [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
  154.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  155.         public int Release(int releaseCount)
  156.         {
  157.             if (releaseCount < 1) {
  158.                 throw new ArgumentOutOfRangeException("releaseCount", SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
  159.             }
  160.             int previousCount;
  161.            
  162.             //If ReleaseSempahore returns false when the specified value would cause
  163.             // the semaphore's count to exceed the maximum count set when Semaphore was created
  164.             //Non-Zero return
  165.            
  166.             if (!SafeNativeMethods.ReleaseSemaphore(SafeWaitHandle, releaseCount, out previousCount)) {
  167.                 throw new SemaphoreFullException();
  168.             }
  169.            
  170.             return previousCount;
  171.         }
  172.        
  173.     }
  174. }

Developer Fusion