public static void SubmitProcessAsync(string content) { if (!PreferenceManager.WithSendProcessReports) { return; } if (content == null) { return; } AsyncHelper.FireAndForget(() => { try { string request = GetRequest("ProcessReporting", content); WebRequestHelper.PostRequest(SERVICE_URL, request); } catch { // Nothing } }); }
protected static void OnDeletedFileRenamed(string strOldFilePath, string strNewFilePath) { if (DeletedFileRenamed != null) { AsyncHelper.FireAndForget(DeletedFileRenamed, new object[] { strOldFilePath, strNewFilePath }); } }
public static void SubmitExceptionAsync(Exception exception) { if (!PreferenceManager.WithSendErrorReports) { return; } if (exception == null) { return; } AsyncHelper.FireAndForget(() => { try { string request = GetRequest("ErrorReporting", exception.ToString()); WebRequestHelper.PostRequest(SERVICE_URL, request); } catch { // Nothing } }); }
private async Task DisplayScreenModelAsync(IDisplayLane lane) { while (true) { foreach (var person in lane.People.ToList()) { if (lane.GetType() == typeof(KioskDisplayLane)) { if ((DateTime.Now >= person.NextDisplayTime)) { Debug.WriteLine($"Displaying {person} for {person.CurrentDisplayCount} in lane {lane.LaneIndex}"); await Animate(person, lane); person.CurrentDisplayCount += 1; //TODO: Refactor out RecycleCount if (person.CurrentDisplayCount >= Configuration.KioskDisplayRecycleCount) { lane.People.Remove(person); } } continue; } await Animate(person, lane); var percent = lane.People.IndexOf(person).ToDouble().PercentOf(DefaultTakeCount.ToDouble()); if (percent >= 90) { AsyncHelper.FireAndForget( () => lane.UpdateQueueAsync(_currentCount, DefaultTakeCount, WebServerUrl), e => { Console.WriteLine(@"Error updating name queue for general names"); Debug.WriteLine(e); }); _currentCount += DefaultTakeCount; } using (Canceller.Token.Register(Thread.CurrentThread.Abort)) { //NOTE: This is amount of time before next name displays and begins animation await Task.Delay(TimeSpan.FromSeconds(lane.RotationDelay), Canceller.Token); } } //TODO: If queue list is not populated continue with existing list. Notifiy issue if (!lane.Queue.Any()) { continue; } //NOTE: If current queue count less than DefaultTakeCount assume at end of database list and start over at beginning. Need to same position for next runtime. if (lane.Queue.Count < DefaultTakeCount) { _currentCount = 0; } lane.People.Clear(); lane.People.AddRange(lane.Queue); lane.Queue.Clear(); } }
protected virtual void OnError(OnErrorEventArgs e) { OnErrorEventHandler[] handlers = null; Monitor.Enter(_errorHandlers); try { if (_errorHandlers.Count > 0) { handlers = new OnErrorEventHandler[_errorHandlers.Count]; _errorHandlers.CopyTo(handlers, 0); } } finally { Monitor.Exit(_errorHandlers); } if (handlers != null) { foreach (OnErrorEventHandler handler in handlers) { if (handler != null) { AsyncHelper.FireAndForget(handler, this, e); } } } }
private async Task BeginRotaion() { var width = _canvas.ActualWidth; //Kiosk Lanes for (var i = 1; i < _numberOfLanes + 1; i++) { //TODO: Refactor out width Lanes.Add(new KioskDisplayLane(laneIndex: i, canvasWidth: width, totalLanes: _numberOfLanes)); } //General Lane var model = new GeneralDisplayLane(Configuration.GeneralRotationDelay, width); await model.LoadNamesAsync(_currentCount, DefaultTakeCount, WebServerUrl); //TODO: Remove dependecy on webserverurl string _currentCount += DefaultTakeCount; Lanes.Add(model); //Priority Lane var priorityLane = new PriorityDisplayLane(Configuration.PriorityRotationDelay, width); await priorityLane.LoadNamesAsync(0, DefaultTakeCount, WebServerUrl); //TODO: Remove dependecy on webserverurl string Lanes.Add(priorityLane); foreach (var lane in Lanes) { AsyncHelper.FireAndForget(() => DisplayScreenModelAsync(lane), e => { Console.WriteLine($@"Error starting loop for lane {lane.LaneIndex}"); Debug.WriteLine(e); }); } }
protected virtual void OnDisposed(OnDisposedEventArgs e) { OnDisposedEventHandler[] handlers = null; Monitor.Enter(this); try { if (_handlers != null) { handlers = new OnDisposedEventHandler[_handlers.Count]; _handlers.CopyTo(handlers, 0); _handlers.Clear(); } } finally { Monitor.Exit(this); } if (handlers != null) { foreach (OnDisposedEventHandler handler in handlers) { if (handler != null) { AsyncHelper.FireAndForget(handler, this, e); } } } }
protected static void OnFileDeleted(string strFilePath) { if (FileDeleted != null) { AsyncHelper.FireAndForget(FileDeleted, new object[] { strFilePath }); } }
public void TestFAF() { int delay = 100; Stopwatch s = new Stopwatch(); bool exceptionThrown = false; var waitHandle = new AutoResetEvent(false); s.Start(); AsyncHelper.FireAndForget( () => FAFExample(delay), e => { exceptionThrown = true; waitHandle.Set(); }); s.Stop(); // These lines will be reached immediately int EPSILON = 30; // millisecond margin of error Assert.Less(s.ElapsedMilliseconds, EPSILON); waitHandle.WaitOne(delay * 2 + EPSILON); Assert.AreEqual(true, exceptionThrown); }
public void Dispose() { if (_healthStreamSub != null) { AsyncHelper.FireAndForget(async() => await _healthStreamSub.UnsubscribeAsync(), exception => { _logger.Error(501, "HeroStreamService :: Error while unsubscribing hero stream", exception); }); } }
public MainViewModel() { #region [ Commands Registering ] this.QuitCommand = new DelegateCommand(this.Quit, this.CanExecuteQuit); base.RegisterCommand(this.QuitCommand); this.CancelCommand = new DelegateCommand(this.Cancel, this.CanExecuteCancel); base.RegisterCommand(this.CancelCommand); this.ClearLogsCommand = new DelegateCommand(this.ClearLogs, this.CanExecuteClearLogs); base.RegisterCommand(this.ClearLogsCommand); this.CopyLogsCommand = new DelegateCommand(this.CopyLogs, this.CanExecuteCopyLogs); base.RegisterCommand(this.CopyLogsCommand); this.ProcessCommand = new DelegateCommand(this.Process, this.CanExecuteProcess); base.RegisterCommand(this.ProcessCommand); this.GenerateTranslationsCommand = new DelegateCommand(this.GenerateTranslations, this.CanExecuteGenerateTranslations); base.RegisterCommand(this.GenerateTranslationsCommand); this.GenerateCodeRefsCommand = new DelegateCommand(this.GenerateCodeRefs, this.CanExecuteGenerateCodeRefs); base.RegisterCommand(this.GenerateCodeRefsCommand); this.ShowExcludedTablesCommand = new DelegateCommand(this.ShowExcludedTables, this.CanExecuteShowExcludedTables); base.RegisterCommand(this.ShowExcludedTablesCommand); #endregion #region [ IHM Initialization ] this.SwitchTableSelectionMode = true; this.WithSqlProcedureIntegration = true; this.WithBusinessIntegration = true; this.SetCompilationModes(); #endregion #region [ Process Initialization ] _processor = new Processor(); _processor.OnProcessMessage += OnProcessorProcessMessage; _processor.OnProcessProgression += OnProcessorProcessProgression; #endregion AsyncHelper.FireAndForget(() => this.Initialize()); this.CheckUpdateAsync(); }
public void Log(string message) { try { WebRequest request = WebRequest.Create(_loggingPartialUrl + _userRef + "/" + message); WebResponseGetter getter = new WebResponseGetter(request.GetResponse); AsyncHelper.FireAndForget(getter, null); } catch { // suppress all errors } }
private async void MainWindow_Loaded(object sender, RoutedEventArgs e) { await InitConfiguration(); await InitDisplay(); await InitAudioSettings(); await InitConnectionManager(); if (_debugMode) { AddLines(); } AsyncHelper.FireAndForget(BeginRotaion); }
public void WriteMessage(MessageBase objMessage) { if (objMessage == null) { throw new ArgumentNullException("objMessage", "A valid non-null MessageBase is required."); } bool blnIsMessageTypeAllowed = IsMessageTypeAllowed(objMessage); if (blnIsMessageTypeAllowed == true) { WriteMessageToLogsDelegate objWriteMessageToLogs = new WriteMessageToLogsDelegate(WriteMessageToLogs); AsyncHelper.FireAndForget(objWriteMessageToLogs, objMessage); } }
public static void FireAsync(Delegate del, params object[] args) { if (del == null) { return; } Delegate[] delegates = del.GetInvocationList(); AsyncFire asyncFire; foreach (Delegate sink in delegates) { asyncFire = new AsyncFire(InvokeDelegate); AsyncHelper.FireAndForget(asyncFire, sink, args); } }
//The interceptor will log the beginning and end of the method call. public void Intercept(IInvocation invocation) { if (!invocation.Method.Name.StartsWith("Get", System.StringComparison.Ordinal)) { //This happens before the method call AsyncHelper.FireAndForget(new AsyncHelper.LogDelegate(LogParameter), "Calling method {0} with parameters {1}", invocation); } //Actual method call begins invocation.Proceed(); if (!invocation.Method.Name.StartsWith("Get", System.StringComparison.Ordinal)) { AsyncHelper.FireAndForget(new AsyncHelper.LogDelegate(AsyncHelper.PerformLog), "Done: result was {0}.", invocation.ReturnValue); } }
public void Send(MailMessage message) { if (message == null) { throw new ArgumentNullException("message"); } if (!CollectionHelper.IsNullOrEmpty(Recipients)) { EnumerableHelper.ForEach(Recipients, to => { if (!string.IsNullOrEmpty(to)) { message.To.Add(to); } }); } if (CollectionHelper.IsNullOrEmpty(message.To)) { throw new ArgumentException("No recipient specified"); } if (!CollectionHelper.IsNullOrEmpty(CarbonCopies)) { EnumerableHelper.ForEach(CarbonCopies, cc => { if (!string.IsNullOrEmpty(cc)) { message.CC.Add(cc); } }); } if (!CollectionHelper.IsNullOrEmpty(BlindCarbonCopies)) { EnumerableHelper.ForEach(BlindCarbonCopies, bcc => { if (!string.IsNullOrEmpty(bcc)) { message.Bcc.Add(bcc); } }); } AsyncHelper.FireAndForget(SendAsync, message); }
protected void OnItemRemovedEvent(object objSender, ItemRemovedEventArgs <TObjectType> objArguments) { if (Initializing == false) { ItemRemovedEventHandler <TObjectType> objHandler = ItemRemovedEventAsync; if (objHandler != null) { AsyncHelper.FireAndForget(objHandler, objSender, objArguments); } objHandler = ItemRemovedEvent; if (objHandler != null) { objHandler(objSender, objArguments); } } }
public virtual void Fill(IResultSet <TKey, TValue> results) { ExceptionHelper.ThrowIfArgumentNull(results, "results"); Monitor.Enter(_syncLock); try { _updateRequests.Enqueue(results); if (!_updateInProgress) { _updateInProgress = true; AsyncHelper.FireAndForget(new ObjectPoolDelegate(ProcessUpdates), null); } } finally { Monitor.Exit(_syncLock); } }
private void CheckUpdateAsync() { if (!PreferenceManager.WithCheckAutomaticUpdates) { return; } AsyncHelper.FireAndForget(() => { string date, version; bool updateReleased = ServiceManager.CheckUpdate(out date, out version); if (updateReleased) { this.CanBeUpdated = true; this.UpdateVersion = string.Format("v{0} released!", version); } }); }
public static void FireAndForget_SingleArgument() { // Arrange var waitHandle = new AutoResetEvent(false); var threadId = Thread.CurrentThread.ManagedThreadId; var actionThreadId = -1; // Act AsyncHelper.FireAndForget(arg => { Assert.Equal(100, arg); actionThreadId = Thread.CurrentThread.ManagedThreadId; waitHandle.Set(); }, 100); var result = waitHandle.WaitOne(500); // Assert Assert.True(result); Assert.NotEqual(-1, actionThreadId); Assert.NotEqual(threadId, actionThreadId); }
public object Invoke(Delegate @delegate, params object[] args) { AsyncHelper.FireAndForget(@delegate, args); return(null); }
public static void OnError(string message) { AsyncHelper.FireAndForget(() => OnErrorAsync(message)); }
public static void DownloadGravatar_Begin(string gravatarID, int size, string targetFolderPath) { AsyncHelper.FireAndForget(delegate { DownloadGravatar(gravatarID, size, targetFolderPath); }); }