C# EventLogEntryType类代码示例

    /// <summary>
    /// Prints a message to the local systems eventlog.
    /// </summary>
    /// <param name="entry"></param>
    /// <param name="type"></param>
    private static void Print(string entry, EventLogEntryType type)
    {
      switch (type)
      {
        case EventLogEntryType.Error: entry = "[error]: " + entry; break;
        case EventLogEntryType.Information: entry = "[comment]: " + entry; break;
        case EventLogEntryType.Warning: entry = "[warning]: " + entry; break;
      }

      try
      {
        if (EventLog.Exists("Application", "."))
        {
          EventLog eventLog = new EventLog("Application", ".", "EasyHook");

#if !DEBUG
                if(InType == EventLogEntryType.Error)
#endif
          eventLog.WriteEntry(entry, type);
        }
      }
      catch
      {
      }

#if DEBUG
      Console.WriteLine(entry);
#endif
    }

        private void AddWindowsEventLog(string message, EventLogEntryType logType = EventLogEntryType.Information, string moduleName = "", int codeErreur = 0, bool fromFileLogEvent = false)
        {
            EventLog evLog = new EventLog(Const.WINDOWS_LOG_NAME);

            message = string.Concat(message, "\r\n", "Module : ", moduleName);
            evLog.Source = Const.DEFAULT_APPLICATION_NAME;

            InitWindowsEventLog();

            try
            {
                evLog.WriteEntry(message, logType, codeErreur);
            }
            catch (Exception ex)
            {
                if (!fromFileLogEvent)
                {
                    AddFileEventLog("Impossible d'écrire dans le journal de log " + Log.Const.WINDOWS_LOG_NAME + ".\r\nLe journal doit être créé préalablement avec un compte Administrateur.\r\nMessage :\r\n" + message + "\r\nException : " + ex.Message, logType, moduleName, codeErreur, true);
                }
            }
            finally
            {
                evLog.Close();
            }
        }

        public EventlogListener(string protocol, string source, string category, EventLogEntryType[] types, string key, int value, IMonitoringChannel channel)
        {
            if (protocol == null)
                throw new ArgumentNullException("protocol");

            if (key == null)
                throw new ArgumentNullException("key");

            if (channel == null)
                throw new ArgumentNullException("channel");

            this.key = key;
            this.value = value;

            this.channel = channel;
            this.types = types;

            this.protocol = protocol;
            this.source = source;
            this.category = category;

            try
            {
                this.Initialize();
            }
            catch (ArgumentException exception)
            {
                throw new ArgumentException(
                    exception.Message + " (" + protocol + ")",
                    exception);
            }
        }

 public LoggingUtil(EventLogEntryType min, EventLogEntryType max, String applicationName)
 {
     isSytemEvent = true;
     minSysLevel = min;
     maxSysLevel = max;
     _logFile.Source = applicationName;
 }

 //Write entry log with custome event log entry type
 public void WriteEntry(string message, EventLogEntryType entryType)
 {
     if (enableDebugLog)
     {
         debugLog.WriteEntry(message, entryType);
     }
 }

 /// <summary/>
 /// <param name="message"/>
 /// <param name="eventLogType"/>
 /// <exclude/>
 public virtual void Log(string message, EventLogEntryType eventLogType)
 {
     lock (lockObj)
     {
         this.eventLog.WriteEntry(message, eventLogType, this.eventId);
     }
 }

 static void EventLog(String evt, EventLogEntryType tpy)
 {
     if (bEventLog)
         eventLog.WriteEntry(evt, tpy);
     //Console.WriteLine(evt);
     //MessageBox.Show(evt);
 }

 public void WriteEventLogEntry(string Message, EventLogEntryType type)
 {
     if(_eventLog!=null)
         _eventLog.WriteEntry(Message, type);
     else
         throw new Exception("Unable to write to event log : not initialized. \r\nMessage to write:\r\n" + Message);
 }

        public static void Log(string message, EventLogEntryType logType, [CallerMemberName] string memberName = "",
            [CallerLineNumber] int lineNumber = 0) {
            try {
                using (StreamWriter log = new StreamWriter("logs.txt", true)) {
                    string _out =
                        $"[{DateTime.Now.ToString("dd/MM hh:mm")} {Enum.GetName(typeof(EventLogEntryType), logType)}] ";

                    switch (logType) {
                        case EventLogEntryType.SuccessAudit:
                        case EventLogEntryType.FailureAudit:
                        case EventLogEntryType.Warning:
                        case EventLogEntryType.Error:
                            _out += $"from `{memberName}' at {lineNumber}: {message}";

                            Console.WriteLine(_out);
                            log.WriteLine(_out);
                            log.Flush();
                            break;
                        case EventLogEntryType.Information:
                            _out += message;

                            Console.WriteLine(_out);
                            log.WriteLine(_out);
                            log.Flush();
                            break;
                        default:
                            throw new ArgumentOutOfRangeException(nameof(logType), logType, null);
                    }
                }
            } catch (Exception ex) {
                Console.WriteLine($"||| Logging error occured: {ex}", EventLogEntryType.Error);
            }
        }

        private static void Write(string message, EventLogEntryType type)
        {
            if (!EventLog.SourceExists(sSource))
                EventLog.CreateEventSource(sSource, "Application");

            EventLog.WriteEntry(sSource, message, type, eventID);
        }

 private static void WriteEventLog(string source, string content, EventLogEntryType type)
 {
     try
     {
         if (!EventLog.SourceExists(source))
         {
             EventLog.CreateEventSource(source, "ECCentral.Service");
         }
         using (EventLog errorLog = new EventLog())
         {
             errorLog.Source = source;
             errorLog.WriteEntry(content, type);
         }
     }
     catch (Exception ex)
     {
         try
         {
             using (EventLog log = new EventLog("Application", ".", "ECCentral.Service.Utility"))
             {
                 log.WriteEntry(ex.ToString(), EventLogEntryType.Error);
             }
         }
         catch
         {
         }
     }
 }

 private void BaseWriteEntry(string message, EventLogEntryType logType, int eventId)
 {
     if (this.HasInitialized)
     {
         this.LoggerProxy.Process(new LogObject(message, logType, eventId));
     }
 }

 /// <summary>
 /// Saves the specified _content.
 /// </summary>
 /// <param name="_content">The _content.</param>
 /// <param name="_logType">Type of the _log.</param>
 /// <returns>System.String.</returns>
 public Result Save(string _content, EventLogEntryType _logType)
 {
     content = _content;
     logType = _logType;
     logPath = @"C:\Cube\Logs\";
     return AddToFile();
 }

        public void Write(string msg, EventLogEntryType type)
        {
            Console.WriteLine(msg);

            // TODO: REBUILD
            //_log.WriteEntry(msg, type);
        }

    public static void Log(object sender, EventLogEntryType logType, string information) {
      if (sender == null)
        sender = new object();
      if (!Enabled)
        return;
      if (!ShowAll && logType != EventLogEntryType.Error && logType != EventLogEntryType.SuccessAudit)
        return;
      var origin = sender.GetType().FullName;
      var trace = new StringBuilder();

      if (logType == EventLogEntryType.Error) {
        var t = new StackTrace();
        for (var i = 0; i < t.FrameCount; ++i) {
          var declaringType = t.GetFrame(i).GetMethod().DeclaringType;
          if (declaringType != null)
            trace.Append(declaringType.FullName + "." + t.GetFrame(i).GetMethod().Name + "\r\n");
        }
      }
      if (_log != null) {
        try {
          _log.WriteEntry(origin + ": " + information + "\r\n\r\nTRACE:\r\n" + trace, logType);
        } catch {}
      }
      OnEvent?.Invoke(logType, sender, trace.ToString(), information);
    }