/// <summary>
 /// 移除处理类
 /// </summary>
 /// <param name="handler"></param>
 private static void DelHandler(ExceptionHandler handler)
 {
     if (handlers.ContainsKey(handler.ToString()))
     {
         handlers.Remove(handler.ToString());
     }
 }

		private static ValueOrError<CrontabSchedule> TryParse(string expression, ExceptionHandler onError)
		{
			if (expression == null)
				throw new ArgumentNullException("expression");

			var tokens = expression.Split(_separators, StringSplitOptions.RemoveEmptyEntries);

			if (tokens.Length != 5)
			{
				return ErrorHandling.OnError(() => new CrontabException(string.Format(
						   "'{0}' is not a valid crontab expression. It must contain at least 5 components of a schedule "
						   + "(in the sequence of minutes, hours, days, months, days of week).",
						   expression)), onError);
			}

			var fields = new CrontabField[5];

			for (var i = 0; i < fields.Length; i++)
			{
				var field = CrontabField.TryParse((CrontabFieldKind)i, tokens[i], onError);
				if (field.IsError)
					return field.ErrorProvider;

				fields[i] = field.Value;
			}

			return new CrontabSchedule(fields[0], fields[1], fields[2], fields[3], fields[4]);
		}

 /// <summary>
 /// 添加处理类
 /// </summary>
 /// <param name="handler"></param>
 private static void AddHandler(ExceptionHandler handler)
 {
     if (!handlers.ContainsKey(handler.ToString()))
     {
         handlers.Add(handler.ToString(), handler);
     }
 }

 public ExceptionHandlerTreeNode( ExceptionHandler handler ) :
     base( TreeViewImage.Method, handler )
 {
     this.handler = handler;
     this.Text = handler.Options.ToString();
     this.EnableLatePopulate();
 }

 static void Main()
 {
     ExceptionHandler EH = new ExceptionHandler();
         AppDomain.CurrentDomain.UnhandledException += EH.ThreadExceptionHandle;
         Application.EnableVisualStyles();
         Application.SetCompatibleTextRenderingDefault(false);
         _LoginForm = new LoginForm();
         Application.Run(_LoginForm); // spawn
 }

		internal static ExceptionProvider OnError(ExceptionProvider provider, ExceptionHandler handler)
		{
			Debug.Assert(provider != null);

			if (handler != null)
				handler(provider());

			return provider;
		}

        public void When_rethrows_if_no_handler()
        {
            var exceptions = new Dictionary<Type, Action>();
            var exception = new ExceptionHandler(exceptions);
            int invoke = 0;
            Action action = () => invoke++;

            Assert.Throws<NotImplementedException>(() => exception.On<AbandonedMutexException>(action).When(() => { throw new NotImplementedException(); }));
        }

 static void Main()
 {
     ExceptionHandler EH = new ExceptionHandler();
     AppDomain.CurrentDomain.UnhandledException += EH.ThreadExceptionHandle;
     Application.Init ();
     LoginForm = new Forms.LoginForm();
     LoginForm.Show ();
     Application.Run ();
 }

        public void Handle_ExceptionWhichNoSpecificHandlerCanHandle_RepositoryViolationExceptionThrown()
        {
            ExceptionHandler handler = new ExceptionHandler();
            Exception e = new Exception();

            Action act = () => handler.Handle(e);

            act.ShouldThrow<RepositoryViolationException>(actual => ReferenceEquals(actual.InnerException, e));
        }

        public void When_invokes_target()
        {
            var exceptions = new Dictionary<Type, Action>();
            var exception = new ExceptionHandler(exceptions);
            int invoke = 0;
            Action action = () => Console.WriteLine("caught");

            exception.On<Exception>(action).When(() => invoke++);
            invoke.ShouldBe(1);
        }

		public static void InstallExceptionHandler(this Application application, ExceptionHandler exceptionHandler)
		{
			const string WarningFormat =
				"If the TaskScheduler used does not implements the {0} interface," +
				" it could not intercept exceptions thrown in secondary threads.";

			Debug.WriteLine(string.Format(WarningFormat, typeof(ILoggerTaskScheduler).Name));

			singletonExceptionHandler.Set(exceptionHandler);
			exceptionHandler.Install();
		}

        public void When_invokes_exception_handler_on_exception()
        {
            var exceptions = new Dictionary<Type, Action>();
            var exception = new ExceptionHandler(exceptions);
            int invoke = 0;
            Action action = () => invoke++;

            exception.On<NotImplementedException>(action).When(() => { throw new NotImplementedException(); });

            invoke.ShouldBe(1);
        }

 private bool Throw(ExceptionHandler handler)
 {
     try
     {
         throw new Exception("ExceptionHandlerTests");
     }
     catch (Exception e)
     {
         return handler.HandleException(e);
     }
 }

        public void On_Exception_adds_exception_and_target_invocation()
        {
            var exceptions = new Dictionary<Type, Action>();
            var exception = new ExceptionHandler(exceptions);
            Action action = () => Console.WriteLine("caught");

            exception.On<Exception>(action);

            exceptions.ContainsKey(typeof(Exception));
            exceptions.ContainsValue(action);
            exceptions.Count.ShouldBe(1);
        }

        static void handleException(Exception e)
        {
            var handler = new ExceptionHandler
            {
                Exception = e,
                LoggedOnUser = GlobalProperties.loggedOnUser,
                Mode = Mode.Online
            };

            handler.handleException();
            MessageBox.Show("An error was detected. An email has been sent to Development. LAD will now close.", "Error");
            Application.Exit();
        }

        public void Run(Proc procediment)
        {
            ExceptionHandler eh = new ExceptionHandler();

            AppDomain.CurrentDomain.UnhandledException += eh.OnThreadException;

            procediment.Invoke();

            AppDomain.CurrentDomain.UnhandledException -= eh.OnThreadException;

            if (eh.Count > 0)
                Assert.Fail("Engine Validator concurrent issues. Concurrent issues count {0}", eh.Count);
        }

        private static void handleException(Exception ex)
        {
            var handler = new ExceptionHandler
            {
                Exception = ex,
                LoggedOnUser = Global.loggedOnUser,
                Mode = Global.systemMode

            };

            handler.handleException();
            MessageBox.Show("An error was detected. An email has been sent to Development. LAD will now close.", "Error");
            Application.Exit();
        }

    void ContinueProcessing()
    {
        body = Method.Body;

        body.SimplifyMacros();

        var ilProcessor = body.GetILProcessor();

        var returnFixer = new ReturnFixer
        {
            Method = Method
        };
        returnFixer.MakeLastStatementReturn();

        exceptionVariable = new VariableDefinition(ModuleWeaver.ExceptionType);
        body.Variables.Add(exceptionVariable);
        messageVariable = new VariableDefinition(ModuleWeaver.ModuleDefinition.TypeSystem.String);
        body.Variables.Add(messageVariable);
        paramsArrayVariable = new VariableDefinition(ModuleWeaver.ObjectArray);
        body.Variables.Add(paramsArrayVariable);


        var tryCatchLeaveInstructions = Instruction.Create(OpCodes.Leave, returnFixer.NopBeforeReturn);

        var methodBodyFirstInstruction = GetMethodBodyFirstInstruction();

        var catchInstructions = GetCatchInstructions().ToList();

        ilProcessor.InsertBefore(returnFixer.NopBeforeReturn, tryCatchLeaveInstructions);

        ilProcessor.InsertBefore(returnFixer.NopBeforeReturn, catchInstructions);

        var handler = new ExceptionHandler(ExceptionHandlerType.Catch)
        {
            CatchType = ModuleWeaver.ExceptionType,
            TryStart = methodBodyFirstInstruction,
            TryEnd = tryCatchLeaveInstructions.Next,
            HandlerStart = catchInstructions.First(),
            HandlerEnd = catchInstructions.Last().Next
        };

        body.ExceptionHandlers.Add(handler);

        body.InitLocals = true;
        body.OptimizeMacros();
    }

		internal static void Implementation( Action action, ExceptionHandler canHandle, ICircuitBreakerState breaker )
		{
			if( breaker.IsBroken )
				throw breaker.LastException;

			try
			{
				action();
				breaker.Reset();
			}
			catch( Exception ex )
			{
				if( !canHandle( ex ) )
					throw;
				breaker.TryBreak( ex );
				throw;
			}
		}

		internal static async Task ImplementationAsync( Func< Task > action, ExceptionHandler canHandle, ICircuitBreakerState breaker )
		{
			if( breaker.IsBroken )
				throw breaker.LastException;

			try
			{
				await action().ConfigureAwait( false );
				breaker.Reset();
			}
			catch( Exception ex )
			{
				if( !canHandle( ex ) )
					throw;
				breaker.TryBreak( ex );
				throw;
			}
		}