public static void Main(string[] args) { var done = new EventWaitHandle(false, EventResetMode.AutoReset); var yield = new Thread( new ParameterizedThreadStart( data => { Console.WriteLine(new { data }); done.Set(); } ) ); Console.WriteLine("before wait " + DateTime.Now); // Additional information: Thread has not been started. done.WaitOne(2100); Console.WriteLine("after wait " + DateTime.Now); yield.Start(new { foo = "bar" }); done.WaitOne(); Console.WriteLine("done"); CLRProgram.CLRMain(); }
public void ThreadDiffusionStep(object o) { fluid.UpdateDensityStep(viscoscity, frame_dt, chunkX, chunkY, NCount, startIdxX, startIdxY); if (System.Threading.Interlocked.Decrement(ref numberOfWorkers) == 0) { AllWorkersCompleted.Set(); } }
public void StartMission(string missionName) { var down = Program.Downloader.GetResource(DownloadType.MISSION, missionName); if (down == null) { //okay Mission exist, but lets check for dependency! down = Program.Downloader.GetDependenciesOnly(missionName); } var engine = Program.Downloader.GetResource(DownloadType.ENGINE, Program.TasClient.ServerWelcome.Engine ?? GlobalConst.DefaultEngineOverride); var metaWait = new EventWaitHandle(false, EventResetMode.ManualReset); Mod modInfo = null; Program.MetaData.GetModAsync(missionName, mod => { if (!mod.IsMission) { Program.MainWindow.InvokeFunc(() => { WarningBar.DisplayWarning(string.Format("{0} is not a valid mission", missionName)); }); } else modInfo = mod; metaWait.Set(); }, error => { Program.MainWindow.InvokeFunc(() => { WarningBar.DisplayWarning(string.Format("Download of metadata failed: {0}", error.Message)); //container.btnStop.Enabled = true; }); metaWait.Set(); }); var downloads = new List<Download>() { down, engine }.Where(x => x != null).ToList(); if (downloads.Count > 0) { var dd = new WaitDownloadDialog(downloads); if (dd.ShowDialog(Program.MainWindow) == DialogResult.Cancel) { Program.MainWindow.InvokeFunc(() => Program.NotifySection.RemoveBar(this)); return; } } metaWait.WaitOne(); var spring = new Spring(Program.SpringPaths); spring.RunLocalScriptGame(modInfo.MissionScript, Program.TasClient.ServerWelcome.Engine ?? GlobalConst.DefaultEngineOverride); var cs = GlobalConst.GetContentService(); cs.NotifyMissionRun(Program.Conf.LobbyPlayerName, missionName); spring.SpringExited += (o, args) => RecordMissionResult(spring, modInfo); Program.MainWindow.InvokeFunc(() => Program.NotifySection.RemoveBar(this)); }
/// <summary> /// 测试回调 /// </summary> /// <param name="value"></param> internal static void OnAdd(AutoCSer.Net.TcpServer.ReturnValue <AutoCSer.TestCase.TcpServerPerformance.Add> value) { int right; if (value.Value.CheckSum(Left, out right) != 0 || !addMap.SetWhenNullUnsafe(right)) { ++ErrorCount; } if (--waitCount == 0) { Time.Stop(); WaitHandle.Set(); } }
/// <summary> /// 测试回调 /// </summary> /// <param name="value"></param> internal static void OnAdd(AutoCSer.Net.TcpServer.ReturnValue <AutoCSer.TestCase.TcpServerPerformance.Add> value) { int right; if (value.Value.CheckSum(Left, out right) != 0 || !addMap.SetWhenNullUnsafe(right)) { ++ErrorCount; } //if (System.Threading.Interlocked.Decrement(ref waitCount) == 0) if (--waitCount == 0) { Time.Stop(); WaitHandle.Set(); } }
private static bool OnlyOneCopy() { bool isnew; s_setup_mutex = new Mutex(true, SETUP_MUTEX_NAME, out isnew); RestoreEvent = null; try { #if RELEASE RestoreEvent = AutoResetEvent.OpenExisting(EVENT_NAME); RestoreEvent.Set(); return false; } catch (WaitHandleCannotBeOpenedException) { #endif string user = Environment.UserDomainName + "\\" + Environment.UserName; EventWaitHandleSecurity evh_sec = new EventWaitHandleSecurity(); EventWaitHandleAccessRule rule = new EventWaitHandleAccessRule(user, EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify, AccessControlType.Allow); evh_sec.AddAccessRule(rule); bool was_created; RestoreEvent = new EventWaitHandle(false, EventResetMode.AutoReset, EVENT_NAME, out was_created, evh_sec); } catch (Exception) { } return true; }
public Controller(BlockingMediator mediator) { _signal = new AutoResetEvent(false); mediator.AddSignal(_signal); dynamic config = ConfigurationManager.GetSection("delays"); var delays = new Dictionary<MessageType, int>(); foreach (string name in config) { delays[Hearts.Utility.Enum.Parse<MessageType>(name)] = int.Parse(config[name]); } foreach (var type in Hearts.Utility.Enum.GetValues<MessageType>()) { var key = type; mediator.Subscribe(type, ignore => { if (delays.ContainsKey(key)) { Thread.Sleep(delays[key]); } _signal.Reset(); if (!IsBlocking) { ThreadPool.QueueUserWorkItem(_ => _signal.Set()); } }); } }
static void Main(string[] args) { // Create a IPC wait handle with a unique identifier. bool createdNew; var waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, "ImperatorWaitHandle", out createdNew); // If the handle was already there, inform the other process to exit itself. // Afterwards we'll also die. if (!createdNew) { Console.WriteLine("Found other Imperator process. Requesting stop..."); waitHandle.Set(); Console.WriteLine("Informer exited."); return; } Console.WriteLine("Initializing Container..."); var container = new ContainerInitializer().Initialize(); Console.WriteLine("Connecting to UI..."); var hubClient = container.GetInstance<IHubClient>(); hubClient.OpenConnection(); Console.WriteLine("Connected"); Console.WriteLine("Initializing Imperator..."); var i = container.GetInstance<Imperator>(); i.InitializeConfig(); i.StartImperator(); waitHandle.WaitOne(); Console.WriteLine("Closing Imperator..."); }
public DoubleLaunchLocker(string signalId, string waitId, bool force = false) { _force = force; SignalId = signalId; WaitId = waitId; bool isNew; _signalHandler = new EventWaitHandle(false, EventResetMode.AutoReset, signalId, out isNew); if (!isNew) { Application.Current.ShutdownMode = ShutdownMode.OnExplicitShutdown; bool terminate = false; if (!force && !RequestConfirmation()) terminate = true; if (!terminate) { _waitHandler = new EventWaitHandle(false, EventResetMode.AutoReset, waitId); if (_signalHandler.Set()) terminate = !_waitHandler.WaitOne(TIMEOUT); else terminate = true; } if (terminate) { TryShutdown(); ForceShutdown(); } else Application.Current.ShutdownMode = ShutdownMode.OnLastWindowClose; } ThreadPool.QueueUserWorkItem(WaitingHandler, waitId); }
public void ShouldJoinDirectMessageChannel() { // given var client = ClientHelper.GetClient(_config.Slack.UserAuthToken); string userName = _config.Slack.DirectMessageUser; string user = client.Users.First(x => x.name.Equals(userName, StringComparison.InvariantCultureIgnoreCase)).id; // when EventWaitHandle wait = new EventWaitHandle(false, EventResetMode.ManualReset); client.JoinDirectMessageChannel(response => { Assert.IsTrue(response.ok, "Error while joining user channel"); Assert.IsTrue(!string.IsNullOrEmpty(response.channel.id), "We expected a channel id to be returned"); wait.Set(); }, user); // then Policy .Handle<AssertFailedException>() .WaitAndRetry(15, x => TimeSpan.FromSeconds(0.2), (exception, span) => Console.WriteLine("Retrying in {0} seconds", span.TotalSeconds)) .Execute(() => { Assert.IsTrue(wait.WaitOne(), "Took too long to do the THING"); }); }
static void Main(string[] args) { EventWaitHandle handle = new EventWaitHandle(false, EventResetMode.AutoReset, uniqueHandleName); AppDomain appDomain1 = AppDomain.CreateDomain("App Domain 1"); Thread thread1 = new Thread(new ThreadStart(() => appDomain1.DoCallBack(() => { EventHandleResponder responder = new EventHandleResponder(); responder.Run(); }))); thread1.Start(); Console.WriteLine("Enter 1 to set the signal on the wait handle."); Console.WriteLine("Enter q to quit."); string input = string.Empty; while (input != "quit" && input != "q") { input = Console.ReadLine(); switch (input) { case "1": handle.Set(); break; } } }
public AbsoluteTimerWaitHandle(DateTimeOffset dueTime) { _dueTime = dueTime; _eventWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); SafeWaitHandle = _eventWaitHandle.SafeWaitHandle; var dueSpan = (_dueTime - DateTimeOffset.Now); var period = new TimeSpan(dueSpan.Ticks / 10); if (dueSpan < TimeSpan.Zero) { _eventWaitHandle.Set(); } else { _timer = new Timer(period.TotalMilliseconds) { AutoReset = false, }; _timer.Elapsed += TimerOnElapsed; _timer.Start(); } }
public void Should_be_able_to_cancel_message_reception_with_a_cancellation_token() { const string mmfName = "Local\\test"; var message = "not null"; var messageCancelled = new EventWaitHandle(false, EventResetMode.ManualReset, mmfName + "_MessageCancelled"); messageCancelled.Set(); using (var messageReceiver = new MemoryMappedFileMessageReceiver(mmfName)) using (var cancellationTokenSource = new CancellationTokenSource()) { var task = new Task(() => message = messageReceiver.ReceiveMessage(ReadString, cancellationTokenSource.Token)); task.Start(); var isSet = true; while (isSet) isSet = messageCancelled.WaitOne(0); cancellationTokenSource.Cancel(); task.Wait(); message.ShouldBeNull(); } }
void AuthSignIn() { EventWaitHandle wait = new EventWaitHandle(false, EventResetMode.ManualReset); SlackSocketClient client = new SlackSocketClient(token); client.OnHello += () => { wait.Set(); }; client.Connect((l) => { if (!l.ok) return; BeginInvoke(new Action(() => { connected = new ConnectedInterface(client, l); connected.Dock = DockStyle.Fill; Controls.Add(connected); password.Visible = false; })); }); wait.WaitOne(); }
public void Should_be_able_to_cancel_message_reception_upon_disposal() { const string mmfName = "Local\\test"; var message = "not null"; var messageCancelled = new EventWaitHandle(false, EventResetMode.ManualReset, mmfName + "_MessageCancelled"); messageCancelled.Set(); var messageReceiver = new MemoryMappedFileMessageReceiver(mmfName); var task = new Task(() => message = messageReceiver.ReceiveMessage(ReadString)); task.Start(); var isSet = true; while (isSet) isSet = messageCancelled.WaitOne(0); messageReceiver.Dispose(); task.Wait(); message.ShouldBeNull(); }
public void ServerResponds() { using (var container = SetupMefContainer()) { using (var server = container.GetExport<IServerProcessProxy>().Value) { var waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); var request = new IpcRequest { RequestId = 5, Protocol = IpcProtocols.Echo, Data = new IpcStringData { Text = "sdfsdsd" } }; IpcResponse response = null; server.RunAsync(request, x => { response = x; waitHandle.Set(); }); Assert.IsTrue(waitHandle.WaitOne(TimeSpan.FromSeconds(5.0)), "Server did not respond within 5 seconds."); Assert.AreEqual(5, response.RequestId); Assert.AreEqual(IpcProtocols.Echo, response.Protocol); Assert.IsNotNull(request.Data); Assert.IsNotNull(response.Data); Assert.AreEqual(request.Data.GetType(), typeof(IpcStringData)); Assert.AreEqual(response.Data.GetType(), typeof(IpcStringData)); Assert.AreEqual((request.Data as IpcStringData).Text, (response.Data as IpcStringData).Text); } } }
static void RunInThreadPoolWithEvents() { double result = 0d; // We use this event to signal when the thread is don executing. EventWaitHandle calculationDone = new EventWaitHandle(false, EventResetMode.AutoReset); // Create a work item to read from I/O ThreadPool.QueueUserWorkItem((x) => { result += Utils.CommonFunctions.ReadDataFromIO(); calculationDone.Set(); }); // Save the result of the calculation into another variable double result2 = Utils.CommonFunctions.DoIntensiveCalculations(); // Wait for the thread to finish calculationDone.WaitOne(); // Calculate the end result result += result2; // Print the result Console.WriteLine("The result is {0}", result); }
public static SlackSocketClient GetClient(string authToken) { var wait = new EventWaitHandle(false, EventResetMode.ManualReset); var client = new SlackSocketClient(authToken); client.Connect(x => { Console.WriteLine("RTM Start"); }, () => { Console.WriteLine("Connected"); wait.Set(); }); Policy .Handle<AssertFailedException>() .WaitAndRetry(15, x => TimeSpan.FromSeconds(0.2), (exception, span) => Console.WriteLine("Retrying in {0} seconds", span.TotalSeconds)) .Execute(() => { Assert.IsTrue(wait.WaitOne(), "Still waiting for things to happen..."); }); Policy .Handle<AssertFailedException>() .WaitAndRetry(15, x => TimeSpan.FromSeconds(0.2), (exception, span) => Console.WriteLine("Retrying in {0} seconds", span.TotalSeconds)) .Execute(() => { Assert.IsTrue(client.IsConnected, "Doh, still isn't connected"); }); return client; }
private void DebuggerStart(EventWaitHandle startWaitHandle, Func<ProcessInformation> processCreator, Action<ProcessInformation> callback, Action<Exception> errorCallback) { try { _debuggerThread = Thread.CurrentThread; // Note: processCreator is responsible for creating the process in DEBUG mode. // Note: If processCreator throws an exception after creating the // process, we may end up in a state where we received debugging events // without having "_processInformation" set. We need to be able to deal // with that. _processInformation = processCreator(); callback(_processInformation); } catch (Exception e) { errorCallback(e); return; } finally { startWaitHandle.Set(); } _running = true; try { DebuggerLoop(); } finally { _running = false; } }
private void StartClientServer(object obj) { try { int clientServerPort = (int)obj; s_Logger.LogInfo("IMissionControl::ClientThe port sent from server is " + clientServerPort.ToString()); MarshalByRefObject processProxyObject = GetProcessProxy();//factory TcpServerChannel clientServer = new TcpServerChannel("WinSniperClient", clientServerPort); ChannelServices.RegisterChannel(clientServer, true); RemotingServices.Marshal(processProxyObject, "WinSniperClient.rem"); s_Logger.LogInfo("Sniper ClientServer has been started and listening at " + clientServerPort.ToString()); System.Threading.EventWaitHandle wh = EventWaitHandle.OpenExisting("SniperWaiting", EventWaitHandleRights.Modify); wh.Set(); while (true) { Thread.Sleep(1000); } } catch (ThreadAbortException e) { s_Logger.LogError("Client Server Thread has been aborted. "); } catch (Exception e) { new Mayday(e); } }
public Waiter(TimeSpan? interval = null) { _waitHandle = new AutoResetEvent(false); _timer = new System.Timers.Timer(); _timer.Elapsed += (sender, args) => _waitHandle.Set(); SetInterval(interval); }
public static void Main(string[] args) { var dir = @"c:\tmp"; if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } ewh = new EventWaitHandle(false, EventResetMode.ManualReset); for (int i = 0; i <= 10; i++) { var t = new Thread(ThreadProc); t.Start(i); Console.WriteLine("Tread {0} started", i); } watcher = new FileSystemWatcher() { Path = dir, IncludeSubdirectories = false, EnableRaisingEvents = true, }; watcher.Created += (sender, eventArgs) => { ewh.Set(); }; Console.WriteLine("Press any key...."); Console.ReadLine(); }
public void OnNext(bool value) { if (value == true) { eventWaitHandle.Set(); } }
/// <summary> /// Fetches the Dota 2 Item schema. /// </summary> /// <param name="apiKey">The API key.</param> /// <returns>A deserialized instance of the Item Schema.</returns> /// <remarks> /// The schema will be cached for future use if it is updated. /// </remarks> public static Dota2Schema FetchSchema (string apiKey) { var url = SchemaApiUrlBase + apiKey; // just let one thread/proc do the initial check/possible update. bool wasCreated; var mre = new EventWaitHandle(false, EventResetMode.ManualReset, SchemaMutexName, out wasCreated); // the thread that create the wait handle will be the one to // write the cache file. The others will wait patiently. if (!wasCreated) { bool signaled = mre.WaitOne(10000); if (!signaled) { return null; } } HttpWebResponse response = SteamWeb.Request(url, "GET"); DateTime schemaLastModified = response.LastModified; string result = GetSchemaString(response, schemaLastModified); response.Close(); mre.Set(); SchemaResult schemaResult = JsonConvert.DeserializeObject<SchemaResult> (result); return schemaResult.result ?? null; }
public void Reset(int count) { if (count < 0) throw new ArgumentOutOfRangeException(); _remaining = count; _event = new ManualResetEvent(false); if (_remaining == 0) _event.Set(); }
public void Learn() { ewh=new EventWaitHandle(false,EventResetMode.AutoReset); for (int i = 0; i <=4; i++) { Thread t=new Thread(new ParameterizedThreadStart(ThreadProc)); t.Start(i); } while (Interlocked.Read(ref threadCount)<5) { Thread.Sleep(500); } while (Interlocked.Read(ref threadCount)>0) { Console.WriteLine("Press Enter to release a waiting thread."); Console.ReadLine(); clearCount.Set(); WaitHandle.SignalAndWait(ewh, clearCount); Console.WriteLine("loop again."); } Console.WriteLine(); ewh=new EventWaitHandle(false,EventResetMode.ManualReset); for (int i = 0; i <=4; i++) { Thread t=new Thread(new ParameterizedThreadStart(ThreadProc)); t.Start(i); } while (Interlocked.Read(ref threadCount)<5) { Thread.Sleep(500); } Console.WriteLine("Press ENTER to release the waiting threads"); Console.ReadLine(); ewh.Set(); ewh.Reset(); Console.WriteLine("Press ENTER to release the waiting threads"); Console.ReadLine(); ewh.Set(); }
/// <summary> /// Scans a given page for proxy servers. /// </summary> /// <param name="proxyListingPage">The proxy listing page.</param> /// <param name="parseAsRawText">If the page must be parsed as raw text (no HTML tags)</param> /// <param name="hostPortEx">The custom parsing expression (providing "address" or "host" and "port" tags) or null to use default</param> /// <param name="route"></param> /// <param name="testTarget"></param> /// <returns></returns> public IEnumerable<ProxyServer> ScanPage(Uri proxyListingPage, bool parseAsRawText, string hostPortEx, Route route, Uri testTarget) { string proxyListingPageText = null; try { proxyListingPageText = Downloader.Download(proxyListingPage, parseAsRawText, route); } catch (ProxyRouteException) { } if (proxyListingPageText == null) yield break; var results = new Queue<ProxyServer>(); var waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset); var thread = new Thread(delegate() { HostScanner.Scan(proxyListingPageText, hostPortEx).AsParallel().WithDegreeOfParallelism(63) .ForAll(delegate(ProxyServer proxyServer) { if (!ProxyValidator.Validate(proxyServer, testTarget, route)) return; lock (results) results.Enqueue(proxyServer); waitHandle.Set(); }); lock (results) results.Enqueue(null); waitHandle.Set(); }); thread.Start(); for (; ; ) { waitHandle.WaitOne(); lock (results) { while (results.Count > 0) { var result = results.Dequeue(); if (result == null) yield break; yield return result; } } } }
private Task<bool> StopGracefully(IProcess process) { string exePath = process.ExePath; Trace.TraceInformation("Attempting to gracefully stop the process"); var stopEvent = new EventWaitHandle(false, EventResetMode.AutoReset, exePath.Replace("\\", string.Empty)); stopEvent.Set(); return ProcessUtils.SpinWaitForExit(process, _waitForExitInSeconds); }
unsafe void ThreadFunc() { eventWH = new EventWaitHandle(false, EventResetMode.AutoReset, "ulHelper_appLiveEvent_" + acc.Name); while (!acc.NeedTerminate) { Thread.Sleep(100); eventWH.Set(); } }
public void Disposed_Set () { var ewh = new EventWaitHandle (false, EventResetMode.ManualReset); ewh.Dispose(); try { ewh.Set(); Assert.Fail (); } catch (ObjectDisposedException) { } }
public void Connect() { if (!IsRunning) { Thread worker = new Thread(() => { try { IsRunning = true; _shouldStop = false; wait = new EventWaitHandle(false, EventResetMode.ManualReset); client.Connect(1000); if (client.IsConnected) { while (!_shouldStop) { byte[] m_buffer = new byte[256]; client.BeginRead(m_buffer, 0, 255, ir => { try { client.EndRead(ir); wait.Set(); } catch (Exception ex) { if (!(ex is ArgumentException)) Debugger.Break(); } }, null); wait.WaitOne(); } } IsRunning = false; } catch (Exception ex) { if (ex is TimeoutException) Console.WriteLine("Unable to connect to CWSRestart. Make sure that the process communication is enabled in CWSRestart"); else System.Diagnostics.Debugger.Break(); IsRunning = false; } }); worker.Start(); } else { Console.WriteLine("Communication is already running."); } }
static void Main() { var model = new Model{ ObjectSensorConfig = VideoSource.USB }; model.ServosConfig[ServoPort.C1] = Defaults.Servo3; model.ServosConfig[ServoPort.C2] = Defaults.Servo3; var sensor = model.ObjectSensor; var sensorOutput = sensor.ToObservable(); var locationStream = from data in sensorOutput where data.IsLocation let loc = data.GetLocation where loc.Mass > Constants.MinMass select loc; //var locationStream = sensor.ToObservable() // .Where(o => o.IsLocation).Select(o => o.GetLocation) // .Where(loc => loc.Mass > Constants.MinMass); var xPowerSetter = locationStream .Select(loc => -loc.X) .Scan(0, (acc, x) => Calculations.Limit(-90, 90, acc) + ScaleXValue(x)) .Subscribe(model.Servos[ServoPort.C1]); var yPowerSetter = locationStream .Select(loc => loc.Y) .Scan(0, (acc, y) => Calculations.Limit(-90, 90, acc) + ScaleYValue(y)) .Subscribe(model.Servos[ServoPort.C2]); var buttons = model.Buttons; var exit = new EventWaitHandle(false, EventResetMode.AutoReset); var targetStream = from data in sensorOutput where data.IsTarget select data.GetTarget; var setterDisposable = targetStream.Subscribe(sensor.SetDetectTarget); var observableButtons = buttons.ToObservable(); var downButtonDetect = observableButtons .Where(x => ButtonEventCode.Down == x.Button) .Subscribe(x => sensor.Detect()); var upButtonDispose = observableButtons .Where(x => ButtonEventCode.Up == x.Button) .Subscribe(x => exit.Set()); buttons.Start(); sensor.Start(); Shell.Send(@"v4l2-ctl -d ""/dev/video2"" --set-ctrl white_balance_temperature_auto=1"); exit.WaitOne(); }
public ActionResult Command(String deviceId, int timeout = 60) { EventWaitHandle waitHandle; using (mongoContext = Context.MongoDBContext.MongoContextFactory.GetContext()) using (rabbitContext = Context.RabbitMqContext.RabbitMqContextFactory.GetContext()) { JObject command = rabbitContext.GetCommand(deviceId); if (command == null) { //загрузка ЦП на самом деле не меняется абсолютно waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset); NewCommandSignal sign = delegate(String devId) { if (deviceId == devId) { command = rabbitContext.GetCommand(deviceId); waitHandle.Set(); } }; //на момент написания этого кода у меня похоже недостаточно опыта в WCF чтобы элегантно реализвать long polling // в асинхронном виде. да еще встроить в ASP.net контроллер. есть в документации аттрбут AsyncPattern для контракта. если удасться, к понедельнику переделаю //c использованием WCF. хотя что-то мне подсказывает, что я должен был сделать не на ASP.net при использовании WCF, а просто на WCF onNewCommand += sign; waitHandle.WaitOne((Int32)timeout * 1000); onNewCommand -= sign; if (onRequestProcessed != null) onRequestProcessed.Invoke(command); if (command != null) { return Json((Models.DSRCommand)command.ToObject(typeof(Models.DSRCommand)), JsonRequestBehavior.AllowGet); } else { return Json(null, JsonRequestBehavior.AllowGet); } } else { String js = command.ToString(); if (onRequestProcessed != null) onRequestProcessed.Invoke(command); return Json((Models.DSRCommand)command.ToObject(typeof(Models.DSRCommand)), JsonRequestBehavior.AllowGet); } } }
private static async Task Start(EventWaitHandle exit) { IBus bus = await SetupBus(); var fireHoseSender = new FireHoseSender(bus); Console.WriteLine("How many messages would you like to spray?"); while (true) { var consoleInput = Console.ReadLine(); if (string.IsNullOrWhiteSpace(consoleInput)) { Console.WriteLine("Please enter number or type 'Exit'"); } else { if (consoleInput.ToLowerInvariant() == "exit") { exit.Set(); break; } int numberOfMessages; if (!int.TryParse(consoleInput, out numberOfMessages)) { Console.WriteLine("Please enter a valid number"); continue; } await fireHoseSender.SprayMessages(numberOfMessages); break; } } Console.ReadKey(); exit.Set(); }
public static void BeginProgram(bool isStep) { if (isRunning && !isStep) { isRunning = false; waitHandle.Set(); } var t = new Thread(() => ExecuteProgram(isStep)); t.IsBackground = true; t.Start(); }
public Task Execute() { TestLib.DispatchContainer.GlobalDispatcher = vm_.Dispatcher; return Task.Run(async () => { try { var testContainer = GetTestingAssembly(); int failureCount = 0, totalCount = 0; foreach (Type testType in GetTestTypes(testContainer)) { UnitTest test = (UnitTest)Activator.CreateInstance(testType); test.Log = log_; int testFailures = 0; foreach (var methodDesc in GetTestMethods(testType)) { test.Assert.TestName = methodDesc.Method.DeclaringType.Name + "." + methodDesc.Method.Name; if (methodDesc.RunInDispatcherContext) { EventWaitHandle wh = new EventWaitHandle(false, EventResetMode.AutoReset); test.Assert.WaitHandle = wh; await vm_.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => { testFailures = await ExecuteTest(test, testFailures, methodDesc); wh.Set(); }); wh.WaitOne(methodDesc.Timeout); } else { testFailures = await ExecuteTest(test, testFailures, methodDesc); } } failureCount += testFailures; totalCount += test.Assert.Count; vm_.AddMessage(string.Format("Completed '{0}' [{1} assertion(s), {2} failure(s)]", testType.Name, test.Assert.Count, testFailures)); vm_.UpdateMessages(); } vm_.AddMessage(string.Format("All tests completed [{0} assertion(s), {1} failure(s)]", totalCount, failureCount)); vm_.UpdateMessages(); } catch (Exception ex) { if (Debugger.IsAttached) Debugger.Break(); } }); }
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) { logIt(e.ToString()); Exception ex = default(Exception); ex = (Exception)e.ExceptionObject; logIt(ex.StackTrace); if (ewait != null) { ewait.Set(); //ewait.Close(); } // }
//bool logged; // Update is called once per frame void Update() { lidar(); position(); distanceFromFlag(); if (!updated) { updatePostion(); updated = true; waitHandle.Set(); } //travelled(); }
public void Start() { if (alreadyStarted) { lock (forState) this.internalState = ThreadState.Running; restart.Set(); } else { alreadyStarted = true; lock (forState) this.internalState = ThreadState.Running; this.gThread.Start(); } }
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) { logIt(e.ToString()); Exception ex = default(Exception); ex = (Exception)e.ExceptionObject; logIt(ex.StackTrace); if (ewait != null) { ewait.Set(); //ewait.Close(); } Thread.Sleep(5000); Util.runExeOnly(System.Reflection.Assembly.GetEntryAssembly().Location, "-start-service"); Environment.Exit(1000); }
void ICallback.Response(MercuryResponse response) { _reference = response; _waitHandle.Set(); }
void _popup_Closed(object sender, object e) { _handle.Set(); }
static void Main(string[] args) { System.Configuration.Install.InstallContext _arg = new System.Configuration.Install.InstallContext(null, args); if (_arg.IsParameterTrue("debug")) { System.Console.WriteLine("Wait for debugger, press any key to continue..."); System.Console.ReadKey(); } // dump version logIt(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileVersionInfo.ToString()); // dump args logIt(string.Format("called by arg: ({0})", args.Length)); foreach (string s in args) { logIt(s); } System.AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); if (_arg.IsParameterTrue("start-service")) { // start service Boolean bFind = false; try { ewait = System.Threading.EventWaitHandle.OpenExisting(IdeviceInfoSvcHost_Event_Name); ewait.Close(); logIt("Instance already started."); } catch (WaitHandleCannotBeOpenedException) { bFind = true; } catch (Exception) { } if (bFind) { try { ewait = new EventWaitHandle(false, EventResetMode.ManualReset, IdeviceInfoSvcHost_Event_Name); //Util.InitEnviroment(); new Thread(() => { iDeviceClass.start(); }).Start(); Console.WriteLine(@"Press any key to terminate..."); while (!ewait.WaitOne(1000)) { if (System.Console.KeyAvailable) { ewait.Set(); } } ewait.Close(); iDeviceClass.stop(); } catch (Exception) { } } } else if (_arg.IsParameterTrue("kill-service")) { // stop service try { ewait = System.Threading.EventWaitHandle.OpenExisting(IdeviceInfoSvcHost_Event_Name); if (ewait != null) { ewait.Set(); } } catch (Exception) { } } else { System.Console.WriteLine("MonitoriDevice.exe"); System.Console.WriteLine("-start-service: to start the service"); System.Console.WriteLine("-kill-service: to stop the service"); } }
public void Append(byte[] bytes) { this.queue.Enqueue(bytes); ewh.Set(); }
static int Main(string[] args) // :обновление { AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); Directory.SetCurrentDirectory(Path.GetDirectoryName(Application.ExecutablePath)); repairUpdateExe(); var repair = args.Length == 0 || (args.Length == 1 && args[0] == "-repair"); if (Repair(repair) && repair) { Console.WriteLine("repair started - succes"); return(40); } if (args.Length > 5 || args.Length < 4) { writeHelp(); return(1); } mainMutexForLog.WaitOne(); addBootRun(); Semaphore s = null; //new System.Threading.Semaphore(50, 50, "vs8.ru updator semaphore"); Mutex syncSemaphoreMutex = null; int sCount = 0, rCount = 0, mCount = 0; bool updatorUpdate = false; try { if (args[1] == "vs8.ru updator semaphore") { main.Set(); sCount = 50; updatorUpdate = true; } else { sCount = Int32.Parse(args[2]); } if (args[1].Length > 0) { s = new Semaphore(sCount, sCount, args[1]); syncSemaphoreMutex = new Mutex(false, args[1] + " umove sync mutex"); } if (syncSemaphoreMutex != null) { if (!syncSemaphoreMutex.WaitOne(0)) { return(32); } mCount = 1; } var RepairInfo = setRepairInfo(args); if (s != null) { rCount = blockSemaphore(s, sCount); } var returned = umoveProcess(args); if (returned == 0) { Console.WriteLine("success"); } else { Console.WriteLine("failure with code " + returned); } File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Исполнено с кодом " + returned, getArgumentsFromArgArray(args))); if (updatorUpdate) { File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Стартуем ./updatorvs8.exe -umove", getArgumentsFromArgArray(args))); Process.Start("updatorvs8.exe", "-umove"); } if (args[3].Length > 0) { if (args.Length == 4) { File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Стартуем " + args[3], getArgumentsFromArgArray(args))); Process.Start(args[3]); } else { File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Стартуем " + args[3] + " " + args[4], getArgumentsFromArgArray(args))); Process.Start(args[3], args[4]); } } ClearRepairInfo(args, RepairInfo); deleteBootRun(); File.AppendAllText(errorLogFileName, String.Format(msgMessage, DateTime.Now, "Исполнено и удалено из аварийного восстановления", getArgumentsFromArgArray(args))); truncateLog(new FileInfo(errorLogFileName)); return(returned); } finally { if (s != null) { releaseSemaphore(s, rCount); s.Close(); } if (syncSemaphoreMutex != null) { if (mCount > 0) { syncSemaphoreMutex.ReleaseMutex(); } syncSemaphoreMutex.Close(); } main.Reset(); main.Close(); mainMutexForLog.ReleaseMutex(); mainMutexForLog.Close(); } }
static void Main(string[] args) { System.Configuration.Install.InstallContext _arg = new System.Configuration.Install.InstallContext(null, args); if (_arg.IsParameterTrue("debug")) { System.Console.WriteLine("Wait for debugger, press any key to continue..."); System.Console.ReadKey(); } // dump version logIt(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileVersionInfo.ToString()); // dump args logIt(string.Format("called by arg: ({0})", args.Length)); foreach (string s in args) { logIt(s); } IniFile ini = new IniFile(Path.Combine(Environment.ExpandEnvironmentVariables(@"%APSTHOME%"), "config.ini")); String sMaxcapacity = ini.GetString("battery", "read_ratio_reboot", "false"); Util.IsMaxCapacity = String.Compare(sMaxcapacity, "true", true) == 0 || String.Compare(sMaxcapacity, "1", true) == 0; //Util.IsMaxCapacity = true; logIt($"config Maxcapacity = {sMaxcapacity}:{Util.IsMaxCapacity}"); System.AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); if (_arg.IsParameterTrue("start-service")) { // start service Boolean bRun = false; try { ewait = System.Threading.EventWaitHandle.OpenExisting(IdeviceInfoSvcHost_Event_Name); ewait.Close(); logIt("Instance already started."); } catch (WaitHandleCannotBeOpenedException) { bRun = true; } catch (Exception) { } if (bRun) { try { ewait = new EventWaitHandle(false, EventResetMode.ManualReset, IdeviceInfoSvcHost_Event_Name); //Util.InitEnviroment(); ThreadPool.QueueUserWorkItem(new WaitCallback(Util.runMonitorExe), null); using (ServiceHost host = new ServiceHost(typeof(Device))) { host.Open(); Console.WriteLine(@"go to http://localhost:1930/device to test"); Console.WriteLine(@"Press any key to terminate..."); while (!ewait.WaitOne(1000)) { if (System.Console.KeyAvailable) { ewait.Set(); } } host.Close(); } Util.bExit = true; Util.runMonitorExe("-kill-service"); ewait.Close(); } catch (Exception) { logIt("iTunes MobileDevice.Dll not found.************"); } Util.bExit = true; Util.runMonitorExe("-kill-service"); ewait.Close(); } } else if (_arg.IsParameterTrue("kill-service")) { // stop service try { ewait = System.Threading.EventWaitHandle.OpenExisting(IdeviceInfoSvcHost_Event_Name); if (ewait != null) { ewait.Set(); } } catch (Exception) { } } else { System.Console.WriteLine("IdeviceInfoSvcHost.exe"); System.Console.WriteLine("-start-service: to start the service"); System.Console.WriteLine("-kill-service: to stop the service"); } }
public void SetFree() { waiter.Set(); }