System.Threading.WaitHandle.cs

Posted 2021-03-03 storebook
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了System.Threading.WaitHandle.cs相关的知识，希望对你有一定的参考价值。
ylbtech-System.Threading.WaitHandle.cs
1、
#region 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETFrameworkv4.5mscorlib.dll
#endregion

using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Security;
using Microsoft.Win32.SafeHandles;

namespace System.Threading
{
    //
    // 摘要:
    //     封装等待对共享资源的独占访问的操作系统特定的对象。
    [ComVisible(true)]
    public abstract class WaitHandle : MarshalByRefObject, IDisposable
    {
        //
        // 摘要:
        //     指示在任何等待句柄终止之前 System.Threading.WaitHandle.WaitAny(System.Threading.WaitHandle[],System.Int32,System.Boolean)
        //     操作已超时。 此字段为常数。
        public const int WaitTimeout = 258;
        //
        // 摘要:
        //     表示无效的本机操作系统句柄。 此字段为只读。
        protected static readonly IntPtr InvalidHandle;

        //
        // 摘要:
        //     初始化 System.Threading.WaitHandle 类的新实例。
        protected WaitHandle();

        //
        // 摘要:
        //     获取或设置本机操作系统句柄。
        //
        // 返回结果:
        //     IntPtr，它表示本机操作系统句柄。 默认为 System.Threading.WaitHandle.InvalidHandle 字段的值。
        [Obsolete("Use the SafeWaitHandle property instead.")]
        public virtual IntPtr Handle { get; set; }
        //
        // 摘要:
        //     获取或设置本机操作系统句柄。
        //
        // 返回结果:
        //     表示本机操作系统句柄的 Microsoft.Win32.SafeHandles.SafeWaitHandle。
        public SafeWaitHandle SafeWaitHandle { get; set; }

