protected virtual void OnUnhandledException(Exception ex, ExecutedNotifyEventArgs agrs) { ExceptionEventArgs t = new ExceptionEventArgs(ex, agrs.Folder, agrs.TaskID, agrs.Description) { ExecuteDuration = agrs.ExecuteDuration, ExecutePath = agrs.ExecutePath, ExecuteResult = agrs.ExecuteResult, ExecuteStartTime = agrs.ExecuteStartTime, LastExecuteTime = agrs.LastExecuteTime, NextExecuteTime = agrs.NextExecuteTime, ServerName = agrs.ServerName }; Logger.Error(t); ExceptionEventHandler handler = m_UnhandledException; if (handler != null) { try { handler(this, t); } catch (Exception ex1) { Logger.Error(m_FolderPath, TaskID, ex1, "执行SpTaskExecutor.OnUnhandledException时出错"); } } }
/// <summary> /// Initializes the game engine. /// </summary> public void Init() { // Test if working directory is set correctly => VS.NET 2003 bug System.IO.DirectoryInfo info = new System.IO.DirectoryInfo(Environment.CurrentDirectory); if (info.Name.ToLower().IndexOf("debug") != -1 || info.Name.ToLower().IndexOf("release") != -1) { throw new Exception("Please set the working directory (project settings) to the project root (within VS.NET) " + "or copy the binaries to the project root (to start from the command line)!"); } ExceptionEventHandler handler = exceptionHandler; if (handler != null) { try { // fire onInit event if (OnInit != null) { OnInit(); } } catch (Exception ex) { handler(ex); } catch { handler(new Exception("Guru Mediation Error!")); } } else // fire onInit event if (OnInit != null) { OnInit(); } }
public void Execute(object sender, DateTime dtBegin, DateTime dtEnd, ExceptionEventHandler handler) { if (!Enabled) { return; } var listEvent = new List <Object>(); Schedule.AddEventsInInterval(dtBegin, dtEnd, listEvent); if (Filter != null) { Filter.FilterResultsInInterval(dtBegin, dtEnd, listEvent); } foreach (DateTime EventTime in listEvent) { if (IsSyncronized) { _ExecuteHandler(sender, EventTime, handler); } else { _ExecuteHandler.BeginInvoke(sender, EventTime, handler, null, null); } } }
/// <summary> /// Raises the Exception event /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected internal void OnException(object sender, ExceptionEventArgs e) { // trace the exception if the server is in verbose mode Trace.WriteLineIf(_verbose, string.Format("Encountered the following exception.\n\t{0}", e.Exception.ToString()), MY_TRACE_CATEGORY); try { if (this.Exception == null) { return; } Delegate[] delegates = this.Exception.GetInvocationList(); if (delegates != null) { foreach (Delegate d in delegates) { try { ExceptionEventHandler handler = (ExceptionEventHandler)d; handler(sender, e); } catch (Exception ex) { Trace.WriteLine(ex); } } } } catch (Exception ex) { Trace.WriteLine(ex); } }
private async void submitCam_Click(object sender, EventArgs e) { if (!Uri.IsWellFormedUriString(hostUrlField.Text, UriKind.Absolute)) { var eventArgs = new ExceptionEventArgs { ExceptionMessage = Resources.Error_BadUri }; ExceptionEventHandler?.Invoke(this, eventArgs); return; } ; var camObj = new CameraInfo() { HostUrl = hostUrlField.Text, Latitude = (double)latField.Value, Longitude = (double)longField.Value, IsTrustedSource = isTrustedBox.Checked }; try { await cameraClient.InsertCamera(camObj); } catch (Exception ex) { var eventArgs = new ExceptionEventArgs { ExceptionMessage = ex.Message }; ExceptionEventHandler?.Invoke(this, eventArgs); } await UpdateCameraDataSource(); }
public void SignIn(string Email, string Password, string Imap = "", int iport = 0) { UserManagement userManagement = new UserManagement(Email: Email, Password: Password); int userId = userManagement.GetUser().U_Id; try { Random r = new Random(); MailKitClient = new SmtpClient(new ProtocolLogger("smtp" + r.Next(1, 100).ToString() + ".log")); ProgressEventHandler pg = Progress; pg?.Invoke("Validating server"); pg?.Invoke("Authenticating server"); MailKitClient.Connect(Imap, iport, SecureSocketOptions.StartTlsWhenAvailable); pg?.Invoke("Signing in"); MailKitClient.Authenticate(Email, Password); } catch (Exception ex) { errorstring = "Failed to authenticate user " + Environment.NewLine + "Details : " + ex.ToString(); ExceptionEventHandler error = ErrorOccured; error?.Invoke(ex.ToString()); } if (errorstring == "") { AuthSuccessEventHandler Success = AuthSuccess; Success?.Invoke(userId); } }
public void Execute(object sender, DateTime Begin, DateTime End, ExceptionEventHandler Error) { if (!this.Enabled) { return; } List <DateTime> list = new List <DateTime>(); this.Schedule.AddEventsInInterval(Begin, End, list); if (this.Filter != null) { this.Filter.FilterResultsInInterval(Begin, End, list); } foreach (DateTime current in list) { if (this.SyncronizedEvent) { this._ExecuteHandler(sender, current, Error); } else { this._ExecuteHandler.BeginInvoke(sender, current, Error, null, null); } } }
public void Execute(object sender, DateTime Begin, DateTime End, ExceptionEventHandler Error) { if (!Enabled) { return; } ArrayList EventList = new ArrayList(); Schedule.AddEventsInInterval(Begin, End, EventList); if (Filter != null) { Filter.FilterResultsInInterval(Begin, End, EventList); } foreach (DateTime EventTime in EventList) { if (SyncronizedEvent) { _ExecuteHandler(sender, EventTime, Error); } else { _ExecuteHandler.BeginInvoke(sender, EventTime, Error, null, null); } } }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Initialisation //--------------------------------------------------------------- private Engine() { //System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US"); Tools.TypeRegistry.Init(); fileSystem = new FileSystem(""); #if !DEBUG ExceptionHandler = new ExceptionEventHandler(ExceptionForm.ExceptionHandler); #endif }
/// <summary> /// Called when [learning module exception]. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="MLifterSettingsManager.ExceptionEventArgs"/> instance containing the event data.</param> /// <remarks>Documented by Dev08, 2009-07-18</remarks> private void OnLearningModuleException(object sender, ExceptionEventArgs e) { ExceptionEventHandler handler = LearningModuleException; if (handler != null) { handler(sender, e); } }
private void OnUnhandledException(Exception ex, string folder, string taskID, string desc) { ExceptionEventHandler handler = m_UnhandledException; if (handler != null) { handler(this, new ExceptionEventArgs(ex, folder, taskID, desc)); } }
private void OnUnhandledException(object sender, ExceptionEventArgs args) { ExceptionEventHandler handler = m_UnhandledException; if (handler != null) { handler(sender, args); } }
/// <summary> /// /// </summary> /// <param name="ex"></param> private void OnException(Exception ex) { ExceptionEventArgs e = new ExceptionEventArgs(ex); if (this.ExceptionEvent != null) { ExceptionEventHandler t = this.ExceptionEvent; t(this, e); } }
public int Exception(ref EXCEPTION_RECORD64 Exception, uint FirstChance) { ExceptionEventHandler evt = (FirstChance == 1) ? FirstChanceExceptionEvent : SecondChanceExceptionEvent; if (evt != null) { evt(this, Exception); } return((int)DEBUG_STATUS.BREAK); }
private void ExecuteInternal(object sender, DateTime EventTime, ExceptionEventHandler Error) { try { TimerParameterSetter Setter = new TimerParameterSetter(EventTime, sender); Method.Execute(Setter); } catch (Exception ex) { if (Error != null) try { Error(this, new ExceptionEventArgs(EventTime, ex)); } catch {} } }
/// <summary> /// 注册全局异常处理。 /// onUnhandledException 异常处理事件,如果未null则使用DefaultExcetionHandle /// </summary> public static void RegisterGlobalException(ExceptionEventHandler onUnhandledException = null, EnumErrorHandle handle = EnumErrorHandle.Default) { _onExceptionEventHandler = onUnhandledException ?? DefaultExcetionHandle; _ErrorHandle = handle; //AppDomain中的异常 AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; //主UI线程 Application.Current.DispatcherUnhandledException += Current_DispatcherUnhandledException; //task scheduler TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException; //SEH RegisterSEHException(); }
private void ExecuteInternal(object sender, DateTime EventTime, ExceptionEventHandler Error) { try { TimerParameterSetter Setter = new TimerParameterSetter(EventTime, sender); Method.Execute(Setter); } catch (Exception ex) { if (Error != null) { try { Error(this, new ExceptionEventArgs(EventTime, ex)); } catch {} } } }
public void RegisterNonFatalErrorBookmark(string bookmarkName) { if (this.ActionInvoker == null) { throw new InvalidOperationException(); } ExceptionEventHandler handler = delegate(object sender, ExceptionEventArgs e) { this.ActionInvoker.ScheduleAction(bookmarkName, sender, e); }; this.NonFatalErrorHandlers.Add(new Tuple <string, ExceptionEventHandler>(bookmarkName, handler)); this.Server.NonFatalError += handler; }
public void OnUnhandledException(string exMessage, string desc) { ExceptionEventHandler handler = m_UnhandledException; if (handler != null) { try { handler(this, new ExceptionEventArgs(exMessage, m_FolderPath, TaskID, desc)); } catch (Exception ex1) { Logger.Error(m_FolderPath, TaskID, ex1, "执行AppDomainTaskExecutor.OnUnhandledException时出错"); } } }
public void OnUnhandledException(ExceptionEventArgs ea) { ExceptionEventHandler handler = m_UnhandledException; if (handler != null) { try { handler(this, ea); } catch (Exception ex1) { Logger.Error(m_FolderPath, TaskID, ex1, "执行AppDomainTaskExecutor.OnUnhandledException时出错"); } } }
static UnhandledExceptionHander() { DefaultExcetionHandle = new ExceptionEventHandler((ex, handle, exSource) => { switch (handle) { case EnumErrorHandle.Exit: Application.Current.Shutdown();; break; case EnumErrorHandle.Restart: Restart(); break; } }); }
void ExecuteInternal(object sender, DateTime dtEvent, ExceptionEventHandler handler) { try { var setter = new TimerParameterSetter(dtEvent, sender); Method.Execute(setter); } catch (Exception ex) { if (null != handler) try { handler(this, new ExceptionEventArgs(dtEvent, ex)); } catch { } } }
void ExecuteInternal(object sender, DateTime dtEvent, ExceptionEventHandler handler) { try { var setter = new TimerParameterSetter(dtEvent, sender); Method.Execute(setter); } catch (Exception ex) { if (null != handler) { try { handler(this, new ExceptionEventArgs(dtEvent, ex)); } catch { } } } }
public void Execute(object sender, DateTime dtBegin, DateTime dtEnd, ExceptionEventHandler handler) { if (!Enabled) return; var listEvent = new List<Object>(); Schedule.AddEventsInInterval(dtBegin, dtEnd, listEvent); if (Filter != null) Filter.FilterResultsInInterval(dtBegin, dtEnd, listEvent); foreach (DateTime EventTime in listEvent) { if (IsSyncronized) _ExecuteHandler(sender, EventTime, handler); else _ExecuteHandler.BeginInvoke(sender, EventTime, handler, null, null); } }
private async void submitButton_Click(object sender, EventArgs e) { var plateNumber = lettersBox.Text + digitsBox.Text; if (!plateNumber.ValidatePlateNumber()) { var eventArgs = new ExceptionEventArgs { ExceptionMessage = Resources.Error_BadLicensePlateNumber }; ExceptionEventHandler?.Invoke(this, eventArgs); return; } await mlpClient.InsertPlateRecord(plateNumber, DateTime.Now); await MissingLicensePlateList.CreateIfNotExistsAndGetInstance(mlpClient, this).UpdateDatasource(); await UpdateDlpDataSource(); }
public void Execute(object sender, DateTime Begin, DateTime End, ExceptionEventHandler Error) { if (Enabled == false) return; ArrayList EventList = new ArrayList(); Schedule.AddEventsInInterval(Begin, End, EventList); if (Filter != null) Filter.FilterResultsInInterval(Begin, End, EventList); foreach(DateTime EventTime in EventList) { if (SyncronizedEvent) _ExecuteHandler(sender, EventTime, Error); else _ExecuteHandler.BeginInvoke(sender, EventTime, Error, null, null); } }
protected virtual void OnUnhandledException(Exception ex, string desc) { var e = new ExceptionEventArgs(ex, m_FolderPath, TaskID, desc); Logger.Error(e); ExceptionEventHandler handler = m_UnhandledException; if (handler != null) { try { handler(this, new ExceptionEventArgs(ex, m_FolderPath, TaskID, desc)); } catch (Exception ex1) { Logger.Error(m_FolderPath, TaskID, ex1, "执行SpTaskExecutor.OnUnhandledException时出错"); } } }
/// <summary> /// Can be used to manually update the game => without Engine.Run(). /// </summary> public void Update() { ExceptionEventHandler handler = exceptionHandler; if (handler != null) { try { InternalUpdate(); } catch (Exception ex) { handler(ex); } catch { handler(new Exception("Guru Mediation Error!")); } } else { InternalUpdate(); } }
public static void Start <TException>( this ExceptionEventHandler <TException> Handler, object Sender, ExceptionEventHandlerArgs <TException> e) where TException : Exception { var handler = Handler; if (handler is null) { return; } var invocations = handler.GetInvocationList(); for (var i = 0; i < invocations.Length; i++) { var invocation = invocations[i]; if (invocation.Target is ISynchronizeInvoke { InvokeRequired: true } invocation_target) { invocation_target.Invoke(invocation, new[] { Sender, e }); }
private void FireClose() { ExceptionEventHandler handler = exceptionHandler; if (handler != null) { try { if (OnClose != null) { OnClose(); } } catch (Exception ex) { handler(ex); } catch { handler(new Exception("Guru Mediation Error!")); } } else if (OnClose != null) { OnClose(); } }
/// <summary> /// Runs the specified action in the UI thread when the main <see cref="DoWork"/> action /// throws an exception. /// </summary> /// <param name="fail">Action to run in the UI thread</param> /// <returns>Reference to this <c>TaskBuilder</c></returns> public TaskBuilder Fail(ExceptionEventHandler fail) { _fail = fail; return this; }
public Task<bool> CreateMetadataTask(CancellationToken cancellationToken, TaskStartedEventHandler start, ExceptionEventHandler fail, TaskSucceededEventHandler succeed, string mkvPath = null) { var token = cancellationToken; var optionalPhases = new[] { CreateGetMetadataPhase(token), CreateAutoDetectPhase(token), CreateRenamePhase(token, mkvPath) }; return CreateStageTask( token, start, () => true, optionalPhases, fail, succeed ); }
public void Receive(StringEventHandler callback, ExceptionEventHandler exCallback, string split) { Debug.Assert(split != null); Debug.Assert(callback != null); Debug.Assert(exCallback != null); this.callback = callback; this.exCallback = exCallback; this.split = Regex.Escape(split); this.doSplit = true; Receive(); }
public void InvokeHandler(ExceptionEventArgs eventArgs) { ExceptionEventHandler?.Invoke(this, eventArgs); }
/// <summary> /// Creates an asynchronous Task object that executes the given critical phase and optional phases in a background thread /// and invokes all other callbacks on the UI thread. /// </summary> /// <param name="cancellationToken"></param> /// <param name="beforeStart">Invoked on UI thread</param> /// <param name="criticalPhase">First phase to run. Must succeed (by returning <c>true</c> and not throwing an exception) for the optional phases to run. Invoked on the background thread.</param> /// <param name="optionalPhases">Collection of phases that can fail (by throwing an exception) without preventing subsequent phases from running. Invoked on the background thread.</param> /// <param name="fail">Called if the operation is canceled or the critical phase throws an exception. Invoked on the UI thread.</param> /// <param name="succeed">Called if the operation completes successfully without being canceled. Invoked on the UI thread.</param> /// <returns> /// Task object that returns <c>false</c> if the operation was canceled by the user or /// the critical phase threw an exception; otherwise <c>true</c>. /// </returns> private Task <bool> CreateStageTask(CancellationToken cancellationToken, TaskStartedEventHandler beforeStart, CriticalPhase criticalPhase, IEnumerable <OptionalPhase> optionalPhases, ExceptionEventHandler fail, TaskSucceededEventHandler succeed) { var canContinue = CreateCanContinueFunc(cancellationToken); return(new TaskBuilder() .OnThread(_callbackScheduler) .CancelWith(cancellationToken) .BeforeStart(beforeStart) .Fail(fail) .DoWork(delegate(IThreadInvoker invoker, CancellationToken token) { cancellationToken.Register(() => Logger.Warn("User canceled current operation")); if (criticalPhase()) { foreach (var phase in optionalPhases.TakeWhile(phase => canContinue())) { phase(); } if (canContinue()) { invoker.InvokeOnUIThreadAsync(_ => succeed()); return; } } // TODO: How should we handle exceptions here? // The rest of the code assumes exceptions are being handled by the plugin runner. invoker.InvokeOnUIThreadAsync(_ => fail(new ExceptionEventArgs())); }) .Build() ); }
public Task <bool> CreateMetadataTask(CancellationToken cancellationToken, TaskStartedEventHandler start, ExceptionEventHandler fail, TaskSucceededEventHandler succeed, string mkvPath = null) { var token = cancellationToken; var optionalPhases = new[] { CreateGetMetadataPhase(token), CreateAutoDetectPhase(token), CreateRenamePhase(token, mkvPath) }; return(CreateStageTask( token, start, () => true, optionalPhases, fail, succeed )); }
// =================================== // PUBLIC Methods // =================================== public void Receive(StringEventHandler callback, ExceptionEventHandler exCallback) { Debug.Assert(callback != null); Debug.Assert(exCallback != null); this.callback = callback; this.exCallback = exCallback; this.doSplit = false; Receive(); }
/// <summary> /// Creates an asynchronous Task object that executes the given critical phase and optional phases in a background thread /// and invokes all other callbacks on the UI thread. /// </summary> /// <param name="cancellationToken"></param> /// <param name="beforeStart">Invoked on UI thread</param> /// <param name="criticalPhase">First phase to run. Must succeed (by returning <c>true</c> and not throwing an exception) for the optional phases to run. Invoked on the background thread.</param> /// <param name="optionalPhases">Collection of phases that can fail (by throwing an exception) without preventing subsequent phases from running. Invoked on the background thread.</param> /// <param name="fail">Called if the operation is canceled or the critical phase throws an exception. Invoked on the UI thread.</param> /// <param name="succeed">Called if the operation completes successfully without being canceled. Invoked on the UI thread.</param> /// <returns> /// Task object that returns <c>false</c> if the operation was canceled by the user or /// the critical phase threw an exception; otherwise <c>true</c>. /// </returns> private Task<bool> CreateStageTask(CancellationToken cancellationToken, TaskStartedEventHandler beforeStart, CriticalPhase criticalPhase, IEnumerable<OptionalPhase> optionalPhases, ExceptionEventHandler fail, TaskSucceededEventHandler succeed) { var canContinue = CreateCanContinueFunc(cancellationToken); return new TaskBuilder() .OnThread(_callbackScheduler) .CancelWith(cancellationToken) .BeforeStart(beforeStart) .Fail(fail) .DoWork(delegate(IThreadInvoker invoker, CancellationToken token) { cancellationToken.Register(() => Logger.Warn("User canceled current operation")); if (criticalPhase()) { foreach (var phase in optionalPhases.TakeWhile(phase => canContinue())) { phase(); } if (canContinue()) { invoker.InvokeOnUIThreadAsync(_ => succeed()); return; } } // TODO: How should we handle exceptions here? // The rest of the code assumes exceptions are being handled by the plugin runner. invoker.InvokeOnUIThreadAsync(_ => fail(new ExceptionEventArgs())); }) .Build() ; }
private void CloudManager_Exception(ExceptionEventHandler obj) { }