C# AutoResetEvent.Reset方法代码示例

        public void Test_Add_and_Retrieve()
        {
            var testBooking = CreateTestBooking();

            Booking actual = null;
            var waiter = new AutoResetEvent(false);
            _client.AddBookingAsync(testBooking, booking =>
                {
                    actual = booking;
                    waiter.Set();
                });

            Assert.IsTrue(waiter.WaitOne(1000), "Timeout waiting for WCF asynk result");
            Assert.AreNotSame(testBooking, actual, "WCF trip over the wire should have created a new object through serialisation");

            //Test that Get the saved booking works over WCF
            IEnumerable<Booking> actualBookings = null;
            waiter.Reset();
            _client.GetBookingsAsync(DateTime.Now, bookings =>
            {
                actualBookings = bookings;
                waiter.Set();
            });

            Assert.IsTrue(waiter.WaitOne(1000), "Timeout waiting for WCF asynk result");

            var retrievedBooking = actualBookings.FirstOrDefault();
            Assert.IsNotNull(retrievedBooking, "Bookings should contain created booking");
            Assert.AreEqual(testBooking.Id, retrievedBooking.Id, "Id is not persisted corectly");
            Assert.AreEqual(testBooking.ClientName, retrievedBooking.ClientName, "ClientName is not persisted corectly");
            Assert.AreEqual(testBooking.Duration, retrievedBooking.Duration, "Duration is not persisted corectly");
            Assert.AreEqual(testBooking.Slot, retrievedBooking.Slot, "Slot is not persisted corectly");
        }

        public void CanCaptureAudio()
        {
            int n = 0;
            SoundInTests((c) =>
            {
                for (int i = 0; i < 500; i++)
                {
                    var waitHandle = new AutoResetEvent(true);

                    c.DataAvailable += (s, e) =>
                    {
                        waitHandle.Reset();
                    };

                    c.Initialize();
                    c.Start();

                    if (!waitHandle.WaitOne(2000))
                        Assert.Fail("Timeout");
                    else
                    {
                        Debug.WriteLine(n.ToString());
                        n++;
                    }

                    c.Stop();

                    waitHandle.Dispose();
                }
            });
        }

        static void Main(string[] args)
        {
            using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
            {
                // Add ChannelManager
                ChannelManagerService channelmgr = new ChannelManagerService();
                workflowRuntime.AddService(channelmgr);
                
                AutoResetEvent waitHandle = new AutoResetEvent(false);
                workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { Console.WriteLine("WorkflowCompleted: " + e.WorkflowInstance.InstanceId.ToString()); waitHandle.Set(); };
                workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e) { Console.WriteLine("WorkflowTerminated: " + e.Exception.Message); waitHandle.Set(); };

                while (true)
                {
                    WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(Microsoft.WorkflowServices.Samples.SequentialCalculatorClient));
                    Console.WriteLine("Start SequentialCalculatorClient.");
                    instance.Start();
                    waitHandle.WaitOne();
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("Do another calculation? (Y)");
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("Press <enter> to exit.");
                    Console.ResetColor();
                    string input = Console.ReadLine();
                    if (input.Length == 0 || input[0] != 'Y')
                        break;
                    waitHandle.Reset();
                }
            }
        }

        public void TestRefreshAmount()
        {
            var mock = new MockRepository();
              var getAmountEventReceived = new AutoResetEvent(false);

              var accountServiceMock = mock.StrictMock<IAccountService>();
              var getAmountResetEventMock = mock.StrictMock<AutoResetEvent>();

              var expectedAccountId = new Random().Next(100);
              var accountInfoToTest = new AccountInfo(expectedAccountId, accountServiceMock, getAmountResetEventMock);

              var expectedReturnAmount = new Random().NextDouble();
              Expect.Call(getAmountResetEventMock.WaitOne(0)).Return(true);
              Expect.Call(getAmountResetEventMock.WaitOne(0)).Return(false);
              Expect.Call(accountServiceMock.GetAccountAmount(expectedAccountId)).Return(expectedReturnAmount);
              Expect.Call(getAmountResetEventMock.Set()).Return(true).WhenCalled(MethodInvocation => getAmountEventReceived.Set());
              mock.ReplayAll();

              getAmountEventReceived.Reset();

              accountInfoToTest.RefreshAmount();
              accountInfoToTest.RefreshAmount();

              Assert.IsTrue(getAmountEventReceived.WaitOne(1000));
              Assert.AreEqual(expectedReturnAmount, accountInfoToTest.Amount);

              mock.VerifyAll();
        }

        public Repository OpenRepositoryWithRetry(IAbsoluteDirectoryPath path, bool createWhenNotExisting = false,
            Action failAction = null) {
            if (createWhenNotExisting && !path.Exists)
                return new Repository(path, createWhenNotExisting);

            using (var autoResetEvent = new AutoResetEvent(false))
            using (var fileSystemWatcher =
                new FileSystemWatcher(path.ToString(), "*.lock") {
                    EnableRaisingEvents = true
                }) {
                var lockFile = path.GetChildFileWithName(Repository.LockFile);
                var fp = Path.GetFullPath(lockFile.ToString());
                fileSystemWatcher.Deleted +=
                    (o, e) => {
                        if (Path.GetFullPath(e.FullPath) == fp)
                            autoResetEvent.Set();
                    };

                while (true) {
                    using (var timer = UnlockTimer(lockFile, autoResetEvent)) {
                        try {
                            return new Repository(path, createWhenNotExisting);
                        } catch (RepositoryLockException) {
                            if (failAction != null)
                                failAction();
                            timer.Start();
                            autoResetEvent.WaitOne();
                            lock (timer)
                                timer.Stop();
                            autoResetEvent.Reset();
                        }
                    }
                }
            }
        }

 public void TestDelete()
 {
     FileInfo file = new FileInfo(@"d:\X16-42552VS2010UltimTrial1.txt");
     AutoResetEvent are = new AutoResetEvent(false);
     string key = null;
     HttpCommunicate.Upload(file, (result, warning) =>
     {
         Console.WriteLine("result:" + result);
         key = result + "";
         are.Set();
     }, error =>
     {
         Console.WriteLine("error:" + error);
         are.Set();
     });
     are.WaitOne();
     are.Reset();
     FileDeletePackage package = new FileDeletePackage();
     package.key = key;
     HttpCommunicate.Request(package, (result, warning) =>
     {
         Console.WriteLine("file:" + result);
         are.Set();
     }, error =>
     {
         Console.WriteLine("error:" + error);
         are.Set();
     });
     are.WaitOne();
 }

		public PlaybackSurface()
		{
			// This call is required by the Windows.Forms Form Designer.
			InitializeComponent();
			AREObj = new System.Threading.AutoResetEvent(false);
			AREObj.Reset();
			m_PlaybackControlList = new PlaybackControlList();
			m_bControlsVisible = true;
			txtTime.Text = "000000";
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="server">path to the server, like "http://privatenotes.dyndns-server.com"</param>
        /// <param name="path">path, starting fromt he server root-url, like "/webdav2/username/"</param>
        /// <param name="user">username for login</param>
        /// <param name="pass">pw for login</param>
        /// <param name="checkSSlCertificates">if true, an ssl certificate (if https is used) will be checked,
        /// if false, the ssl check will be ommited (has to be used for self-signed certificates etc)</param>
        public WebDAVInterface(String server, String path, String user, String pass, bool checkSSlCertificates)
        {
            //Logger.Debug("creating server " + server + " path " + path + " user " + user + " pass " + pass);
            client = new WebDAVClient();
            client.Server = server;
            client.BasePath = path;
            client.User = user;
            client.Pass = pass;
            client.SSLCertVerification = checkSSlCertificates;
            autoReset = new AutoResetEvent(false);
            autoReset.Reset();

            client.ListComplete += list;
            client.DownloadComplete += download;
            client.UploadComplete += upload;
            client.DeleteComplete += delete;
        }

        public virtual void ShouldAutomaticallyReleaseDataWhenThreadIsReturnedToThePool()
        {
            try
            {
                ThreadPool.SetMinThreads(1, 1);
                ThreadPool.SetMaxThreads(1, 1);
                var mainEvent = new AutoResetEvent(false);
                int? threadId = null;
                int? otherThreadId = null;
                object data = null;
                ThreadPool.QueueUserWorkItem(
                    delegate(object ev)
                    {
                        LogicContext.SetData("Test4", 100);
                        threadId = Thread.CurrentThread.ManagedThreadId;
                        ((AutoResetEvent)ev).Set();
                    }, 
                    mainEvent);

                mainEvent.WaitOne();

                mainEvent.Reset();

                Assert.IsNotNull(threadId);

                ThreadPool.QueueUserWorkItem(
                    delegate(object ev)
                    {
                        otherThreadId = Thread.CurrentThread.ManagedThreadId;
                        data = LogicContext.FindData("Test4");
                        ((AutoResetEvent)ev).Set();
                    }, 
                    mainEvent);
                mainEvent.WaitOne();

                Assert.IsNotNull(otherThreadId);
                Assert.AreEqual(threadId.Value, otherThreadId.Value);
                Assert.IsNull(data);
            }
            finally
            {
                ThreadPool.SetMinThreads(2, 2);
                ThreadPool.SetMaxThreads(1023, 1000);
            }
        }

        public lineAndScore findBestMoveWithTimeout(baseBoard boardToMove, int timeout)
        {
            findBestMoveBoard = boardToMove;
            Thread findThread = new Thread(findBestMoveWithTimeoutThread);
            evnt = new AutoResetEvent(false);
            evnt.Reset();
            findThread.Start();
            if (evnt.WaitOne(timeout, false))
            {
                if (ex != null)
                    throw ex;
                return bestLine;
            }

            findThread.Abort();

            throw new Exception("Player timeout");
        }

        static void NLoopConsumeTest()
        {
            AutoResetEvent autoResetEvent = new AutoResetEvent(false); //声明 false， WaitOne时线程等待
            while (true)
            {
                autoResetEvent.Reset(); //WaitOne时，使线程等待
                //todo：从队列取数据

                //消费者
                Task.Run(() =>
                {
                    //todo:处理数据
                    autoResetEvent.Set(); //消费完成，允许线程继续
                });
                autoResetEvent.WaitOne(); //等待某个消费者空闲，线程等待

            }
        }

        /// <summary>
        /// fire and forget
        /// </summary>
        /// <param name="millisecondsTimeout"></param>
        /// <param name="method"></param>
        public static void ExecuteMethodWithTimeout(int millisecondsTimeout, Action method)
        {
            AutoResetEvent timeoutEvent = new AutoResetEvent(false);
            Thread methodInvoker = new Thread(delegate()
            {
                method();
                timeoutEvent.Set();
            });

            timeoutEvent.Reset();
            methodInvoker.Start();

            if (timeoutEvent.WaitOne(millisecondsTimeout, false) == false)
            {
                methodInvoker.Abort();
                throw new TimeoutException();
            }
        }

 public void CopyFolder(InventoryFolder dest, InventoryFolder folder)
 {
     UUID newFolderID = Client.Inventory.CreateFolder(dest.UUID, folder.Name, AssetType.Unknown);
     Thread.Sleep(500);
     var items = Client.Inventory.FolderContents(folder.UUID, folder.OwnerID, true, true, InventorySortOrder.ByDate, 45 * 1000);
     AutoResetEvent copied = new AutoResetEvent(false);
     foreach (var item in items)
     {
         if (item is InventoryItem)
         {
             copied.Reset();
             Client.Inventory.RequestCopyItem(item.UUID, newFolderID, item.Name, folder.OwnerID, (InventoryBase target) =>
             {
                 Instance.TabConsole.DisplayNotificationInChat(string.Format("    * Copied {0} to {1}", item.Name, dest.Name));
                 copied.Set();
             });
             copied.WaitOne(15 * 1000, false);
         }
     }
 }

        static void Main(string[] args)
        {
            EventWaitHandle waitHandle = new AutoResetEvent(false);

            Worker worker1 = new Worker("Worker1", waitHandle);
            Worker worker2 = new Worker("Worker2", waitHandle);

            Console.WriteLine("press 'g' to start threads");
            Console.WriteLine("Press 'p' to pause threads");
            Console.WriteLine("Press 'q' to quit");

            Thread.Sleep(2000);

            worker1.Start();
            worker2.Start();

            while (true) {
                ConsoleKey key = Console.ReadKey(true).Key;
                switch (key) {
                    case ConsoleKey.G:
                        Console.WriteLine("starting...");
                        waitHandle.Set();
                        break;
                    case ConsoleKey.P:
                        Console.WriteLine("pausing...");
                        waitHandle.Reset();
                        break;
                    case ConsoleKey.Q:
                        Console.WriteLine("quitting...");
                        worker1.Stop();
                        worker2.Stop();
                        return;
                    default:
                        break;
                }
            }
        }

        /// <summary>
        /// wait for end of execution or timeout
        /// </summary>
        /// <param name="millisecondsTimeout"></param>
        /// <param name="method"></param>
        /// <returns>true if method executed in less than timeout</returns>
        public static bool ExecuteMethodWithTimeoutSync(int millisecondsTimeout, Action method)
        {
            AutoResetEvent timeoutEvent = new AutoResetEvent(false);
            var executed = false;
            Thread methodInvoker = new Thread(delegate()
            {
                method();
                timeoutEvent.Set();
                executed = true;
            });

            timeoutEvent.Reset();
            methodInvoker.Start();

            if (timeoutEvent.WaitOne(millisecondsTimeout, false) == false)
            {
                methodInvoker.Abort();
            }
            else
            {
                methodInvoker.Join();
            }
            return executed;
        }