//[TestMethod] //[PlatformSpecific(TestPlatforms.Windows)] // names aren't supported on Unix public void WaitAll_SameNames() { Mutex[] wh = new Mutex[2]; wh[0] = new Mutex(false, "test"); wh[1] = new Mutex(false, "test"); AssertExtensions.Throws <ArgumentException>(null, () => WaitHandle.WaitAll(wh)); }
public void WaitAny_SameHandles() { ManualResetEvent[] wh = new ManualResetEvent[2]; wh[0] = new ManualResetEvent(true); wh[1] = wh[0]; Assert.AreEqual(0, WaitHandle.WaitAny(wh)); }
public void WaitAll_SameHandles() { ManualResetEvent[] wh = new ManualResetEvent[2]; wh[0] = new ManualResetEvent(true); wh[1] = wh[0]; AssertExtensions.ThrowsAny <ArgumentException>(() => WaitHandle.WaitAll(wh)); }
public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken) { if (millisecondsTimeout < -1) { throw new ArgumentOutOfRangeException("millisecondsTimeout"); } ThrowIfDisposed(); if (!IsSet) { SpinWait wait = new SpinWait(); while (!IsSet) { if (wait.Count < spinCount) { wait.SpinOnce(); continue; } break; } cancellationToken.ThrowIfCancellationRequested(); if (IsSet) { return(true); } WaitHandle handle = WaitHandle; if (cancellationToken.CanBeCanceled) { var result = WaitHandle2.WaitAny(new[] { handle, cancellationToken.WaitHandle }, millisecondsTimeout);//, false); if (result == 1) { throw new InternalOCE(cancellationToken); } if (result == WaitHandle2.WaitTimeout) { return(false); } } else { if (!handle.WaitOne(millisecondsTimeout, false)) { return(false); } } } return(true); }
public void WaitAll() { var handles = new ManualResetEvent[] { new ManualResetEvent(true), new ManualResetEvent(true), new ManualResetEvent(true) }; Assert.IsTrue(WaitHandle.WaitAll(handles)); Assert.IsTrue(WaitHandle.WaitAll(handles, 1)); Assert.IsTrue(WaitHandle.WaitAll(handles, TimeSpan.FromMilliseconds(1))); handles[2].Reset(); Assert.IsFalse(WaitHandle.WaitAll(handles, 1)); Assert.IsFalse(WaitHandle.WaitAll(handles, TimeSpan.FromMilliseconds(1))); }
public void WaitAny() { var handles = new ManualResetEvent[] { new ManualResetEvent(false), new ManualResetEvent(false), new ManualResetEvent(true) }; Assert.AreEqual(2, WaitHandle.WaitAny(handles)); Assert.AreEqual(2, WaitHandle.WaitAny(handles, 1)); Assert.AreEqual(2, WaitHandle.WaitAny(handles, TimeSpan.FromMilliseconds(1))); handles[2].Reset(); Assert.AreEqual(WaitHandle.WaitTimeout, WaitHandle.WaitAny(handles, 1)); Assert.AreEqual(WaitHandle.WaitTimeout, WaitHandle.WaitAny(handles, TimeSpan.FromMilliseconds(1))); }
/// <summary> /// When overridden in a derived class, blocks the current thread until the current instance receives a signal, using a TimeSpan to measure the time interval and specifying whether to exit the synchronization domain before the wait. /// </summary> /// <param name="timeout">A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.</param> /// <param name="notApplicableOnCE">Just pass false</param> /// <returns>true if the current instance receives a signal; otherwise, false.</returns> public bool WaitOne(TimeSpan timeout, bool notApplicableOnCE) { return(NativeMethods.WaitForSingleObject(this.Handle, WaitHandle2.ToTimeoutMilliseconds(timeout)) != NativeMethods.WAIT_TIMEOUT); }
public bool Wait(TimeSpan timeout) => Wait(WaitHandle2.ToTimeoutMilliseconds(timeout));
public void WaitTimeout() { Assert.AreEqual(WaitHandle.WaitTimeout, WaitHandle.WaitAny(new[] { new ManualResetEvent(false) }, 0)); }
public static bool Wait(object obj, TimeSpan timeout) => Wait(obj, WaitHandle2.ToTimeoutMilliseconds(timeout));
public static void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken) => TryEnter(obj, WaitHandle2.ToTimeoutMilliseconds(timeout), ref lockTaken);