public WaitForAll(AsyncCallback callbackWhenOver, object asyncState) { callbackResults = new Dictionary<string, IAsyncResult>(); this.callbackWhenOver = callbackWhenOver; this.asyncState = asyncState; handle = new AutoResetEvent(false); }
internal AnalysisQueue(VsProjectAnalyzer analyzer) { _workEvent = new AutoResetEvent(false); _cancel = new CancellationTokenSource(); _analyzer = analyzer; // save the analysis once it's ready, but give us a little time to be // initialized and start processing stuff... _lastSave = DateTime.Now - _SaveAnalysisTime + TimeSpan.FromSeconds(10); _queue = new List<IAnalyzable>[PriorityCount]; for (int i = 0; i < PriorityCount; i++) { _queue[i] = new List<IAnalyzable>(); } _enqueuedGroups = new HashSet<IGroupableAnalysisProject>(); _workThread = new Thread(Worker); _workThread.Name = "Node.js Analysis Queue"; _workThread.Priority = ThreadPriority.BelowNormal; _workThread.IsBackground = true; // start the thread, wait for our synchronization context to be created using (AutoResetEvent threadStarted = new AutoResetEvent(false)) { _workThread.Start(threadStarted); threadStarted.WaitOne(); } }
// Initialize Parallel class's instance creating required number of threads // and synchronization objects private void Initialize( ) { threadsCount = System.Environment.ProcessorCount; //No point starting new threads for a single core computer if (threadsCount <= 1) { return; } // array of events, which signal about available job jobAvailable = new AutoResetEvent[threadsCount]; // array of events, which signal about available thread threadIdle = new ManualResetEvent[threadsCount]; // array of threads threads = new Thread[threadsCount]; for ( int i = 0; i < threadsCount; i++ ) { jobAvailable[i] = new AutoResetEvent( false ); threadIdle[i] = new ManualResetEvent( true ); threads[i] = new Thread( new ParameterizedThreadStart( WorkerThread ) ); threads[i].IsBackground = false; threads[i].Start( i ); } }
public multi_downloader(string[] files, string dest_dir, System.Threading.AutoResetEvent resetEvent, int threads = -1) { this.files = files; this.dest_dir = dest_dir; this.resetEvent = resetEvent; started_count = 0; parallel_count = threads > 0 ? threads : parallel_count; downloader = new download_file[parallel_count]; for (int i = 0; i < parallel_count; i++) { downloader[i] = new download_file(DestinationDir, i + 1); downloader[i].DownloadProgress += new DownloadProgressHandler(download_progress); downloader[i].DownloadCompleted += new DownloadCompletedHandler(download_completed); } Console.WriteLine(string.Format(@" Downloader started. {0} files to be downloaded. Download directory: ""{1}"" Parallel in: {2} threads ============================ " , files.Count(), dest_dir, parallel_count)); }
/// <summary> /// Constructor /// </summary> /// <param name="action">Action</param> /// <param name="synchronizeWithUpdate">Whether to sync with the main thread update loop</param> internal EZThreadRunner(Action action, bool synchronizeWithUpdate) { this.action = action; this.running = true; if (synchronizeWithUpdate) { SyncEvent = new System.Threading.AutoResetEvent(true); } #if TASK_AVAILABLE if (synchronizeWithUpdate) { Task.Factory.StartNew(ThreadFunctionSync); } else { Task.Factory.StartNew(ThreadFunction); } #else WaitCallback w; if (synchronizeWithUpdate) { w = new WaitCallback((s) => ThreadFunctionSync()); } else { w = new WaitCallback((s) => ThreadFunction()); } ThreadPool.QueueUserWorkItem(w); #endif }
public void Promise_Reject_UserInfo() { var args = default(object[]); var are = new AutoResetEvent(false); var resolve = new MockCallback(_ => { }); var reject = new MockCallback(a => { args = a; are.Set(); }); var promise = new Promise(resolve, reject); var code = "42"; var message = "foo"; var e = new Exception(); e.Data.Add("qux", "baz"); promise.Reject(code, message, e); are.WaitOne(); Assert.IsNotNull(args); Assert.AreEqual(1, args.Length); var json = args[0] as JObject; Assert.IsNotNull(json); var userInfo = json["userInfo"] as JObject; Assert.IsNotNull(userInfo); Assert.AreEqual("baz", userInfo["qux"]); }
public void GetShopsByNameLowDetailRetrievalTest() { // ARANGE using (AutoResetEvent waitEvent = new AutoResetEvent(false)) { ResultEventArgs<Shops> result = null; IShopService shopsService = new ShopService(new EtsyContext(NetsyData.EtsyApiKey)); shopsService.GetShopsByNameCompleted += (s, e) => { result = e; waitEvent.Set(); }; // ACT shopsService.GetShopsByName("fred", SortOrder.Up, 0, 10, DetailLevel.Low); bool signalled = waitEvent.WaitOne(NetsyData.WaitTimeout); // ASSERT // check that the event was fired, did not time out Assert.IsTrue(signalled, "Not signalled"); // check the data TestHelpers.CheckResultSuccess(result); Assert.IsNotNull(result.ResultValue.Results); Assert.IsTrue(result.ResultStatus.Success); Assert.IsTrue(result.ResultValue.Count > 0); } }
public void Start() { startedEvent = new AutoResetEvent(false); Thread t = new Thread(Execute); t.Start(); }
public Form2(String hostPort, Form1 form1) { // // Required for Windows Form Designer support // InitializeComponent(); // // TODO: Add any constructor code after InitializeComponent call // dataReadyToSend = new AutoResetEvent(false); refToForm1 = form1; // Resolve the local host. IPHostEntry localHost = Dns.Resolve(Dns.GetHostName()); // Create a local end point for listening. IPEndPoint localEndPoint = new IPEndPoint(localHost.AddressList[0], 4001); // Instantiate the TCP Listener. tcpListener = new TcpListener(localEndPoint); tcpListener.Start(); tcp = tcpListener.AcceptTcpClient(); ethernetThreadStart = new ThreadStart(this.ThreadProcPollOnEthernet); pollDevicesEthernetThread = new Thread(ethernetThreadStart); pollDevicesEthernetThread.Name = "Listener's Receive Thread"; pollDevicesEthernetThread.ApartmentState = System.Threading.ApartmentState.MTA; pollDevicesEthernetThread.Start(); }
public void Send_to_standIn() { var cre = PubnubCredentials.LoadFrom("pubnub credentials.txt"); using(var sut = new PubnubHostTransceiver(cre, "hostchannel")) { var standIn = new Pubnub(cre.PublishingKey, cre.SubscriptionKey, cre.SecretKey); try { var standInChannel = Guid.NewGuid().ToString(); var are = new AutoResetEvent(false); ReadOnlyCollection<object> result = null; standIn.subscribe(standInChannel, (ReadOnlyCollection<object> _) => { result = _; are.Set(); }); var ho = new HostOutput{CorrelationId = Guid.NewGuid(), Data = "hello".Serialize(), Portname = "portname"}; sut.SendToStandIn(new Tuple<string, HostOutput>(standInChannel, ho)); Assert.IsTrue(are.WaitOne(5000)); var hoReceived = Convert.FromBase64String((string)((JValue)result[0]).Value).Deserialize() as HostOutput; Assert.AreEqual(ho.CorrelationId, hoReceived.CorrelationId); Assert.AreEqual(ho.Data, hoReceived.Data); Assert.AreEqual(ho.Portname, hoReceived.Portname); } finally { standIn.subscribe("standIn", _ => {}); } } }
static Reader() { Thread inputThread = new Thread(Run) {IsBackground = true}; inputThread.Start(); GetInput = new AutoResetEvent(false); GotInput = new AutoResetEvent(false); }
public void DisconnectAsync_Success() { AutoResetEvent completed = new AutoResetEvent(false); IPEndPoint loopback = new IPEndPoint(IPAddress.Loopback, 0); using (var server1 = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, loopback)) using (var server2 = SocketTestServer.SocketTestServerFactory(SocketImplementationType.Async, loopback)) { SocketAsyncEventArgs args = new SocketAsyncEventArgs(); args.Completed += OnCompleted; args.UserToken = completed; args.RemoteEndPoint = server1.EndPoint; args.DisconnectReuseSocket = true; using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { Assert.True(client.ConnectAsync(args)); completed.WaitOne(); Assert.Equal(SocketError.Success, args.SocketError); Assert.True(client.DisconnectAsync(args)); completed.WaitOne(); Assert.Equal(SocketError.Success, args.SocketError); args.RemoteEndPoint = server2.EndPoint; Assert.True(client.ConnectAsync(args)); completed.WaitOne(); Assert.Equal(SocketError.Success, args.SocketError); } } }
public void GetMethodTableCallTest() { // ARRANGE using (AutoResetEvent waitEvent = new AutoResetEvent(false)) { ResultEventArgs<MethodTable> result = null; IServerService serverService = new ServerService(new EtsyContext(NetsyData.EtsyApiKey)); serverService.GetMethodTableCompleted += (s, e) => { result = e; waitEvent.Set(); }; // ACT serverService.GetMethodTable(); bool signalled = waitEvent.WaitOne(Constants.WaitTimeout); // ASSERT // check that the event was fired, did not time out Assert.IsTrue(signalled, "Not signalled"); // check the data Assert.IsNotNull(result); TestHelpers.CheckResultSuccess(result); Assert.IsTrue(result.ResultValue.Count > 1); Assert.IsTrue(result.ResultValue.Results.Length > 1); Assert.IsNull(result.ResultValue.Params); } }
public void TestArbitrary() { AutoResetEvent are = new AutoResetEvent(false); var client = new AustinHarris.JsonRpc.JsonRpcClient(remoteUri); var arbitrary = new Newtonsoft.Json.Linq.JObject(); JObject r = null; Exception e = null; for (int i = 0; i < 10; i++) { arbitrary[getPrintableString(10)] = getPrintableString(20); arbitrary[getNonPrintableString(10)] = getNonPrintableString(20); arbitrary[getExtendedAsciiString(10)] = getExtendedAsciiString(20); } var myObs = client.Invoke<Newtonsoft.Json.Linq.JObject>("testArbitraryJObject", arbitrary, Scheduler.TaskPool); using(myObs.Subscribe( onNext: (jo) => { r = jo.Result; }, onError: _ => { e = _; }, onCompleted: () => are.Set() )) { are.WaitOne(); }; Assert.IsTrue(r.ToString() == arbitrary.ToString()); Assert.IsTrue(e == null); }
public void when_sending_message_with_session_then_session_receiver_gets_both_messages_fast() { var sender = this.Settings.CreateTopicClient(this.Topic); var signal = new AutoResetEvent(false); var body1 = Guid.NewGuid().ToString(); var body2 = Guid.NewGuid().ToString(); var stopWatch = new Stopwatch(); var receiver = new SessionSubscriptionReceiver(this.Settings, this.Topic, this.Subscription); sender.Send(new BrokeredMessage(body1) { SessionId = "foo" }); sender.Send(new BrokeredMessage(body2) { SessionId = "bar" }); var received = new ConcurrentBag<string>(); receiver.Start( m => { received.Add(m.GetBody<string>()); signal.Set(); return MessageReleaseAction.CompleteMessage; }); signal.WaitOne(); stopWatch.Start(); signal.WaitOne(); stopWatch.Stop(); receiver.Stop(); Assert.Contains(body1, received); Assert.Contains(body2, received); Assert.InRange(stopWatch.Elapsed, TimeSpan.Zero, TimeSpan.FromSeconds(2)); }
public void GetShopsByNameApiKeyInvalidTest() { // ARRANGE using (AutoResetEvent waitEvent = new AutoResetEvent(false)) { ResultEventArgs<Shops> result = null; IShopService shopsService = new ShopService(new EtsyContext("InvalidKey")); shopsService.GetShopsByNameCompleted += (s, e) => { result = e; waitEvent.Set(); }; // ACT shopsService.GetShopsByName("fred", SortOrder.Up, 0, 10, DetailLevel.Low); bool signalled = waitEvent.WaitOne(NetsyData.WaitTimeout); // ASSERT // check that the event was fired, did not time out Assert.IsTrue(signalled, "Not signalled"); // check the data - should fail Assert.IsNotNull(result); Assert.IsNotNull(result.ResultStatus); Assert.IsFalse(result.ResultStatus.Success); Assert.AreEqual(WebExceptionStatus.ProtocolError, result.ResultStatus.WebStatus); } }
public void ConsumeMessagesOnMultipleWorkerThreads() { const int NumerOfMessages = 1000; this.module.ConsumeDelay = TimeSpan.FromMilliseconds(0); this.testee = new ModuleController(); this.testee.Initialize(this.module, 10); for (int i = 0; i < NumerOfMessages; i++) { this.testee.EnqueueMessage(i); } AutoResetEvent signal = new AutoResetEvent(false); int count = 0; object padlock = new object(); this.testee.AfterConsumeMessage += delegate { lock (padlock) { count++; if (count == NumerOfMessages) { signal.Set(); } } }; this.testee.Start(); Assert.IsTrue(signal.WaitOne(10000, false), "not all messages consumed. Consumed " + this.module.Messages.Count); this.testee.Stop(); }
private void EhThreadBody() { while (_keepThreadRunning) { try { ProcessInvokerQueue(); _triggeringEvent.WaitOne(_safetyIntervalTime_msec); } catch (Exception ex) { // the exception must be re-thrown on the Gui thread in order to be handled _dispatcherForReThrowingExceptions.Invoke((Action <Exception>)ReThrow, new object[] { ex }); } } // Process the invoker queue one last time ProcessInvokerQueue(); var locTriggerEvent = _triggeringEvent; if (null != locTriggerEvent) { locTriggerEvent.Dispose(); } _triggeringEvent = null; _thread = null; }
/// <summary> /// Constructs an Engine for the specified Debugger. /// </summary> /// <param name="debugger">Debugger instance.</param> public Engine(Debugger debugger) { Debugger = debugger; _pause = false; _stop = false; AllowedToContinue = new AutoResetEvent(false); }
/// <summary> /// Default constructor, Instantiates a new copy of the TexturePipeline class /// </summary> /// <param name="client">Reference to the instantiated <see cref="GridClient"/> object</param> public TexturePipeline(GridClient client) { _Client = client; maxTextureRequests = client.Settings.MAX_CONCURRENT_TEXTURE_DOWNLOADS; resetEvents = new AutoResetEvent[maxTextureRequests]; threadpoolSlots = new int[maxTextureRequests]; _Transfers = new Dictionary <UUID, TaskInfo>(); // Pre-configure autoreset events and threadpool slots for (int i = 0; i < maxTextureRequests; i++) { resetEvents[i] = new AutoResetEvent(true); threadpoolSlots[i] = -1; } // Handle client connected and disconnected events client.Network.LoginProgress += delegate(object sender, LoginProgressEventArgs e) { if (e.Status == LoginStatus.Success) { Startup(); } }; client.Network.Disconnected += delegate { Shutdown(); }; }
/// <summary> /// Initialise a new channel. /// </summary> /// <param name="i">The backlog for this channel, or 0 for infinite.</param> public Channel(int i = 0) { backlog = i; queue = new Queue <T>(); reset = new AutoResetEvent(false); resetR = new AutoResetEvent(false); }
public static void Main(string[] args) { var timeout = Int32.Parse(args[0]); var waitEvent = new System.Threading.AutoResetEvent(false); var hr = new HandlerRoutine(type => { Console.WriteLine($"ConsoleCtrlHandler got signal: {type}"); Console.WriteLine("Waiting for shutdown."); for (int countdown = 1; countdown <= timeout; countdown++) { Console.WriteLine($"{countdown}"); System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1)); } Console.WriteLine("Done waiting - setting event and exiting."); waitEvent.Set(); return(false); }); SetConsoleCtrlHandler(hr, true); Console.WriteLine("Shutdown will wait {0} seconds.", timeout); Console.WriteLine("Waiting on handler to trigger"); waitEvent.WaitOne(); GC.KeepAlive(hr); }
public void Should_be_able_to_do_basic_request_async() { const string expectedResult = "Sending back 'Ninja!!'"; var autoResetEvent = new AutoResetEvent(false); bus.Respond<TestRequestMessage, TestResponseMessage>(request => { var response = new TestResponseMessage { Text = string.Format("Sending back '{0}'", request.Text) }; return response; }); var actualResult = string.Empty; using (var channel = bus.OpenPublishChannel()) { var request = new TestRequestMessage { Text = "Ninja!!" }; var responseTask = channel.RequestAsync<TestRequestMessage, TestResponseMessage>(request); responseTask.ContinueWith(t => { actualResult = t.Result.Text; autoResetEvent.Set(); }); } // give the bus a chance to deliver the message autoResetEvent.WaitOne(1000); actualResult.ShouldEqual(expectedResult); }
public int Run(PlayerOptions options) { SynchronizationContext.SetSynchronizationContext(new SynchronizationContext()); int res = Initialize(options); if (res != 0) { return(res); } if (!options.NonInteractive) { Console.WriteLine(StringResources.PressKeyToExit); Console.ReadKey(); } else { m_IsDaemon = options.Daemon; m_NonInteractiveWaitEvent = new System.Threading.AutoResetEvent(false); bool shutdown = false; while (!shutdown) { m_NonInteractiveWaitEvent.WaitOne(200); lock (m_LockObject) { shutdown = m_Shutdown; } } } Shutdown(); return(0); }
public void Should_not_overwrite_correlation_id() { var autoResetEvent = new AutoResetEvent(false); const string expectedCorrelationId = "abc_foo"; var actualCorrelationId = ""; var queue = EasyNetQ.Topology.Queue.DeclareDurable("myqueue"); var exchange = EasyNetQ.Topology.Exchange.DeclareDirect("myexchange"); queue.BindTo(exchange, "#"); bus.Subscribe<MyMessage>(queue, (message, info) => Task.Factory.StartNew(() => { actualCorrelationId = message.Properties.CorrelationId; autoResetEvent.Set(); })); var messageToSend = new Message<MyMessage>(new MyMessage()); messageToSend.Properties.CorrelationId = expectedCorrelationId; using (var channel = bus.OpenPublishChannel()) { channel.Publish(exchange, "abc", messageToSend); } autoResetEvent.WaitOne(1000); actualCorrelationId.ShouldEqual(expectedCorrelationId); }
private PriceDTO GetMarketInfo(int marketId) { IStreamingListener<PriceDTO> listener = null; PriceDTO marketInfo = null; try { listener = _streamingClient.BuildPricesListener(marketId); var gate = new AutoResetEvent(false); listener.MessageReceived += (o, s) => { marketInfo = s.Data; gate.Set(); }; if (!gate.WaitOne(10000)) { throw new Exception("timed out waiting for market data"); } } finally { _streamingClient.TearDownListener(listener); } return marketInfo; }
protected void Test1(IDatagramEventSocket[] sockets, EndPoint[] endPoints) { byte[] sendData = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; int recvIdx = -1, recvSize = -1; byte[] recvData = null; AutoResetEvent done = new AutoResetEvent (false); for (int i = 0; i < sockets.Length; i++) { sockets[i].Bind (endPoints[i]); sockets[i].Received += new DatagramReceiveEventHandler (delegate (object sender, DatagramReceiveEventArgs e) { recvIdx = Array.IndexOf<IDatagramEventSocket> (sockets, sender as IDatagramEventSocket); recvSize = e.Size; recvData = (byte[])e.Buffer.Clone (); done.Set (); }); } for (int i = 0; i < sockets.Length; i++) { for (int k = 0; k < endPoints.Length; k++) { sockets[i].SendTo (sendData, endPoints[k]); done.WaitOne (); Array.Resize<byte> (ref recvData, recvSize); string id = "#" + (i + 1).ToString () + "." + (k + 1).ToString (); Assert.AreEqual (k, recvIdx, id + ".1"); Assert.AreEqual (sendData.Length, recvSize, id + ".2"); Assert.AreEqual (sendData, recvData, id + ".3"); } } }
public async Task TestMICRenderURLScopeID() { // Arrange var builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); var client = builder.Build(); var autoEvent = new System.Threading.AutoResetEvent(false); string urlToTestForScopeID = String.Empty; var micDelegate = new KinveyMICDelegate <User>() { onError = (user) => { }, onSuccess = (error) => { }, onReadyToRender = (url) => { urlToTestForScopeID = url; autoEvent.Set(); } }; // Act User.LoginWithMIC("mytestredirectURI", micDelegate); bool signal = autoEvent.WaitOne(5000); // Assert Assert.IsTrue(signal); Assert.IsFalse(urlToTestForScopeID.Equals(string.Empty)); Assert.IsTrue(urlToTestForScopeID.Contains("scope=openid")); }
FacetedMesh MeshPrim(Primitive prim) { FacetedMesh mesh = null; if (prim.Sculpt == null || prim.Sculpt.SculptTexture == UUID.Zero) { mesh = Mesher.GenerateFacetedMesh(prim, DetailLevel.Highest); } else if (prim.Sculpt.Type != SculptType.Mesh) { Image img = null; if (LoadTexture(prim.Sculpt.SculptTexture, ref img, true)) { mesh = Mesher.GenerateFacetedSculptMesh(prim, (Bitmap)img, DetailLevel.Highest); } } else { var gotMesh = new System.Threading.AutoResetEvent(false); Client.Assets.RequestMesh(prim.Sculpt.SculptTexture, (success, meshAsset) => { if (!success || !FacetedMesh.TryDecodeFromAsset(prim, meshAsset, DetailLevel.Highest, out mesh)) { Logger.Log("Failed to fetch or decode the mesh asset", Helpers.LogLevel.Warning, Client); } gotMesh.Set(); }); gotMesh.WaitOne(20 * 1000, false); } return(mesh); }
public void AutoRestEventTest() { CodeTimer.Time("AutoResetEvent(false)", () =>//无信号,可以通过WaitOne 阻塞线程的执行,通过Set发出信号唤醒等待的线程 { using (System.Threading.AutoResetEvent are = new System.Threading.AutoResetEvent(false)) { System.Threading.ThreadPool.QueueUserWorkItem((s) => { Thread.Sleep(1000); Console.WriteLine("Run!"); are.Set(); }); are.WaitOne(); } }); CodeTimer.Time("AutoResetEvent(true)", () =>//有信号表示终止状态,即线程属于闲置状态 { using (System.Threading.AutoResetEvent are = new System.Threading.AutoResetEvent(true)) { System.Threading.ThreadPool.QueueUserWorkItem((s) => { Thread.Sleep(1000); Console.WriteLine("Not Run!"); are.Set(); }); are.WaitOne();//不会等待子线程的结束 } }); }
private bool m_disposed; // Whether or not this manager has been disposed //--// /// <summary> /// Creates and initializes a new BTManager /// </summary> protected BTManager(BTDriver driver, IPowerPolicy pp) { m_driver = null; try { m_driver = driver; m_pp = (null == pp) ? new DefaultPowerPolicy() : pp; m_outstandingConnections = new ArrayList(); m_connectionsToBeProcessed = new ArrayList(); m_newCommand = new AutoResetEvent(false); m_scheduler = new Thread(new ThreadStart(AggregateAndDispatch)); m_scheduler.Start(); m_disposed = false; } catch { m_disposed = true; throw; } // Now apply policy for no pending commands m_pp.ApplyPolicy(m_driver, null, null); }
/// <summary> /// Creates a new instance. /// </summary> /// <param name="events">the ResponseEvents to store the events in</param> /// <param name="actionCompleteEventClass">the type of event that indicates that all events have been received</param> /// <param name="thread">the thread to interrupt when the actionCompleteEventClass has been received</param> public ResponseEventHandler(ManagerConnection connection, ManagerActionEvent action, AutoResetEvent autoEvent) { this.connection = connection; this.events = new ResponseEvents(); this.action = action; this.autoEvent = autoEvent; }
public void GetMethodTableApiKeyInvalidTest() { // ARRANGE using (AutoResetEvent waitEvent = new AutoResetEvent(false)) { ResultEventArgs<MethodTable> result = null; IServerService serverService = new ServerService(new EtsyContext("InvalidKey")); serverService.GetMethodTableCompleted += (s, e) => { result = e; waitEvent.Set(); }; // ACT serverService.GetMethodTable(); bool signalled = waitEvent.WaitOne(Constants.WaitTimeout); // ASSERT // check that the event was fired, did not time out Assert.IsTrue(signalled, "Not signalled"); // check the data - should fail Assert.IsNotNull(result); Assert.IsNotNull(result.ResultStatus); Assert.IsFalse(result.ResultStatus.Success); Assert.AreEqual(WebExceptionStatus.ProtocolError, result.ResultStatus.WebStatus); } }
public void Close() { try { try { _sock.Shutdown(SocketShutdown.Both); } catch { } _sock.Close(); _sock.Dispose(); if (wait != null) { wait.Close(); wait.Dispose(); wait = null; } AsynEvent.Dispose(); } catch (ObjectDisposedException) { } catch (NullReferenceException) { } }
public void Receive_from_standIn() { var cre = PubnubCredentials.LoadFrom("pubnub credentials.txt"); using (var sut = new PubnubHostTransceiver(cre, "hostchannel")) { var are = new AutoResetEvent(false); HostInput result = null; sut.ReceivedFromStandIn += _ => { result = _; are.Set(); }; var standIn = new Pubnub(cre.PublishingKey, cre.SubscriptionKey, cre.SecretKey); var hi = new HostInput{CorrelationId = Guid.NewGuid(), Data = "hello".Serialize(), Portname = "portname", StandInEndpointAddress = "endpoint"}; standIn.publish("hostchannel", hi.Serialize(), _ => { }); Assert.IsTrue(are.WaitOne(5000)); Assert.AreEqual(hi.CorrelationId, result.CorrelationId); Assert.AreEqual(hi.Data, result.Data); Assert.AreEqual(hi.Portname, result.Portname); Assert.AreEqual(hi.StandInEndpointAddress, result.StandInEndpointAddress); } }
internal ThreadManager(Debugger debugger) { this.debugger = debugger; thread_hash = Hashtable.Synchronized(new Hashtable()); engine_hash = Hashtable.Synchronized(new Hashtable()); processes = ArrayList.Synchronized(new ArrayList()); pending_events = Hashtable.Synchronized(new Hashtable()); last_pending_sigstop = DateTime.Now; pending_sigstops = new Dictionary <int, DateTime> (); address_domain = AddressDomain.Global; wait_event = new ST.AutoResetEvent(false); engine_event = new ST.ManualResetEvent(true); ready_event = new ST.ManualResetEvent(false); event_queue = new DebuggerEventQueue("event_queue"); event_queue.DebugFlags = DebugFlags.Wait; mono_debugger_server_global_init(); wait_thread = new ST.Thread(new ST.ThreadStart(start_wait_thread)); wait_thread.IsBackground = true; wait_thread.Start(); inferior_thread = new ST.Thread(new ST.ThreadStart(start_inferior)); inferior_thread.IsBackground = true; inferior_thread.Start(); ready_event.WaitOne(); }
private bool RawSendHelper(byte[] aData, bool aWait) { if (IsInBackgroundThread) { return SendRawData(aData); } if (!IsConnected) { return false; } if (aWait) { using (var xEvent = new AutoResetEvent(false)) { mPendingWrites.Add(new Outgoing {Packet = aData, Completed = xEvent}); while (IsConnected) { xEvent.WaitOne(1000); } return IsConnected; // ?? } } else { mPendingWrites.Add(new Outgoing {Packet = aData}); return true; } }
public object SendEvent(int events, object param) { if (threadid == MT.Thread.CurrentThread.ManagedThreadId) { bool success = true; while (success) { DoEvent(ref success); } return(OnProc(events, param)); } else { using (MT.AutoResetEvent signal = new MT.AutoResetEvent(false)) { object result = null; PostEvent(events, param, (response) => { result = response; signal.Set(); }); while (!signal.WaitOne(1)) { ; } return(result); } } }
public DDEClient() { AutoResetEvent are = new AutoResetEvent(false); thread = new Thread(this.ThreadMain); thread.Start(are); are.WaitOne(); }
async public static Task <System.Drawing.Rectangle> GetitAsync() { if (VersionHelper.IsWindows8OrGreater()) { _overlayWindow = new Interfaces.Overlay.OverlayWindow(true); } else { _overlayWindow = new Interfaces.Overlay.OverlayWindow(false); } _overlayWindow.Visible = true; _overlayWindow.Bounds = new System.Drawing.Rectangle(0, 0, 10, 10); createform(); mouseDown = false; var pos = System.Windows.Forms.Cursor.Position; rect = new System.Drawing.Rectangle(pos.X, pos.Y, 1, 1); //hi = new Highlighter(rect, System.Drawing.Color.Red); OpenRPA.Input.InputDriver.Instance.OnMouseDown += onMouseDown; OpenRPA.Input.InputDriver.Instance.OnMouseUp += onMouseUp; OpenRPA.Input.InputDriver.Instance.OnMouseMove += onMouseMove; OpenRPA.Input.InputDriver.Instance.onCancel += onCancel; OpenRPA.Input.InputDriver.Instance.CallNext = false; waitHandle = new System.Threading.AutoResetEvent(false); await waitHandle.WaitOneAsync(); //System.Windows.Forms.Application.Exit(); return(rect); }
public void Should_be_able_to_do_basic_request_async_cancellation() { const string expectedResult = "Sending back 'Ninja!!'"; var autoResetEvent = new AutoResetEvent(false); bus.Respond<TestRequestMessage, TestResponseMessage>(request => { var response = new TestResponseMessage { Text = string.Format("Sending back '{0}'", request.Text) }; return response; }); using (var channel = bus.OpenPublishChannel()) { var request = new TestRequestMessage { Text = "Ninja!!" }; var cancellationSource = new CancellationTokenSource(); var responseTask = channel.RequestAsync<TestRequestMessage, TestResponseMessage>(request, cancellationSource.Token); responseTask.ContinueWith(t => { autoResetEvent.Set(); }, TaskContinuationOptions.OnlyOnCanceled); cancellationSource.Cancel(); } // give the bus a chance to deliver the message Assert.IsTrue(autoResetEvent.WaitOne(1000)); }
public static bool ClearMarkedPosts(ThreadMetadata thread, int timeout = CoreConstants.DEFAULT_TIMEOUT_IN_MILLISECONDS) { // create request HttpWebRequest request = AwfulWebRequest.CreateFormDataPostRequest( "http://forums.somethingawful.com/showthread.php", "application/x-www-form-urlencoded"); // begin request stream creation and wait... var signal = new AutoResetEvent(false); var result = request.BeginGetRequestStream(callback => SendClearMarkedPostRequest(callback, signal, thread), request); signal.WaitOne(); // begin response stream and wait... request = result.AsyncState as HttpWebRequest; result = request.BeginGetResponse(callback => { signal.Set(); }, request); signal.WaitOne(timeout); if (!result.IsCompleted) throw new TimeoutException(); // process the response and return status bool success = ProcessClearMarkedPostResponse(result); return success; }
public void AsyncStorageModule_InvalidKeyValue_Method() { var module = new AsyncStorageModule(); var waitHandle = new AutoResetEvent(false); var error = default(JObject); var result = default(JArray); var callback = new MockCallback(res => { error = res.Length > 0 ? (JObject)res[0] : null; result = res.Length > 1 ? (JArray)res[1] : null; waitHandle.Set(); }); var array = new[] { new[] { "5", "5", "5" }, }; module.clear(callback); Assert.IsTrue(waitHandle.WaitOne()); Assert.IsNull(error); Assert.IsNull(result); module.multiSet(array, callback); Assert.IsTrue(waitHandle.WaitOne()); Assert.AreEqual(error["message"], "Invalid Value"); Assert.IsNull(result); }
public void Should_invoke_onReceiveMessage_delegate_with_copied_MessageDeliverEventArgs() { // Arrange MessageDeliverEventArgs eventArgs = null; var are = new AutoResetEvent(false); var func = consumer.CreateJobFactoryForTest<Customer>("subscriptionName", (c, e) => { eventArgs = e; are.Set(); }); var basicProperties = Substitute.For<IBasicProperties>(); basicProperties.Type.Returns(Global.DefaultTypeNameSerializer.Serialize(typeof(Customer))); // Action func(new BasicDeliverEventArgs { BasicProperties = basicProperties, ConsumerTag = "ct", DeliveryTag = 1000, }); // Assert are.WaitOne(); Assert.AreEqual("ct", eventArgs.ConsumerTag); Assert.AreEqual((ulong)1000, eventArgs.DeliveryTag); Assert.AreEqual("subscriptionName", eventArgs.SubscriptionName); }
private static void DemoOne() { //AutoResetEvent example //AutoResetEvent 通知正在等待的线程已发生的事件。 AutoResetEvent waitHandler = new AutoResetEvent(false);//false 即非终止,未触发。 new Thread(() => { waitHandler.WaitOne(); //阻塞当前线程,等待底层内核对象收到信号。 Console.WriteLine("线程1接收到信号,开始处理。"); }).Start(); new Thread(() => { waitHandler.WaitOne(); //阻塞当前线程,等待底层内核对象收到信号。 Console.WriteLine("线程2接收到信号,开始处理。"); }).Start(); new Thread(() => { Thread.Sleep(2000); Console.WriteLine("线程3发信号"); waitHandler.Set(); //向内核对象发送信号。设置事件对象为非终止状态、false,解除阻塞。 }).Start(); //waitHandler.Close(); //释放句柄资源。 //waitHandler.Reset(); //手动设置事件为非终止状态、false,线程阻止。 Console.ReadLine(); }
/// <summary> /// Constructor /// </summary> public Console() { InitializeComponent(); textpen = new Pen(Settings.Simulator.ConsoleTextColor); //color of the init text this.BackColor = Settings.Simulator.ConsoleBackGroundColor; caretThread = new Thread(new ThreadStart(ShowCaret)); AllThreads.Add(caretThread); //add the caret thread to list for closing caretThread.Start(); m_Output = new dOutputFunction(this.Write); m_Exit = new dExitFunction(this.exitConsole); ScreenBuffer = new ArrayList(); InputBuffer = new CodeBlock(); ScreenBuffer.Insert(0, new CodeBlock()); bNowInInputFunction = false; eWaitForInput = new AutoResetEvent(false); PrevImage = new System.Drawing.Bitmap(_MaxX, _MaxY); NeedToRepaint = new System.Timers.Timer(); NeedToRepaint.Elapsed += new ElapsedEventHandler(ConsoleUpdateTime); NeedToRepaint.Interval = 100; NeedToRepaint.Enabled = false; }
/* The implementation of Storage is hidden from users, although it is protected * so you can derive from it if you want to. If you do, you have to write a new * Attach() function as well, as that function attaches an instance of this * specific class. */ protected Storage() : base(GameInstance) { todo = new System.Threading.AutoResetEvent(false); thread = new System.Threading.Thread(this.Worker); thread.Start(); GameInstance.Components.Add(this); }
public Camera(string camName) { this._camName = camName; this._ThreadFlag = true; this._ent = new AutoResetEvent(false); TaskFactory factory = new TaskFactory(); Task a = factory.StartNew(snapImage); }
public RunWorkflowInstance(string UniqueId, string IDOrRelativeFilename, bool WaitForCompleted, Dictionary <string, object> Arguments) { this.UniqueId = UniqueId; this.IDOrRelativeFilename = IDOrRelativeFilename; this.WaitForCompleted = WaitForCompleted; this.Arguments = Arguments; Started = false; Pending = new System.Threading.AutoResetEvent(false); }
public AutoResetEventExpire(bool initialState, int expireTime) { are = new System.Threading.AutoResetEvent(initialState); setTimer = new System.Timers.Timer(); setTimer.Interval = expireTime; setTimer.Elapsed += OnTimedEvent; setTimer.AutoReset = false; setTimer.Enabled = true; }
private void Initialize() { index = 1; packetSize = 32768; buffer = new byte[MaxPduSize]; State = State.Closed; completeEvent = new System.Threading.AutoResetEvent(false); threadEvent = new AutoResetEvent(false); services = new List <ServiceClass>(); }
public ASyncRead(SerialPort com) { _com = com; _result = int.MinValue; _readCompletedEvent = new System.Threading.AutoResetEvent(false); _readStartedEvent = new System.Threading.AutoResetEvent(false); _exception = null; }
private Timer InitalizeAlgorthmTimer(CancelationObject cancelationSignal, AutoResetEvent autoResetEvent) { Timer timer = new Timer(); timer.Elapsed += (sender, e) => AlgorthmTimerElapsedCallback(sender, e, cancelationSignal, autoResetEvent); timer.Interval = 10000; timer.AutoReset = false; return(timer); }
static internal void ClearAutoEvents() { lock (_sLockObj) { while (_AutoEventQueue.Count > 0) { System.Threading.AutoResetEvent aEvent = _AutoEventQueue.Dequeue(); aEvent.Set(); } } }
void OnEnable() { jobEvent = new System.Threading.AutoResetEvent(false); exit = false; deep = false; thread = new System.Threading.Thread(threadMain); thread.Priority = System.Threading.ThreadPriority.AboveNormal; thread.Start(); coGarbageCollection = garbageCollection(); StartCoroutine(coGarbageCollection); }
public CustomQueue(string name, CancellationToken token) { AllServed = 0; AverageLentgth = 0; Name = name; _reachedLimit = false; HasLimit = false; customersList = new Queue <Customer>(); resetEvent = new System.Threading.AutoResetEvent(false); new Thread(() => UpdateAvrLength(token)).Start(); }
/// <summary> /// Starts the invokable thread with a specified priority. The <paramref name="name"/> argument is used for debugging purposes, it is assigned to the thread. /// </summary> /// <param name="name">The name of the thread (as it then appears in TaskManager).</param> /// <param name="priority">The priority of the thread.</param> protected void Start(string name, System.Threading.ThreadPriority priority) { _keepThreadRunning = true; _triggeringEvent = new AutoResetEvent(false); _thread = new Thread(EhThreadBody) { IsBackground = true, Priority = priority, Name = name }; _thread.Start(); }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (disposing) { this.ByteStream.Close(); this.sendRateLimit.Dispose(); this.internalCancellation.Dispose(); } System.Threading.AutoResetEvent are = new System.Threading.AutoResetEvent(false); are.WaitOne(100); }
internal CommandLineInterpreter(DebuggerOptions options, bool is_interactive) { if (options.HasDebugFlags) { Report.Initialize(options.DebugOutput, options.DebugFlags); } else { Report.Initialize(); } Configuration = new DebuggerConfiguration(); #if HAVE_XSP if (options.StartXSP) { Configuration.SetupXSP(); } else { Configuration.LoadConfiguration(); } #else Configuration.LoadConfiguration(); #endif Configuration.SetupCLI(); interpreter = new Interpreter(is_interactive, Configuration, options); interpreter.CLI = this; engine = interpreter.DebuggerEngine; parser = new LineParser(engine); if (!interpreter.IsScript) { line_editor = new LineEditor("mdb"); line_editor.AutoCompleteEvent += delegate(string text, int pos) { return(engine.Completer.Complete(text, pos)); }; Console.CancelKeyPress += control_c_event; } interrupt_event = new ST.AutoResetEvent(false); nested_break_state_event = new ST.AutoResetEvent(false); main_loop_stack = new Stack <MainLoop> (); main_loop_stack.Push(new MainLoop(interpreter)); main_thread = new ST.Thread(new ST.ThreadStart(main_thread_main)); main_thread.IsBackground = true; }
/// <summary> /// Creates new program. Get CodeBlock to load into the simulator's memory /// </summary> /// <param name="cbProgram">CodeBlock to load into the simulator's memory</param> /// <param name="DebugMode">True if the new program suppose to run in debug mode</param> public Program(ProgramBlock cbProgram, bool DebugMode, frmMain theMainApplication, string sInputFile, string sOutputFile) { theProgram = cbProgram; _theMainApplication = theMainApplication; BreakPointWait = new AutoResetEvent(false); _BreakPointList = new BreakPointList(); bInDebug = DebugMode; con = new VAX11Simulator.Console(sInputFile, sOutputFile); theSimulator = new VAX11Simulator.Simulator(theProgram, con); theSimulator.memory.OnMemoryAccess += new MemoryAccessedFunc(MemoryAcessedHandler); theSimulator.memory.OnPageFault += new PageFaultFunc(PageFaultHandler); con.InterruptsEvent += new VAX11Simulator.Console.InterruptsDelegate(InterruptHendler); }