Exemple #1
0
 public void OnActivityFailed(ActivityFailedEventArgs activityFailedEventArgs)
 {
     ActivityFailed?.Invoke(this, activityFailedEventArgs);
 }
        private void MActivityExecutor_ActivityFailed(object sender, ActivityFailedEventArgs eventArgs)
        {
            if (!Visible)
            {
                return;
            }

            if (InvokeRequired)
            {
                Invoke(new EventHandler <ActivityFailedEventArgs>(MActivityExecutor_ActivityFailed), sender, eventArgs);
                return;
            }

            string text = Resources.MsgActivityFailed;

            if (eventArgs.Message != null)
            {
                text += " " + eventArgs.Message;
            }

            Exception exception         = eventArgs.Exception;
            Exception handlingException = null;
            string    path = Path.Combine(Environment.CurrentDirectory, "exception.log");

            if (exception != null)
            {
                if (!mTask.ContinueOnError)
                {
                    try
                    {
                        using (StreamWriter writer = new StreamWriter(path, true))
                        {
                            writer.WriteLine(Resources.TxtActivityException, exception.GetType().FullName, exception.Message);
                            writer.WriteLine(Resources.TxtStackTrace, exception.StackTrace);

                            if (exception.InnerException != null)
                            {
                                writer.WriteLine(Resources.TxtInnerException, exception.InnerException);
                            }

                            if (exception.Data.Count > 0)
                            {
                                writer.WriteLine(Resources.TxtExceptionData);

                                foreach (DictionaryEntry entry in exception.Data)
                                {
                                    writer.WriteLine(string.Concat(new object[] { "  * ", entry.Key, " = ", entry.Value }));
                                }
                            }

                            writer.WriteLine();
                        }
                    }
                    catch (Exception ex)
                    {
                        handlingException = ex;
                    }
                }

                text += Environment.NewLine + string.Format(Resources.MsgActivityExceptionOccured, exception.GetType().Name, exception.Message);
            }

            string logMessage = mTask.ContinueOnError ? text : string.Format(Resources.MsgActivityCompletedFailure, text);

            AddLogText(mLogTextBox.Text.EndsWith(Environment.NewLine) ? logMessage : Environment.NewLine + logMessage);

            if (!mTask.ContinueOnError)
            {
                if (exception != null)
                {
                    text += Environment.NewLine;

                    if (handlingException == null)
                    {
                        text += string.Format(Resources.MsgDetailErrorLogWritten, path);
                    }
                    else
                    {
                        text += string.Format(Resources.MsgDetailErrorLogException, handlingException.GetType().Name, handlingException.Message);
                    }
                }

                MessageBox.Show(this, text, Resources.CptActivityFailed, MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }