Exemplo n.º 1
0
            /// <summary>
            /// The push fatal error.
            /// </summary>
            /// <param name="fatalErrorType">
            /// The fatal error type.
            /// </param>
            internal void PushFatalError(FatalErrorType fatalErrorType)
            {
                if (pendingFatalErrors == null)
                {
                    pendingFatalErrors = new List <FatalErrorType>();
                }

                pendingFatalErrors.Add(fatalErrorType);
            }
Exemplo n.º 2
0
            /// <summary>
            ///   The take next pending.
            /// </summary>
            /// <returns>
            ///   The <see cref="bool" />.
            /// </returns>
            internal override bool TakeNextPending()
            {
                if ((pendingFatalErrors != null) && (pendingFatalErrors.Count > 0))
                {
                    fatalErrorType = pendingFatalErrors[0];
                    pendingFatalErrors.RemoveAt(0);
                    return(true);
                }

                return(false);
            }
Exemplo n.º 3
0
        /// <summary>
        /// The fatal error as string.
        /// </summary>
        /// <param name="type">
        /// The type.
        /// </param>
        /// <returns>
        /// The <see cref="string"/>.
        /// </returns>
        public static string FatalErrorAsString(FatalErrorType type)
        {
            switch (type)
            {
            case FatalErrorType.Unknown:
                return("неизвестно");

            case FatalErrorType.DatabaseError:
                return("ошибка при обращении к БД");
            }

            return(type.ToString());
        }
Exemplo n.º 4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="FatalErrorRunningEventData"/> class.
 /// </summary>
 /// <param name="fatalErrorType">
 /// The fatal error type.
 /// </param>
 internal FatalErrorRunningEventData(FatalErrorType fatalErrorType)
     : base(GlobalEvent.FatalErrorHandle)
 {
     this.fatalErrorType = fatalErrorType;
 }
Exemplo n.º 5
0
        // private static void CallFatalError(FatalErrorType fatalErrorType)
        // {
        // CallGlobalEventStaging(GlobalEvent.FatalErrorHandle, SimplePrecedence.Before);
        // try
        // {
        // try
        // {
        // if (BeforeFatalError != null)
        // {
        // bool cancel = false;
        // BeforeFatalError(fatalErrorType, ref cancel);
        // if (cancel)
        // {
        // return;
        // }
        // }
        // }
        // catch (Exception exception)
        // {
        // FomsLogger.WriteError(exception, null);
        // }
        // bool handled = false;
        // try
        // {
        // if (HandleFatalError != null)
        // {
        // HandleFatalError(fatalErrorType, ref handled);
        // }
        // }
        // catch (Exception exception2)
        // {
        // FomsLogger.WriteError(exception2, null);
        // }
        // try
        // {
        // if (AfterFatalError != null)
        // {
        // AfterFatalError(fatalErrorType, handled);
        // }
        // }
        // catch (Exception exception3)
        // {
        // FomsLogger.WriteError(exception3, null);
        // }
        // }
        // finally
        // {
        // CallGlobalEventStaging(GlobalEvent.FatalErrorHandle, SimplePrecedence.After);
        // }
        // }

        // private static void GlobalEventAction(RunningEventData runningEventData)
        // {
        // GlobalEventAction(runningEventData.globalEvent, runningEventData);
        // }

        // private static bool GlobalEventAction(GlobalEvent globalEvent, RunningEventData runningEventData = new RunningEventData())
        // {
        // switch (globalEvent)
        // {
        // case GlobalEvent.LiveStateChanged:
        // if (LiveStateChanged == null)
        // {
        // break;
        // }
        // if (runningEventData != null)
        // {
        // CallGlobalEvent(globalEvent, LiveStateChanged);
        // }
        // return true;

        // case GlobalEvent.SystemTimeChanged:
        // if (SystemTimeChanged == null)
        // {
        // break;
        // }
        // if (runningEventData != null)
        // {
        // CallGlobalEvent(globalEvent, SystemTimeChanged);
        // }
        // return true;

        // case GlobalEvent.ConfigReadEvent:
        // if (HasUnloadFlag || (ConfigReadEvent == null))
        // {
        // break;
        // }
        // if (runningEventData != null)
        // {
        // CallGlobalEvent(globalEvent, ConfigReadEvent);
        // }
        // return true;

        // case GlobalEvent.FatalErrorHandle:
        // {
        // if (((BeforeFatalError == null) && (AfterFatalError == null)) && (HandleFatalError == null))
        // {
        // break;
        // }
        // FatalErrorRunningEventData data = runningEventData as FatalErrorRunningEventData;
        // if (data != null)
        // {
        // CallFatalError(data.FatalErrorType);
        // }
        // return true;
        // }
        // }
        // return false;
        // }
        #region Public Methods and Operators

        /// <summary>
        /// The raise fatal error.
        /// </summary>
        /// <param name="fatalErrorType">
        /// The fatal error type.
        /// </param>
        /// <param name="forceSeparateThread">
        /// The force separate thread.
        /// </param>
        public static void RaiseFatalError(FatalErrorType fatalErrorType, bool forceSeparateThread = true)
        {
            // RaiseGlobalEventProc(GlobalEvent.FatalErrorHandle, forceSeparateThread, evt => new FatalErrorRunningEventData(fatalErrorType), delegate (RunningEventData runningEventData) {
            // ((FatalErrorRunningEventData) runningEventData).PushFatalError(fatalErrorType);
            // });
        }