internal CommandResult StartOperation(ThreadingModel model, SingleSteppingEngine caller) { if (!ThreadManager.InBackgroundThread) { throw new InternalError(); } if ((current_state != ProcessState.Stopped) && (current_state != ProcessState.SingleThreaded)) { throw new TargetException(TargetError.NotStopped); } if ((model & ThreadingModel.ThreadingMode) == ThreadingModel.Single) { current_state = ProcessState.SingleThreaded; if ((model & ThreadingModel.ResumeThreads) != 0) { ResumeUserThreads(model, caller); } return(new ThreadCommandResult(caller.Thread)); } else if ((model & ThreadingModel.ThreadingMode) != ThreadingModel.Process) { throw new ArgumentException(); } lock (this) { current_state = ProcessState.Running; stopped_event.Reset(); current_operation = new ProcessCommandResult(this, model); } ResumeUserThreads(model, caller); return(current_operation); }
/// <summary> /// 启动发送任务 /// </summary> /// <param name="studyInstUID"></param> /// <param name="accepteNums"></param> public bool StartDownload(string studyInstUID) { var ok = false; try { var cd = DateTime.Now; DownloadItem di = new DownloadItem() { Completed = 0, SendStatus = E_SendStatus.Start, StudyInstanceUID = studyInstUID // Completed = 0, // Fails = 0, // Warnings = 0, // AddTime = cd, //TokenTime = cd, // PatientId = patientId, // Remaings = 0 }; mr.WaitOne(); mr.Reset(); } catch (Exception e) { } finally { mr.Set(); } return(ok); }
internal object SendCommand(SingleSteppingEngine sse, TargetAccessDelegate target, object user_data) { Command command = new Command(sse, target, user_data); if (!engine_event.WaitOne(WaitTimeout, false)) { throw new TargetException(TargetError.NotStopped); } event_queue.Lock(); engine_event.Reset(); current_command = command; event_queue.Signal(); event_queue.Unlock(); engine_event.WaitOne(); if (command.Result is Exception) { throw (Exception)command.Result; } else { return(command.Result); } }
public void CallbackInvokedMultipleTimes() { var reRegisterForFinalize = true; var callbackInvoked = new ManualResetEvent(false); GcNotification.Register(state => { callbackInvoked.Set(); return reRegisterForFinalize; }, null); GcCollectAndWait(); Assert.True(callbackInvoked.WaitOne(0)); callbackInvoked.Reset(); reRegisterForFinalize = false; GcCollectAndWait(); Assert.True(callbackInvoked.WaitOne(0)); callbackInvoked.Reset(); // No callback expected the 3rd time GcCollectAndWait(); Assert.False(callbackInvoked.WaitOne(0)); }
public void CallbackInvokedMultipleTimes() { int callbackCount = 0; var callbackInvoked = new ManualResetEvent(false); GcNotification.Register(state => { callbackCount++; callbackInvoked.Set(); if (callbackCount < 2) { return true; } return false; }, null); GC.Collect(2, GCCollectionMode.Forced, blocking: true); Assert.True(callbackInvoked.WaitOne(100)); Assert.Equal(1, callbackCount); callbackInvoked.Reset(); GC.Collect(2, GCCollectionMode.Forced, blocking: true); Assert.True(callbackInvoked.WaitOne(100)); Assert.Equal(2, callbackCount); callbackInvoked.Reset(); // No callback expected the 3rd time GC.Collect(2, GCCollectionMode.Forced, blocking: true); Assert.False(callbackInvoked.WaitOne(100)); Assert.Equal(2, callbackCount); }
/// ------------------------------------------------------------------- /// <summary> /// Called by the test cases to make sure the number of desired events have been fired before they start doing eny event verification. /// </summary> /// ------------------------------------------------------------------- internal static bool WaitForEvents(int number, int millSeconds) { int time = (number * millSeconds); Comment("Waiting for a period of " + time + " milliseconds for no events to occur"); _waitedForEventToFire = true; _lastEvent = DateTime.Now; // Wait for a specific time span since the last event occured before // return back to the calling test. while (((DateTime.Now.Ticks - _lastEvent.Ticks) / TimeSpan.TicksPerMillisecond) < time) { // _haveNotifiedEvent.Set() will let OnEvent() process events if it has stoped processing at the _haveNotifiedEvent.WaitOne() call. _haveNotifiedEvent.Set(); // Wait until OnEvent() has called _gotNotifiedEvent.Set() or the amount of time defined by millSeconds has expired, which ever comes first. _gotNotifiedEvent.WaitOne(millSeconds, true); // Reset so _gotNotifiedEvent.Wait() will pause on the next iteration. _gotNotifiedEvent.Reset(); } int count = _eventList == null ? 0 : _eventList.Count; Comment("Stop waiting for events. Found " + count + " event(s)"); //RemoveAllEventHandlers(); //Thread.Sleep(1); return(count == number); }
public void Stop() { if (!IsStarted) { string message = "Not started!"; Logging.Log(message); return; } assembly = null; // signal that we want to shutdown our server socket. // this should start the process of stopping the background thread if (serversocket != null) { Logging.Log("Socket will be shutdown."); serversocket.Close(); } // even if the thread doesn't shutdown, we may be able to start // another mainthread started.Reset(); // if we have a background thread if (mainthread != null) { // wait a little bit if (!mainthread.Join(Timeout)) { // if the thread did not shutdown, be nasty about it. Logging.Log("Timeout waiting for thread to complete!"); mainthread.Abort(); } } SetStatus("Stopped"); }
/// <summary> /// 初始化命令 /// </summary> public void Init() { ManagerPlant.flowManager.InitPos(); XmlNode cmdNode = xd.SelectSingleNode("Cmds/Cmd/DispatchCmd[@strMemo='初始化加样臂']"); XmlElement el = cmdNode as XmlElement; WaitEvent.Reset(); ManagerPlant.aiKangManager.ClsModule.SendXmlElement(el, "Module_AiKang_Service"); WaitEvent.WaitOne(); }
public void ExecuteCommand(Command command) { lock (this) { this.command = command; this.last_command = command; this.repeating = false; completed_event.Reset(); command_event.Set(); } }
public void TestSuccesfulConnection() { // setup Uri url = new Uri("http://test.com"); CancellationTokenSource cts = new CancellationTokenSource(); List<EventSourceState> states = new List<EventSourceState>(); ServiceResponseMock response = new ServiceResponseMock(url, System.Net.HttpStatusCode.OK); WebRequesterFactoryMock factory = new WebRequesterFactoryMock(response); ManualResetEvent stateIsOpen = new ManualResetEvent(false); TestableEventSource es = new TestableEventSource(url, factory); es.StateChanged += (o, e) => { states.Add(e.State); if (e.State == EventSourceState.OPEN) { stateIsOpen.Set(); cts.Cancel(); } }; // act stateIsOpen.Reset(); es.Start(cts.Token); stateIsOpen.WaitOne(); // assert Assert.IsTrue(states.Count == 2); Assert.AreEqual(states[0], EventSourceState.CONNECTING); Assert.AreEqual(states[1], EventSourceState.OPEN); }
public MockPresenter(Page.ePageType activePageType = Page.ePageType.AVItemCollectionGallery, string excludedTitles = "Popular,TV,V,W,Sports,ESPN,News", int imageWidth = IMAGE_WIDTH, int imageHeight = IMAGE_HEIGHT) { // start logging during mocking SetupLogging(); _model = MediaServerModel.GetInstance(); TitlesExcludedFromImageReplacement = excludedTitles; ImageWidth = imageWidth; ImageHeight = imageHeight; AVItemCollections = new ObservableCollection<UPnPCollection>(); AVItems = new ObservableCollection<UPnPItem>(); DetailItem = new ObservableCollection<UPnPItem>(); Items = new ObservableCollection<AVItemBase>(); _allDoneEvent = new ManualResetEvent(false); Logger.TraceInfo(MethodBase.GetCurrentMethod(), "MockPresenter _model: {0}", _model.Actions.ContentDirectory.Name); _model.Actions.ContentDirectory.NewDeviceFound += NewDeviceFound; _model.Actions.ContentDirectory.OnCreateControlPoint(null); _allDoneEvent.WaitOne(); _allDoneEvent.Reset(); WaitTimeBetweenGetImageInMilliseconds = 0; StartBackgroundThreadToGetImages(); PropertyChanged += OnLocalPropertyChanged; // default to the showing a collection ActivePageType = activePageType; //ActivePageType = Page.ePageType.AVItemGallery; //ActivePageType = Page.ePageType.AVItemDetails; _allDoneEvent.WaitOne(TimeSpan.FromSeconds(15D)); }
void command_thread_main() { Report.Debug(DebugFlags.CLI, "{0} starting command thread", this); while (!Completed) { command_event.WaitOne(); Report.Debug(DebugFlags.CLI, "{0} command thread waiting", this); Command command; lock (this) { command = this.command; this.command = null; command_event.Reset(); } Report.Debug(DebugFlags.CLI, "{0} command thread execute: {1}", this, command); execute_command(command); Report.Debug(DebugFlags.CLI, "{0} command thread done executing: {1}", this, command); completed_event.Set(); } Report.Debug(DebugFlags.CLI, "{0} terminating command thread", this); }
void processAction() { while (!_exited || _backupQueue.Count > 0) { _backupEvent.WaitOne(); _backupEvent.Reset(); List <ContentAction> buffer = new List <ContentAction>(500); while (true) { if (_backupQueue.TryDequeue(out ContentAction dataitem)) { buffer.Add(dataitem); } else { break; } } if (buffer.Count > 0) { _db.Handle(buffer); } } }
public void Connect(string address, int port) { if (socket == null) { Id = -1; this.address = address; this.port = port; using (mreBeginConnect = new ManualResetEvent(false)) { mreBeginConnect.Reset(); BeginConnect(); mreBeginConnect.WaitOne(); } if (!closed) { InitSocket(); OnConnected(); } else { OnDisconnected(); } } }
public static void RunTaskWaitAndDoEvents(ThreadStart methodToInvoke, int pollTimeMs) { var syncEvent = new ManualResetEvent(true); syncEvent.Reset(); ThreadPool.QueueUserWorkItem( delegate(object state) { try { methodToInvoke(); } finally { syncEvent.Set(); } }); do { bool releaded = syncEvent.WaitOne(pollTimeMs); if (releaded) break; Application.DoEvents(); } while (true); }
public static void Run() { // ExStart:SupportIMAPIdleCommand // Connect and log in to IMAP ImapClient client = new ImapClient("imap.domain.com", "username", "password"); ManualResetEvent manualResetEvent = new ManualResetEvent(false); ImapMonitoringEventArgs eventArgs = null; client.StartMonitoring(delegate(object sender, ImapMonitoringEventArgs e) { eventArgs = e; manualResetEvent.Set(); }); Thread.Sleep(2000); SmtpClient smtpClient = new SmtpClient("exchange.aspose.com", "username", "password"); smtpClient.Send(new MailMessage("*****@*****.**", "*****@*****.**", "EMAILNET-34875 - " + Guid.NewGuid(), "EMAILNET-34875 Support for IMAP idle command")); manualResetEvent.WaitOne(10000); manualResetEvent.Reset(); Console.WriteLine(eventArgs.NewMessages.Length); Console.WriteLine(eventArgs.DeletedMessages.Length); client.StopMonitoring("Inbox"); smtpClient.Send(new MailMessage("*****@*****.**", "*****@*****.**", "EMAILNET-34875 - " + Guid.NewGuid(), "EMAILNET-34875 Support for IMAP idle command")); manualResetEvent.WaitOne(5000); // ExEnd:SupportIMAPIdleCommand }
private async void TheGame_Load(object sender, EventArgs e) { MessageBox.Show("Choose a number between 1 and 128 & Keep it in your mind", "Help", MessageBoxButtons.OK, MessageBoxIcon.Information); for (cardno = 0; cardno <= 6; cardno++) { noperrow = 0; for (number = 1; number <= 127; number++) { if (Convert.ToBoolean(number & (int)Math.Pow(2.0, cardno))) { label1.Text += number + " "; noperrow++; if (noperrow == 5) { label1.Text += "\n"; noperrow = 0; } } } if (noperrow < 5) { label1.Text += "\n"; } mre.Reset(); await Task.Factory.StartNew(() => { mre.WaitOne(); }); } MessageBox.Show("Your Number is : " + chno.ToString() + " :D <3", "The answer", MessageBoxButtons.OK, MessageBoxIcon.Information); StartPage f = new StartPage(); f.Show(); this.Hide(); }
public XSocketLogListener(String host) { ThreadStart connect = () => { myEvent = new ManualResetEvent(false); mySocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); SocketAsyncEventArgs connArg = new SocketAsyncEventArgs(); // Ҫ���ӵ�Զ�̷����� connArg.RemoteEndPoint = new DnsEndPoint(host, HOST_PORT,AddressFamily.InterNetwork); connArg.Completed += (sendObj, arg) => { if (arg.SocketError == SocketError.Success) //���ӳɹ� { XLog.WriteInfo("SocketLogServer Connect Success"); } else { XLog.WriteInfo("SocketLogServer Connect fail"); mySocket.Close(); mySocket = null; } // ������̱߳���������� myEvent.Set(); }; myEvent.Reset(); mySocket.ConnectAsync(connArg); myEvent.WaitOne(TIME_OUT); }; new Thread(connect).Start(); }
public void SharedTimer_Register_CallbackInvokedMultipleTimes() { var timerSet = new ManualResetEvent(false); using (var timer = new SharedTimer(TimeSpan.FromMilliseconds(20))) { using (IDisposable cleanup = timer.Register(_ => timerSet.Set(), null)) { Assert.NotNull(cleanup); Assert.True(timerSet.WaitOne(500)); timerSet.Reset(); Assert.True(timerSet.WaitOne(500)); timerSet.Reset(); } Assert.False(timerSet.WaitOne(500)); } }
/// <summary> /// Start server and begin accepting clients /// </summary> public static void Start() { futureMoves = new Queue<FutureMove>(); clientsPlaying = new List<Connection>(); clientUpdate = new List<Connection>(); clientAI = new List<Connection>(); clientPlayers = new List<Connection>(); clientsAll = new List<Connection>(); updateTimer.Elapsed += new ElapsedEventHandler(UpdateTick); updateTimer.AutoReset = false; if (listener != null) listener.Stop(); listener = TcpListener.Create(Program.port); listener.Start(); allDone = new ManualResetEvent(false); try { while (true) { allDone.Reset(); listener.BeginAcceptTcpClient(new AsyncCallback(AcceptTcpClient), listener); allDone.WaitOne(); } } catch (ThreadAbortException) { listener.Stop(); } }
public void TestAsyncGetAccountInfo_WhenUserIsNotLoggedIn_ThenStatusIsNotLoggedIn() { const int status = 847587532; ManualResetEvent wait = new ManualResetEvent(false); bool callbackWasExecuted = false; OperationFinished<GetAccountInfoResponse> callback = resp => { Assert.AreEqual(GetAccountInfoStatus.NotLoggedIn, resp.Status); Assert.IsInstanceOf(typeof(int), resp.UserState); Assert.AreEqual(status, (int)resp.UserState); Assert.IsNull(resp.Error); Assert.IsNull(resp.User); callbackWasExecuted = true; wait.Reset(); }; Context.Manager.Logout(); Context.Manager.GetAccountInfo(callback, status); wait.WaitOne(30000); Assert.IsTrue(callbackWasExecuted, "Callback was not executed. The operation has timed out"); }
public void TestAsyncGetAccountInfo() { const int status = 847587532; ManualResetEvent wait = new ManualResetEvent(false); bool callbackWasExecuted = false; OperationFinished<GetAccountInfoResponse> callback = resp => { Assert.AreEqual(GetAccountInfoStatus.Successful, resp.Status); Assert.IsNull(resp.Error); Assert.IsInstanceOf(typeof(int), resp.UserState); Assert.AreEqual(status, (int)resp.UserState); Assert.IsNotNull(resp.User); Assert.AreEqual(Context.AuthenticatedUser.AccessID, resp.User.AccessID); Assert.AreEqual(Context.AuthenticatedUser.ID, resp.User.ID); Assert.AreEqual(Context.AuthenticatedUser.MaxUploadSize, resp.User.MaxUploadSize); Assert.AreEqual(Context.AuthenticatedUser.SpaceAmount, resp.User.SpaceAmount); Assert.AreEqual(Context.AuthenticatedUser.SpaceUsed, resp.User.SpaceUsed); StringAssert.IsMatch(Context.AuthenticatedUser.Email, resp.User.Email); StringAssert.IsMatch(Context.AuthenticatedUser.Login, resp.User.Login); callbackWasExecuted = true; wait.Reset(); }; Context.Manager.GetAccountInfo(callback, status); wait.WaitOne(30000); Assert.IsTrue(callbackWasExecuted, "Callback was not executed. The operation has timed out"); }
public ContentLoader(ContentLoaderProgressHandler progress) { LoaderQueue = new Queue<ContentLoaderItem>(); ContinueLoaderThreadEvent = new ManualResetEvent(false); ContentLoaderThread = new Thread(delegate() { double itemIndex = 0; while (ContentLoaderThread.ThreadState != ThreadState.Aborted) { if (LoaderQueue.Count > 0) { ContentLoaderItem item = LoaderQueue.Dequeue(); progress((++itemIndex) / (itemIndex + LoaderQueue.Count), item.Description); item.Handler(item.Target); } else { ContinueLoaderThreadEvent.WaitOne(); } ContinueLoaderThreadEvent.Reset(); } }); ContentLoaderThread.Start(); }
void backupRunning() { while (!_disposed || _backupQueue.Count > 0) { _backupEvent.WaitOne(); _backupEvent.Reset(); List <OpAction <T> > buffer = new List <OpAction <T> >(500); while (true) { if (_backupQueue.TryDequeue(out OpAction <T> dataitem)) { buffer.Add(dataitem); } else { break; } } if (buffer.Count > 0) { _db.Handle(buffer); } } _backupExited = true; }
public new void ReInitialize(IProtocol !protocol) { base.ReInitialize(protocol); sessionTCB = new TCB(); sessionTCB.SND.WND = TcpFormat.TCP_MSS; sessionTCB.RCV.WND = TcpFormat.TCP_MSS; maxAcceptedSessions = 0; passiveSession = null; isValidForRead = true; isValidForWrite = true; DrainQueue(outQueue); DrainQueue(inQueue); retransmitQ.Clear(); acceptedSessions.Clear(); setupCompleteEvent.Reset(); closedEvent.Reset(); // create and initialize the init state this.oldStateEnum = TcpStateEnum.Undefined; if (!IsClosed) { ChangeState(TCPFSM.CLOSED); } DestroyConnectTimer(); DestroyShutdownTimer(); DestroyPersistTimer(); retransInterval = InitialRetransInterval; }
bool isKeyPressed = false; //KeyDown fires many times, possible bug in Eto.Forms ? /// <summary> /// Creates new image display form supporting rectangle creation. /// </summary> /// <param name="title">Window title.</param> /// <param name="setPassingResetEvent">True to set the reset event to passing state, false otherwise.</param> public DrawingRectangleForm(string title = "", bool setPassingResetEvent = true) :base(title) { adorner = new DrawingRectangleAdorner(PictureBox); adorner.OnDrawn = () => { if (OnDrawn != null && !Rectangle.IsEmpty) OnDrawn(Rectangle); adorner.Clear(); }; ResetEvent = new ManualResetEvent(setPassingResetEvent); KeyDown += (s, e) => { if (isKeyPressed) return; isKeyPressed = true; ResetEvent.Reset(); }; KeyUp += (s, e) => { isKeyPressed = false; ResetEvent.Set(); }; }
public static void Test(ITransport t, IQueueStrategy strategy, Endpoint queueEndpoint, Action<Message> send, Func<MessageEnumerator> enumer) { Guid id = Guid.NewGuid(); var serializer = new XmlMessageSerializer(new DefaultReflection(), new DefaultKernel()); var subscriptionStorage = new MsmqSubscriptionStorage(new DefaultReflection(), serializer, queueEndpoint.Uri, new EndpointRouter(), strategy); subscriptionStorage.Initialize(); var wait = new ManualResetEvent(false); subscriptionStorage.SubscriptionChanged += () => wait.Set(); t.AdministrativeMessageArrived += subscriptionStorage.HandleAdministrativeMessage; Message msg = new MessageBuilder (serializer).GenerateMsmqMessageFromMessageBatch(new AddInstanceSubscription { Endpoint = queueEndpoint.Uri.ToString(), InstanceSubscriptionKey = id, Type = typeof (TestMessage2).FullName, }); send(msg); wait.WaitOne(); msg = new MessageBuilder (serializer).GenerateMsmqMessageFromMessageBatch(new RemoveInstanceSubscription { Endpoint = queueEndpoint.Uri.ToString(), InstanceSubscriptionKey = id, Type = typeof (TestMessage2).FullName, }); wait.Reset(); send(msg); wait.WaitOne(); IEnumerable<Uri> uris = subscriptionStorage .GetSubscriptionsFor(typeof (TestMessage2)); Assert.Equal(0, uris.Count()); int count = 0; MessageEnumerator copy = enumer(); while (copy.MoveNext()) count++; Assert.Equal(0, count); }
/// <summary> /// pauses the encoding process /// </summary> /// <param name="error">output for any errors that might ocurr during this method</param> /// <returns>true if encoding has been successfully paused, false if not</returns> public void pause() { if (!mre.Reset()) { throw new JobRunException("Could not reset mutex"); } }
static void Main() { // Creates a new ExamplePenguin class which, in this instance, is a wrapper for Sharpenguin. ExamplePenguin myPenguin = new ExamplePenguin(); // Creates a new ManualResetEvent. This is used to pause the thread so that the program doesn't exit. Threads.ManualResetEvent penguinDone = new Threads.ManualResetEvent(false); // Asks for the user's username. System.Console.Write("Enter your username: "******"Enter your password: "******"Enter the name of the server to join: "); string joinServer = System.Console.ReadLine(); // Connects the penguin. myPenguin.Connect(penguinUsername, penguinPassword, joinServer); // Pauses the thread. [penguinDone.Set() would resume the thread, and so would exit the program.] penguinDone.Reset(); penguinDone.WaitOne(); }
public static void Main2(string[] args) { ManualResetEvent conn = new ManualResetEvent(false); int count = 0; Socket main = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint bindingPoint = new IPEndPoint(IPAddress.Any,6199); main.Bind(bindingPoint); main.Listen(10); Console.WriteLine("main socket status: Blocking:{0}, localIP:{1}", main.Blocking, main.LocalEndPoint.ToString()); do { conn.Reset(); lock (main) { count++; } main.BeginAccept(AceptCallback, new stateObj { sck = main, ClientNo = count, conn = conn }); Console.WriteLine("wait one : " + count); conn.WaitOne(); } while (true); Console.ReadKey(); main.Close(1000); }
public void TestAsyncGetTicket() { BoxManager manager = new BoxManager(ApplicationKey, ServiceUrl, null); const int someValue = 78435; ManualResetEvent wait = new ManualResetEvent(false); bool callbackWasExecuted = false; OperationFinished<GetTicketResponse> response = resp => { Assert.IsNull(resp.Error); Assert.IsNotNull(resp.Ticket); Assert.IsInstanceOfType(typeof(int), resp.UserState); Assert.AreEqual(GetTicketStatus.Successful, resp.Status); int userStatus = (int) resp.UserState; Assert.AreEqual(someValue, userStatus); callbackWasExecuted = true; wait.Reset(); }; manager.GetTicket(response, someValue); wait.WaitOne(30000); Assert.IsTrue(callbackWasExecuted, "Callback was not executed. The operation has timed out"); }
public void start_and_callback() { var reset = new ManualResetEvent(false); var timer = new DefaultTimer(); int i = 0; timer.Start(() => { i++; reset.Set(); timer.Stop(); }, 500); reset.WaitOne(1000); i.ShouldBe(1); // Should only fire once because timer.Stop was called reset.Reset(); reset.WaitOne(1000); i.ShouldBe(1); timer.Dispose(); }
public void AcceptAsyncShouldUseAcceptSocketFromEventArgs() { var readyEvent = new ManualResetEvent(false); var mainEvent = new ManualResetEvent(false); var listenSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); var serverSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Socket acceptedSocket = null; Exception ex = null; ThreadPool.QueueUserWorkItem(_ => { SocketAsyncEventArgs asyncEventArgs; try { listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0)); listenSocket.Listen(1); asyncEventArgs = new SocketAsyncEventArgs {AcceptSocket = serverSocket}; asyncEventArgs.Completed += (s, e) => { acceptedSocket = e.AcceptSocket; mainEvent.Set(); }; } catch (Exception e) { ex = e; return; } finally { readyEvent.Set(); } try { if (listenSocket.AcceptAsync(asyncEventArgs)) return; acceptedSocket = asyncEventArgs.AcceptSocket; mainEvent.Set(); } catch (Exception e) { ex = e; } }); Assert.IsTrue(readyEvent.WaitOne(1500)); if (ex != null) throw ex; var clientSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); clientSocket.Connect(listenSocket.LocalEndPoint); clientSocket.NoDelay = true; Assert.IsTrue(mainEvent.WaitOne(1500)); Assert.AreEqual(serverSocket, acceptedSocket, "x"); mainEvent.Reset(); if (acceptedSocket != null) acceptedSocket.Close(); listenSocket.Close(); readyEvent.Close(); mainEvent.Close(); }
public static void StartListening(int port = 11001) { IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()); IPAddress ipAddress = IPAddress.Parse(LocalSettings.ServerIP); IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port); _allDone = new ManualResetEvent(false); // Create a TCP/IP socket. Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Bind the socket to the local endpoint and listen for incoming connections. try { listener.Bind(localEndPoint); listener.Listen(100); while (true) { // Set the event to nonsignaled state. _allDone.Reset(); // Start an asynchronous socket to listen for connections. listener.BeginAccept( AcceptCallback, listener); // Wait until a connection is made before continuing. _allDone.WaitOne(); } } catch (Exception e) { Console.WriteLine(e.ToString()); } Console.WriteLine("\nPress ENTER to continue..."); Console.Read(); }
/// <summary> /// Runs a MethodInvoker delegate on the UI thread from whichever thread we are currently calling from and BLOCKS until it is complete /// </summary> /// <param name="ivk"></param> public void UIBlockingInvoke(MethodInvoker ivk) { System.Threading.ManualResetEvent UIAsyncComplete = new System.Threading.ManualResetEvent(false); UIAsyncComplete.Reset(); if (this.InvokeRequired) { this.BeginInvoke(new MethodInvoker(delegate() { try { ivk(); } finally { UIAsyncComplete.Set(); } })); UIAsyncComplete.WaitOne(); } else { ivk(); } }
public bool UnInitialize() { lock (this) { lock (Clients) { Clients.Remove(this); } if (_proxyServerInterface != null) { ((IChannel)_proxyServerInterface).Opened -= new EventHandler(MessageContainerTransportClient_Opened); ((IChannel)_proxyServerInterface).Opening -= new EventHandler(MessageContainerTransportClient_Opening); ((IChannel)_proxyServerInterface).Faulted -= new EventHandler(MessageContainerTransportClient_Faulted); ((IChannel)_proxyServerInterface).Closing -= new EventHandler(MessageContainerTransportClient_Closing); ((IChannel)_proxyServerInterface).Abort(); _proxyServerInterface = null; } if (_channelFactory != null) { _channelFactory.Abort(); _channelFactory = null; } _connectingEvent.Reset(); } return(true); }
public Dictionary <int, double> GetVariablesExperiment(string expName) { if (User != null) { _resetEvent.WaitOne(); _resetEvent.Reset(); try { bool start = _server.RequestVariables(expName, CallbackAction, User.UserLever); if (start) { _resetEvent.WaitOne(); _resetEvent.Set(); } else { _resetEvent.Set(); } } catch { _resetEvent.Set(); } return(changed); } else { return(new Dictionary <int, double>()); } }
public void RunTest(bool useLowLatencyBackoffStrategy, int iterations) { var adapter = new BuiltinContainerAdapter(); var messageHasBeenReceived = new ManualResetEvent(false); adapter.Handle<string>(s => messageHasBeenReceived.Set()); ConfigureBus(adapter, useLowLatencyBackoffStrategy); var bus = adapter.Bus; var recordedLatencies = new List<TimeSpan>(); iterations.Times(() => { // let things calm down Console.Write("Calming down.... "); Thread.Sleep(30.Seconds()); Console.Write("Sending! "); var sendTime = DateTime.UtcNow; bus.SendLocal("w0000tamafooook!!1"); Console.Write("waiting... "); messageHasBeenReceived.WaitUntilSetOrDie(20.Seconds()); var elapsedUntilNow = sendTime.ElapsedUntilNow(); Console.WriteLine("got the message - recorded latency of {0}", elapsedUntilNow); recordedLatencies.Add(elapsedUntilNow); messageHasBeenReceived.Reset(); }); Console.WriteLine("AVERAGE RECORDED LATENCY: {0:0.00} s", recordedLatencies.Average(t => t.TotalSeconds)); }
public void FilteringTargetWrapperAsyncTest2() { var myMockCondition = new MyMockCondition(false); var myTarget = new MyAsyncTarget(); var wrapper = new FilteringTargetWrapper(myTarget, myMockCondition); wrapper.Initialize(CommonCfg); var logEvent = new LogEventInfo(); Exception lastException = null; var continuationHit = new ManualResetEvent(false); Action<Exception> continuation = ex => { lastException = ex; continuationHit.Set(); }; wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation)); continuationHit.WaitOne(); Assert.IsNull(lastException); Assert.AreEqual(0, myTarget.WriteCount); Assert.AreEqual(1, myMockCondition.CallCount); continuationHit.Reset(); wrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation)); continuationHit.WaitOne(); Assert.IsNull(lastException); Assert.AreEqual(0, myTarget.WriteCount); Assert.AreEqual(2, myMockCondition.CallCount); }
public void SimpleCommunication() { var reset1 = new ManualResetEvent(false); var reset2 = new ManualResetEvent(false); INatterConnection connection2 = null; var connection1 =_client1.OnConnected(c => reset1.Set()).OnData((c, f) => HandleResponse(f, c)).Call(GetClient2Address()); _client2.OnConnected(c => reset2.Set()).OnData((c, f) => { HandleResponse(f, c); connection2 = c; }); Assert.IsTrue(reset1.WaitOne(TimeSpan.FromSeconds(5)), "Failed to connect"); Assert.IsTrue(reset2.WaitOne(TimeSpan.FromSeconds(5)), "Failed to connect"); reset1.Reset(); reset2.Reset(); _client1.OnDisconnected(c => reset1.Set()); _client2.OnDisconnected(c => reset2.Set()); Send(connection1, StartNumber); Assert.IsTrue(reset1.WaitOne(TimeSpan.FromSeconds(80)), "Failed to disconnect"); Assert.IsTrue(reset2.WaitOne(TimeSpan.FromSeconds(80)), "Failed to disconnect"); Assert.AreEqual(ConnectionState.Disconnected, connection1.State, "Client not disconnected"); Assert.AreEqual(ConnectionState.Disconnected, connection2.State, "Client not disconnected"); Assert.AreEqual(EndNumber, _lastResult, "Invalid last number"); Assert.AreEqual((EndNumber - StartNumber) + 1, _count, "Invalid count"); }
public void AsyncTargetWrapperAsyncTest1() { var myTarget = new MyAsyncTarget(); var targetWrapper = new AsyncTargetWrapper(myTarget) { Name = "AsyncTargetWrapperAsyncTest1_Wrapper" }; targetWrapper.Initialize(null); myTarget.Initialize(null); var logEvent = new LogEventInfo(); Exception lastException = null; var continuationHit = new ManualResetEvent(false); AsyncContinuation continuation = ex => { lastException = ex; continuationHit.Set(); }; targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation)); Assert.True(continuationHit.WaitOne()); Assert.Null(lastException); Assert.Equal(1, myTarget.WriteCount); continuationHit.Reset(); targetWrapper.WriteAsyncLogEvent(logEvent.WithContinuation(continuation)); continuationHit.WaitOne(); Assert.Null(lastException); Assert.Equal(2, myTarget.WriteCount); }
public static void AppdomainLoop(bool benchConfiguration) { sync = new ManualResetEvent(false); while (true) { sync.Reset(); // create appdomain logger.Debug("domain starting."); AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation; AppDomain Domain = AppDomain.CreateDomain("ApplicationKeeper", null, setup); // BrokerApplication app = (BrokerApplication)Domain.CreateInstanceAndUnwrap( typeof(BrokerApplication).Assembly.FullName, typeof(BrokerApplication).FullName); //RunAppInSeparateThread(app); app.Run(sync, benchConfiguration, true); // waitfor sync sync.WaitOne(); // unload appdomain AppDomain.Unload(Domain); logger.Debug("domain unloaded."); GC.Collect(); // collects all unused memory GC.WaitForPendingFinalizers(); // wait until GC has finished its work GC.Collect(); } }
public void ClientCancelsLimitOrder() { OrderStatus status = OrderStatus.New; var manualResetEvent = new ManualResetEvent(false); var ib = new InteractiveBrokersBrokerage(); ib.Connect(); ib.OrderEvent += (sender, args) => { status = args.Status; manualResetEvent.Set(); }; // try to sell a single share at a ridiculous price, we'll cancel this later var order = new Order("AAPL", SecurityType.Equity, -1, OrderType.Limit, DateTime.UtcNow, 100000); ib.PlaceOrder(order); manualResetEvent.WaitOne(2500); ib.CancelOrder(order); manualResetEvent.Reset(); manualResetEvent.WaitOne(2500); Assert.AreEqual(OrderStatus.Canceled, status); }
public void Send(IcmpEchoSender.SendEchoInfo info, Action<IList<SendResult<IcmpEchoResponseDatagram>>> finished) { IPEndPoint endPoint = null; var finishedResult = new List<SendResult<IcmpEchoResponseDatagram>>(); var senderImpl = new IcmpTracertSenderImpl(); var lastTtl = 1; var manualResetevent = new ManualResetEvent(false); while (endPoint == null || endPoint.Address != info.IpAddress) { senderImpl.Send(new SendTracertInfo(info, lastTtl++), result => { endPoint = result.EndPoint as IPEndPoint; finishedResult.Add(result); manualResetevent.Set(); }); info.IncreaseSequence(); manualResetevent.WaitOne(); manualResetevent.Reset(); } senderImpl.CloseHost(); finished(finishedResult); }
public void AsyncTargetWrapperAsyncTest1() { var myTarget = new MyAsyncTarget(); var targetWrapper = new AsyncTargetWrapper(myTarget); ((ISupportsInitialize)targetWrapper).Initialize(); ((ISupportsInitialize)myTarget).Initialize(); var logEvent = new LogEventInfo(); Exception lastException = null; var continuationHit = new ManualResetEvent(false); AsyncContinuation continuation = ex => { lastException = ex; continuationHit.Set(); }; targetWrapper.WriteLogEvent(logEvent, continuation); continuationHit.WaitOne(); Assert.IsNull(lastException); Assert.AreEqual(1, myTarget.WriteCount); continuationHit.Reset(); targetWrapper.WriteLogEvent(logEvent, continuation); continuationHit.WaitOne(); Assert.IsNull(lastException); Assert.AreEqual(2, myTarget.WriteCount); }
public void TheadLocalTimeServerIsNotShared() { var ts1 = new TestDateTimeServer(now: new DateTime(2011, 1, 1)); var ts2 = new TestDateTimeServer(now: new DateTime(2012, 1, 1)); var g1 = new ManualResetEvent(false); var g2 = new ManualResetEvent(false); DateTime? t1Date = null; var t1 = new Thread(() => { DateTimeServer.SetLocal(ts1); g1.WaitOne(); t1Date = DateTimeServer.Now; g2.Set(); }); var t2 = new Thread(() => { DateTimeServer.SetLocal(ts2); g2.Set(); g1.WaitOne(); }); t1.Start(); t2.Start(); Assert.That(g2.WaitOne(20), Is.True); g2.Reset(); g1.Set(); Assert.That(g2.WaitOne(20), Is.True); Assert.That(t1Date, Is.Not.Null); Assert.That(t1Date, Is.EqualTo(ts1.Now)); }
public void Reset() { mStatus = -1; Error = null; IsCompleted = false; Result = null; mSpinWait.Reset(); mResetEvent.Reset(); }
private static void Main(string[] args) { Console.WriteLine("App started"); Runner(); Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] press Any key to pause"); Console.ReadKey(); ManualResetEvent.Reset(); Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] press Any key to continue"); Console.ReadKey(); ManualResetEvent.Set(); Console.ReadKey(); }
public override bool pause(out string error) { error = null; if (_mre.Reset()) { return(true); } else { error = "Could not reset mutex. pause failed"; return(false); } }
/// <summary> /// Uninitialize the client from operation. /// </summary> /// <returns></returns> public bool UnInitialize() { lock (Clients) { Clients.Remove(this); } lock (this) { if (_proxyServerInterface != null) { try { ((IChannel)_proxyServerInterface).Opened -= new EventHandler(MessageContainerTransportClient_Opened); ((IChannel)_proxyServerInterface).Opening -= new EventHandler(MessageContainerTransportClient_Opening); ((IChannel)_proxyServerInterface).Faulted -= new EventHandler(MessageContainerTransportClient_Faulted); ((IChannel)_proxyServerInterface).Closing -= new EventHandler(MessageContainerTransportClient_Closing); ((IChannel)_proxyServerInterface).Abort(); } catch (Exception ex) { SystemMonitor.OperationError(string.Empty, ex); } finally { _proxyServerInterface = null; } } if (_channelFactory != null) { try { _channelFactory.Abort(); } catch (Exception ex) { SystemMonitor.OperationError(string.Empty, ex); } finally { _channelFactory = null; } } _connectingEvent.Reset(); } return(true); }
// send thread function private void SendThread() { CSLogger.LogDebug("Enter SendThread"); try { Message msg = null; while (true) { if (m_socket == null || m_socket.Connected == false) { m_send_thread = null; break; } m_event_wait_send.WaitOne(); m_event_wait_send.Reset(); lock (m_send_queue) { while (m_send_queue.Count > 0) { msg = m_send_queue.Peek(); byte[] bytes = msg.ToBytes(); int result = 0; int byte_size = bytes.Length; while (result != byte_size) { try { result += m_socket.Send(bytes, result, byte_size - result, SocketFlags.None); } catch (System.Exception ex) { CSLogger.LogError(ex.ToString()); } } m_send_queue.Dequeue(); } } System.Threading.Thread.Sleep(10); } } catch (SocketException /*e*/) { CSLogger.LogDebug("SendThread: SocketException "); } catch (Exception /*e*/) { CSLogger.LogDebug("SendThread: Exception "); } CSLogger.LogDebug("Exit SendThread"); }
/// <summary> /// pauses the encoding process /// </summary> /// <param name="error">output for any errors that might ocurr during this method</param> /// <returns>true if encoding has been successfully paused, false if not</returns> public bool pause(out string error) { error = ""; try { mre.Reset(); } catch (Exception e) { error = e.Message; return(false); } return(true); }
/// <summary> /// Signal the graph update thread to start processing graph updates if there are any in the <see cref="graphUpdateQueueAsync"/> queue. /// Returns: True if the other thread was signaled. /// </summary> private bool StartAsyncUpdatesIfQueued() { if (graphUpdateQueueAsync.Count > 0) { #if UNITY_WEBGL throw new System.Exception("This should not happen in WebGL"); #else asyncGraphUpdatesComplete.Reset(); graphUpdateAsyncEvent.Set(); return(true); #endif } return(false); }
private void SendThread() { try { while (true) { if (!Connected) { _sendThread = null; break; } _waitSend.WaitOne(); //阻塞当前线程 _waitSend.Reset(); //线程只处理一次,立即阻塞 lock (_sendQueue) { while (_sendQueue.Count > 0) { _sendProtocolItem = _sendQueue.Peek(); _bytes = _sendProtocolItem.ProtocolItemBytes; #if blowfish _mbw.Clear(); _bytes = _encryptBF.Encrypt_ECB(_bytes); _mbw.Write(_bytes.Length + ProtocolConf.PACKGE_LEN); _mbw.Write(_bytes); _bytes = _mbw.ToArray(); #endif int result = 0; int byteSize = _bytes.Length; while (result != byteSize) { result += _socket.Send(_bytes, result, byteSize - result, SocketFlags.None); } _sendQueue.Dequeue(); Debugger.Log("给服务器发送数据:" + result + ", 协议体:" + _sendProtocolItem.ToString()); } } } } catch (SocketException se) { Debugger.LogError("MSocketException" + se); } catch (Exception e) { Debugger.LogError("MSocketException" + e); } }
public void Test() { CodeTimer.Time("ManualRestEvent(false)", () =>//无信号,可以通过WaitOne 阻塞线程的执行,通过Set发出信号唤醒等待的线程 { using (System.Threading.ManualResetEvent are = new System.Threading.ManualResetEvent(false)) { System.Threading.ThreadPool.QueueUserWorkItem((s) => { Thread.Sleep(2000); Console.WriteLine("Run!"); are.Set(); }); Console.WriteLine(are.WaitOne(5000)); } }); CodeTimer.Time("ManualRestEvent(true)", () =>//有信号表示终止状态,即线程属于闲置状态 { using (System.Threading.ManualResetEvent are = new System.Threading.ManualResetEvent(true)) { System.Threading.ThreadPool.QueueUserWorkItem((s) => { Thread.Sleep(1000); Console.WriteLine("Not Run!"); if (!are.SafeWaitHandle.IsClosed) { are.Set(); } }); are.WaitOne();//不会等待子线程的结束 } }); CodeTimer.Time("ManualRestEvent(reset)", () => { using (System.Threading.ManualResetEvent are = new System.Threading.ManualResetEvent(true)) { System.Threading.ThreadPool.QueueUserWorkItem((s) => { Thread.Sleep(1000); Console.WriteLine("Run!"); are.Set(); }); are.WaitOne(); //不会等待子线程的结束 are.Reset(); // are.WaitOne(); } }); }
public bool Execute(string filename, string arg) { if (filename == null || filename.Length < 1) { //GCError.SetLastError("Invalid arugment(s)."); return(false); } //try //{ ProcessStartInfo pi = new ProcessStartInfo(); pi.FileName = filename; pi.CreateNoWindow = false; pi.Arguments = " >> " + filename + ".log"; waitEvent.Reset(); Process p = Process.Start(pi); if (p != null) { p.Exited += new EventHandler(process_Exited); p.EnableRaisingEvents = true; } else { //GCError.SetLastError("Cannot start process." + filename); return(false); } bool res = waitEvent.WaitOne(TimeOut, true); if (!res) { //GCError.SetLastError("Execure script time out." + filename); } return(res); //} //catch (Exception err) //{ // //GCError.SetLastError("Start process failed." + filename); // //GCError.SetLastError(err); // return false; //} }
public DebuggerEvent Wait() { for (int i = 0; i < 5; i++) { lock (queue.SyncRoot) { if (queue.Count > 0) { return((DebuggerEvent)queue.Dequeue()); } wait_event.Reset(); } wait_event.WaitOne(3000, false); } return(null); }
private void thread_entry() { for (;;) { try { main_loop(); // Debug.Assert(update_sync_frame_ >= render_sync_frame_); while (update_sync_frame_ >= render_sync_frame_) { manual_reset_event_.WaitOne(); manual_reset_event_.Reset(); } ++update_sync_frame_; } catch (System.Exception e) { Debug.Log(e); } } }
/// <summary> /// 取出一个消息 /// </summary> public Message PopData() { Message ci; mutex.WaitOne(); if (cmdq.Count > 0) { ci = cmdq.Dequeue() as Message; } else { ci = null; } if (cmdq.Count == 0) { evt.Reset(); } mutex.ReleaseMutex(); return(ci); }
private void thread_entry() { // TaskManager.Instance.setCamera(camera); // restart(); for (;;) { try { main_loop(); while (update_sync_frame_ >= render_sync_frame_) { manual_reset_event_.WaitOne(); manual_reset_event_.Reset(); } ++update_sync_frame_; } catch (System.Exception e) { Debug.Log(e); } } }