        //
        // 摘要:
        //     向一个 System.Threading.WaitHandle 发出信号并等待另一个，指定超时间隔为 32 位有符号整数，并指定在进入等待前是否退出上下文的同步域。
        //
        // 参数:
        //   toSignal:
        //     要发出信号的 System.Threading.WaitHandle。
        //
        //   toWaitOn:
        //     要等待的 System.Threading.WaitHandle。
        //
        //   millisecondsTimeout:
        //     一个整数，表示要等待的间隔。 如果值是 System.Threading.Timeout.Infinite，即 -1，则等待是无限期的。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     如果信号发送和等待均成功完成，则为 true；如果信号发送完成，但等待超时，则为 false。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     toSignal 为 null。 - 或 - toWaitOn 为 null。
        //
        //   T:System.NotSupportedException:
        //     对具有 System.STAThreadAttribute 的线程调用了此方法。
        //
        //   T:System.PlatformNotSupportedException:
        //     Windows 98 或 Windows Millennium Edition 不支持此方法。
        //
        //   T:System.InvalidOperationException:
        //     toSignal 是信号量，已达到最大计数。
        //
        //   T:System.InvalidOperationException:
        //     toSignal 是信号量，已达到最大计数。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     millisecondsTimeout 是一个非 -1 的负数，而 -1 表示无限期超时。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        [SecuritySafeCritical]
        public static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, int millisecondsTimeout, bool exitContext);
        //
        // 摘要:
        //     向一个 System.Threading.WaitHandle 发出信号并等待另一个，指定超时间隔为 System.TimeSpan，并指定在进入等待前是否退出上下文的同步域。
        //
        // 参数:
        //   toSignal:
        //     要发出信号的 System.Threading.WaitHandle。
        //
        //   toWaitOn:
        //     要等待的 System.Threading.WaitHandle。
        //
        //   timeout:
        //     一个 System.TimeSpan，表示要等待的间隔。 如果值是 -1，则等待是无限期的。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     如果信号发送和等待均成功完成，则为 true；如果信号发送完成，但等待超时，则为 false。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     toSignal 为 null。 - 或 - toWaitOn 为 null。
        //
        //   T:System.NotSupportedException:
        //     在一个具有 System.STAThreadAttribute 的线程上调用了该方法。
        //
        //   T:System.PlatformNotSupportedException:
        //     Windows 98 或 Windows Millennium Edition 不支持此方法。
        //
        //   T:System.InvalidOperationException:
        //     toSignal 是信号量，已达到最大计数。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     timeout 计算为 -1 以外的负毫秒数。 - 或 - timeout 大于 System.Int32.MaxValue。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        public static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn, TimeSpan timeout, bool exitContext);
        //
        // 摘要:
        //     向一个 System.Threading.WaitHandle 发出信号并等待另一个。
        //
        // 参数:
        //   toSignal:
        //     要发出信号的 System.Threading.WaitHandle。
        //
        //   toWaitOn:
        //     要等待的 System.Threading.WaitHandle。
        //
        // 返回结果:
        //     如果信号和等待都成功完成，则为 true；如果等待没有完成，则此方法不返回。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     toSignal 为 null。 - 或 - toWaitOn 为 null。
        //
        //   T:System.NotSupportedException:
        //     在一个具有 System.STAThreadAttribute 的线程上调用了该方法。
        //
        //   T:System.PlatformNotSupportedException:
        //     Windows 98 或 Windows Millennium Edition 不支持此方法。
        //
        //   T:System.InvalidOperationException:
        //     toSignal 是信号量，已达到最大计数。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        public static bool SignalAndWait(WaitHandle toSignal, WaitHandle toWaitOn);
        //
        // 摘要:
        //     等待指定数组中的所有元素接收信号，同时使用 System.TimeSpan 值指定时间间隔。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。 此数组不能包含对同一对象的多个引用。
        //
        //   timeout:
        //     一个 System.TimeSpan，表示等待的毫秒数；或者一个 System.TimeSpan，表示 -1 毫秒（无限期等待）。
        //
        // 返回结果:
        //     如果 waitHandles 中的每个元素都已收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。 - 或 - waitHandles
        //     是不含任何元素的数组。
        //
        //   T:System.DuplicateWaitObjectException:
        //     waitHandles 数组包含重复的元素。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。 - 或 - System.STAThreadAttribute 特性应用于当前线程的线程过程，且
        //     waitHandles 包含多个元素。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     timeout 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 - 或 - timeout 大于 System.Int32.MaxValue。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout);
        //
        // 摘要:
        //     等待指定数组中的所有元素收到信号，使用 System.Int32 值指定时间间隔，并指定是否在等待之前退出同步域。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。 此数组不能包含对同一对象的多个引用（重复的元素）。
        //
        //   millisecondsTimeout:
        //     等待的毫秒数，或为 System.Threading.Timeout.Infinite (-1)，表示无限期等待。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     如果 waitHandles 中的每个元素都已收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。 - 或 - waitHandles
        //     是不含元素的数组，并且 .NET Framework 的版本为 2.0 或更高。
        //
        //   T:System.DuplicateWaitObjectException:
        //     waitHandles 数组包含重复的元素。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。 - 或 - System.STAThreadAttribute 特性应用于当前线程的线程过程，且
        //     waitHandles 包含多个元素。
        //
        //   T:System.ApplicationException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 1.0 或 1.1。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     millisecondsTimeout 是一个非 -1 的负数，而 -1 表示无限期超时。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        [SecuritySafeCritical]
        public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext);
        //
        // 摘要:
        //     等待指定数组中的所有元素收到信号，使用 System.TimeSpan 值指定时间间隔，并指定是否在等待之前退出同步域。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。 此数组不能包含对同一对象的多个引用。
        //
        //   timeout:
        //     一个 System.TimeSpan，表示等待的毫秒数；或者一个 System.TimeSpan，表示 -1 毫秒（无限期等待）。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     如果 waitHandles 中的每个元素都收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。 - 或 - waitHandles
        //     是不含元素的数组，并且 .NET Framework 的版本为 2.0 或更高。
        //
        //   T:System.DuplicateWaitObjectException:
        //     waitHandles 数组包含重复的元素。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。 - 或 - System.STAThreadAttribute 特性应用于当前线程的线程过程，且
        //     waitHandles 包含多个元素。
        //
        //   T:System.ApplicationException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 1.0 或 1.1。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     timeout 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 - 或 - timeout 大于 System.Int32.MaxValue。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext);
        //
        // 摘要:
        //     等待指定数组中的所有元素都收到信号。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。 此数组不能包含对同一对象的多个引用。
        //
        // 返回结果:
        //     如果 waitHandles 中的每个元素都收到信号，则返回 true；否则该方法永不返回。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。 - 或 - waitHandles
        //     是不含元素的数组，并且 .NET Framework 的版本为 2.0 或更高。
        //
        //   T:System.DuplicateWaitObjectException:
        //     waitHandles 数组包含重复的元素。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。 - 或 - System.STAThreadAttribute 特性应用于当前线程的线程过程，且
        //     waitHandles 包含多个元素。
        //
        //   T:System.ApplicationException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 1.0 或 1.1。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public static bool WaitAll(WaitHandle[] waitHandles);
        //
        // 摘要:
        //     等待指定数组中的所有元素接收信号，同时使用 System.Int32 值指定时间间隔。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。 此数组不能包含对同一对象的多个引用（重复的元素）。
        //
        //   millisecondsTimeout:
        //     等待的毫秒数，或为 System.Threading.Timeout.Infinite (-1)，表示无限期等待。
        //
        // 返回结果:
        //     如果 waitHandles 中的每个元素都已收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。 - 或 - waitHandles
        //     是不含任何元素的数组。
        //
        //   T:System.DuplicateWaitObjectException:
        //     waitHandles 数组包含重复的元素。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。 - 或 - System.STAThreadAttribute 特性应用于当前线程的线程过程，且
        //     waitHandles 包含多个元素。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     millisecondsTimeout 是一个非 -1 的负数，而 -1 表示无限期超时。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout);
        //
        // 摘要:
        //     等待指定数组中的任意元素接收信号，同时使用 32 位带符号整数指定时间间隔。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。
        //
        //   millisecondsTimeout:
        //     等待的毫秒数，或为 System.Threading.Timeout.Infinite (-1)，表示无限期等待。
        //
        // 返回结果:
        //     满足等待的对象的数组索引；如果没有任何对象满足等待，并且等效于 millisecondsTimeout 的时间间隔已过，则为 System.Threading.WaitHandle.WaitTimeout。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     millisecondsTimeout 是一个非 -1 的负数，而 -1 表示无限期超时。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.ArgumentException:
        //     waitHandles 是不含任何元素的数组。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout);
        //
        // 摘要:
        //     等待指定数组中的任一元素收到信号。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。
        //
        // 返回结果:
        //     满足等待的对象的数组索引。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。
        //
        //   T:System.ApplicationException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 1.0 或 1.1。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.ArgumentException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 2.0 或更高。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int WaitAny(WaitHandle[] waitHandles);
        //
        // 摘要:
        //     等待指定数组中的任意元素接收信号，同时使用 System.TimeSpan 指定时间间隔。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。
        //
        //   timeout:
        //     表示等待的毫秒数的 System.TimeSpan，或表示 -1 毫秒（无限期等待）的 System.TimeSpan。
        //
        // 返回结果:
        //     满足等待的对象的数组索引；如果没有任何对象满足等待，并且等效于 timeout 的时间间隔已过，则为 System.Threading.WaitHandle.WaitTimeout。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     timeout 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 - 或 - timeout 大于 System.Int32.MaxValue。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.ArgumentException:
        //     waitHandles 是不含任何元素的数组。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout);
        //
        // 摘要:
        //     等待指定数组中的任一元素收到信号，使用 System.TimeSpan 指定时间间隔并指定是否在等待之前退出同步域。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。
        //
        //   timeout:
        //     表示等待的毫秒数的 System.TimeSpan，或表示 -1 毫秒（无限期等待）的 System.TimeSpan。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     满足等待的对象的数组索引；如果没有任何对象满足等待，并且等效于 timeout 的时间间隔已过，则为 System.Threading.WaitHandle.WaitTimeout。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。
        //
        //   T:System.ApplicationException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 1.0 或 1.1。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     timeout 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 - 或 - timeout 大于 System.Int32.MaxValue。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.ArgumentException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 2.0 或更高。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext);
        //
        // 摘要:
        //     等待指定数组中的任一元素收到信号，使用 32 位带符号整数指定时间间隔并指定是否在等待之前退出同步域。
        //
        // 参数:
        //   waitHandles:
        //     一个 WaitHandle 数组，包含当前实例将等待的对象。
        //
        //   millisecondsTimeout:
        //     等待的毫秒数，或为 System.Threading.Timeout.Infinite (-1)，表示无限期等待。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     满足等待的对象的数组索引；如果没有任何对象满足等待，并且等效于 millisecondsTimeout 的时间间隔已过，则为 System.Threading.WaitHandle.WaitTimeout。
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     waitHandles 参数为 null。 - 或 - waitHandles 数组中的一个或多个对象为 null。
        //
        //   T:System.NotSupportedException:
        //     waitHandles 中对象的数目大于系统允许的数目。
        //
        //   T:System.ApplicationException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 1.0 或 1.1。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     millisecondsTimeout 是一个非 -1 的负数，而 -1 表示无限期超时。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.ArgumentException:
        //     waitHandles 是不含元素的数组，并且 .NET Framework 的版本为 2.0 或更高。
        //
        //   T:System.InvalidOperationException:
        //     waitHandles 数组包含另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        [SecuritySafeCritical]
        public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext);
        //
        // 摘要:
        //     在派生类中被重写时，释放由当前 System.Threading.WaitHandle 持有的所有资源。
        public virtual void Close();
        //
        // 摘要:
        //     释放由 System.Threading.WaitHandle 类的当前实例使用的所有资源。
        public void Dispose();
        //
        // 摘要:
        //     阻止当前线程，直到当前的 System.Threading.WaitHandle 收到信号为止，同时使用 32 位带符号整数指定时间间隔，并指定是否在等待之前退出同步域。
        //
        // 参数:
        //   millisecondsTimeout:
        //     等待的毫秒数，或为 System.Threading.Timeout.Infinite (-1)，表示无限期等待。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     如果当前实例收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     当前实例已被释放。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     millisecondsTimeout 是一个非 -1 的负数，而 -1 表示无限期超时。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     当前实例是另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public virtual bool WaitOne(int millisecondsTimeout, bool exitContext);
        //
        // 摘要:
        //     阻止当前线程，直到当前实例收到信号，同时使用 System.TimeSpan 指定时间间隔。
        //
        // 参数:
        //   timeout:
        //     表示等待的毫秒数的 System.TimeSpan，或表示 -1 毫秒（无限期等待）的 System.TimeSpan。
        //
        // 返回结果:
        //     如果当前实例收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     当前实例已被释放。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     timeout 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 - 或 - timeout 大于 System.Int32.MaxValue。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     当前实例是另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public virtual bool WaitOne(TimeSpan timeout);
        //
        // 摘要:
        //     阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号，同时使用 32 位带符号整数指定时间间隔。
        //
        // 参数:
        //   millisecondsTimeout:
        //     等待的毫秒数，或为 System.Threading.Timeout.Infinite (-1)，表示无限期等待。
        //
        // 返回结果:
        //     如果当前实例收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     当前实例已被释放。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     millisecondsTimeout 是一个非 -1 的负数，而 -1 表示无限期超时。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     当前实例是另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public virtual bool WaitOne(int millisecondsTimeout);
        //
        // 摘要:
        //     使用 System.TimeSpan 指定时间间隔并指定是否在等待之前退出同步域，以此阻止当前线程，直到当前的实例收到信号。
        //
        // 参数:
        //   timeout:
        //     表示等待的毫秒数的 System.TimeSpan，或表示 -1 毫秒（无限期等待）的 System.TimeSpan。
        //
        //   exitContext:
        //     如果等待之前先退出上下文的同步域（如果在同步上下文中），并在稍后重新获取它，则为 true；否则为 false。
        //
        // 返回结果:
        //     如果当前实例收到信号，则为 true；否则为 false。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     当前实例已被释放。
        //
        //   T:System.ArgumentOutOfRangeException:
        //     timeout 是一个非 -1 毫秒的负数，而 -1 表示无限期超时。 - 或 - timeout 大于 System.Int32.MaxValue。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     当前实例是另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public virtual bool WaitOne(TimeSpan timeout, bool exitContext);
        //
        // 摘要:
        //     阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号。
        //
        // 返回结果:
        //     如果当前实例收到信号，则为 true。 如果当前实例永远收不到信号，则 System.Threading.WaitHandle.WaitOne(System.Int32,System.Boolean)
        //     永不返回。
        //
        // 异常:
        //   T:System.ObjectDisposedException:
        //     当前实例已被释放。
        //
        //   T:System.Threading.AbandonedMutexException:
        //     线程退出时未释放互斥体，等待过程已终止。 在 Windows 98 或 Windows Millennium Edition 中不引发此异常。
        //
        //   T:System.InvalidOperationException:
        //     当前实例是另一个应用程序域中的 System.Threading.WaitHandle 的透明代理。
        public virtual bool WaitOne();
        //
        // 摘要:
        //     在派生类中被重写时，释放由 System.Threading.WaitHandle 使用的非托管资源，也可以根据需要释放托管资源。
        //
        // 参数:
        //   explicitDisposing:
        //     true 表示释放托管资源和非托管资源；false 表示仅释放非托管资源。
        [SecuritySafeCritical]
        protected virtual void Dispose(bool explicitDisposing);
    }
}
2、
作者：ylbtech
出处：http://ylbtech.cnblogs.com/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
以上是关于System.Threading.WaitHandle.cs的主要内容，如果未能解决你的问题，请参考以下文章