Zapisz w dzienniku zdarzeń aplikacji systemu Windows

Czy istnieje sposób na zapisanie w tym dzienniku zdarzeń:

A przynajmniej jakiś inny domyślny dziennik systemu Windows, w którym nie muszę rejestrować źródła zdarzeń ?

Tak, istnieje sposób, aby zapisać się do dziennika zdarzeń, którego szukasz. Nie musisz tworzyć nowego źródła, po prostu użyj istniejącego, które często ma taką samą nazwę jak nazwa EventLog, a także, w niektórych przypadkach, jak aplikacja dziennika zdarzeń, może być dostępna bez uprawnień administratora *.

* Inne przypadki, w których nie można uzyskać do niego bezpośredniego dostępu, to na przykład Security EventLog, do którego dostęp ma tylko system operacyjny.

Użyłem tego kodu, aby napisać bezpośrednio do dziennika zdarzeń Aplikacja:

using (EventLog eventLog = new EventLog("Application")) 
{
    eventLog.Source = "Application"; 
    eventLog.WriteEntry("Log message example", EventLogEntryType.Information, 101, 1); 
}

Jak widać, źródło EventLog jest takie samo jak nazwa EventLog. Powód tego można znaleźć w Event Sources @ Windows Dev Center (pogrubiłem część, która odnosi się do nazwy źródła):

Każdy dziennik w kluczu Eventlog zawiera podklucze zwane źródłami zdarzeń. Źródło zdarzenia to nazwa oprogramowania, które rejestruje zdarzenie. Często jest to nazwa aplikacji lub nazwa podkomponentu aplikacji, jeśli aplikacja jest duża. Do rejestru można dodać maksymalnie 16 384 źródła zdarzeń.

Możesz użyć klasy EventLog, jak wyjaśniono w temacie How to: Write to the Application Event Log (Visual C #) :

var appLog = new EventLog("Application");
appLog.Source = "MySource";
appLog.WriteEntry("Test log message");

Musisz jednak skonfigurować to źródło „Moje źródło ” przy użyciu uprawnień administracyjnych:

Użyj WriteEvent i WriteEntry, aby zapisywać zdarzenia w dzienniku zdarzeń. Aby zapisywać zdarzenia, musisz określić źródło zdarzenia; musisz utworzyć i skonfigurować źródło zdarzenia przed zapisaniem pierwszego wpisu ze źródłem.

Jak podano w MSDN (np. Https://msdn.microsoft.com/en-us/library/system.diagnostics.eventlog(v=vs.110).aspx ), sprawdzenie nieistniejącego źródła i utworzenie źródła wymaga administratora przywilej.

Możliwe jest jednak użycie źródła „Aplikacja” bez. Podczas testu w systemie Windows 2012 Server r2 otrzymuję jednak następujący wpis dziennika przy użyciu źródła „Aplikacja”:

Nie można znaleźć opisu dla identyfikatora zdarzenia xxxx z aplikacji źródłowej. Albo składnik wywołujący to zdarzenie nie jest zainstalowany na komputerze lokalnym albo instalacja jest uszkodzona. Możesz zainstalować lub naprawić komponent na komputerze lokalnym. Jeśli zdarzenie powstało na innym komputerze, informacje o wyświetlaniu musiały zostać zapisane wraz ze zdarzeniem. Następujące informacje zostały dołączone do zdarzenia: {my event entry message} zasób wiadomości jest obecny, ale wiadomość nie została znaleziona w tabeli string / message

Zdefiniowałem następującą metodę tworzenia źródła:

    private string CreateEventSource(string currentAppName)
    {
        string eventSource = currentAppName;
        bool sourceExists;
        try
        {
            // searching the source throws a security exception ONLY if not exists!
            sourceExists = EventLog.SourceExists(eventSource);
            if (!sourceExists)
            {   // no exception until yet means the user as admin privilege
                EventLog.CreateEventSource(eventSource, "Application");
            }
        }
        catch (SecurityException)
        {
            eventSource = "Application";
        }

        return eventSource;
    }

Wołam to z currentAppName = AppDomain.CurrentDomain.FriendlyName

Może być możliwe użycie klasy EventLogPermission zamiast tego try / catch, ale nie jesteśmy pewni, czy uda nam się uniknąć złapania.

Możliwe jest również utworzenie źródła zewnętrznie, np. W podwyższonym Powershellu:

New-EventLog -LogName Application -Source MyApp

Następnie użycie „MyApp” w powyższej metodzie NIE spowoduje wygenerowania wyjątku, a dziennik zdarzeń można utworzyć za pomocą tego źródła.

To jest klasa rejestratora, której używam. Zawiera metodę private Log () EventLog.WriteEntry(), czyli sposób, w jaki faktycznie zapisujesz w dzienniku zdarzeń. Dołączam tutaj cały ten kod, ponieważ jest przydatny. Oprócz rejestrowania ta klasa zapewnia również, że wiadomość nie jest zbyt długa, aby można ją było zapisać w dzienniku zdarzeń (spowoduje to obcięcie wiadomości). Jeśli wiadomość była za długa, pojawi się wyjątek. Wzywający może również określić źródło. Jeśli wywołujący tego nie zrobi, ta klasa otrzyma źródło. Mam nadzieję, że to pomoże.

Nawiasem mówiąc, możesz pobrać ObjectDumper z Internetu. Nie chciałem tego tutaj publikować. Mam stąd:C:\Program Files (x86)\Microsoft Visual Studio 10.0\Samples\1033\CSharpSamples.zip\LinqSamples\ObjectDumper

using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using Xanico.Core.Utilities;

namespace Xanico.Core
{
    /// <summary>
    /// Logging operations
    /// </summary>
    public static class Logger
    {
        // Note: The actual limit is higher than this, but different Microsoft operating systems actually have
        //       different limits. So just use 30,000 to be safe.
        private const int MaxEventLogEntryLength = 30000;

        /// <summary>
        /// Gets or sets the source/caller. When logging, this logger class will attempt to get the
        /// name of the executing/entry assembly and use that as the source when writing to a log.
        /// In some cases, this class can't get the name of the executing assembly. This only seems
        /// to happen though when the caller is in a separate domain created by its caller. So,
        /// unless you're in that situation, there is no reason to set this. However, if there is
        /// any reason that the source isn't being correctly logged, just set it here when your
        /// process starts.
        /// </summary>
        public static string Source { get; set; }

        /// <summary>
        /// Logs the message, but only if debug logging is true.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="debugLoggingEnabled">if set to <c>true</c> [debug logging enabled].</param>
        /// <param name="source">The name of the app/process calling the logging method. If not provided,
        /// an attempt will be made to get the name of the calling process.</param>
        public static void LogDebug(string message, bool debugLoggingEnabled, string source = "")
        {
            if (debugLoggingEnabled == false) { return; }

            Log(message, EventLogEntryType.Information, source);
        }

        /// <summary>
        /// Logs the information.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="source">The name of the app/process calling the logging method. If not provided,
        /// an attempt will be made to get the name of the calling process.</param>
        public static void LogInformation(string message, string source = "")
        {
            Log(message, EventLogEntryType.Information, source);
        }

        /// <summary>
        /// Logs the warning.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="source">The name of the app/process calling the logging method. If not provided,
        /// an attempt will be made to get the name of the calling process.</param>
        public static void LogWarning(string message, string source = "")
        {
            Log(message, EventLogEntryType.Warning, source);
        }

        /// <summary>
        /// Logs the exception.
        /// </summary>
        /// <param name="ex">The ex.</param>
        /// <param name="source">The name of the app/process calling the logging method. If not provided,
        /// an attempt will be made to get the name of the calling process.</param>
        public static void LogException(Exception ex, string source = "")
        {
            if (ex == null) { throw new ArgumentNullException("ex"); }

            if (Environment.UserInteractive)
            {
                Console.WriteLine(ex.ToString());
            }

            Log(ex.ToString(), EventLogEntryType.Error, source);
        }

        /// <summary>
        /// Recursively gets the properties and values of an object and dumps that to the log.
        /// </summary>
        /// <param name="theObject">The object to log</param>
        [SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "Xanico.Core.Logger.Log(System.String,System.Diagnostics.EventLogEntryType,System.String)")]
        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "object")]
        public static void LogObjectDump(object theObject, string objectName, string source = "")
        {
            const int objectDepth = 5;
            string objectDump = ObjectDumper.GetObjectDump(theObject, objectDepth);

            string prefix = string.Format(CultureInfo.CurrentCulture,
                                          "{0} object dump:{1}",
                                          objectName,
                                          Environment.NewLine);

            Log(prefix + objectDump, EventLogEntryType.Warning, source);
        }

        private static void Log(string message, EventLogEntryType entryType, string source)
        {
            // Note: I got an error that the security log was inaccessible. To get around it, I ran the app as administrator
            //       just once, then I could run it from within VS.

            if (string.IsNullOrWhiteSpace(source))
            {
                source = GetSource();
            }

            string possiblyTruncatedMessage = EnsureLogMessageLimit(message);
            EventLog.WriteEntry(source, possiblyTruncatedMessage, entryType);

            // If we're running a console app, also write the message to the console window.
            if (Environment.UserInteractive)
            {
                Console.WriteLine(message);
            }
        }

        private static string GetSource()
        {
            // If the caller has explicitly set a source value, just use it.
            if (!string.IsNullOrWhiteSpace(Source)) { return Source; }

            try
            {
                var assembly = Assembly.GetEntryAssembly();

                // GetEntryAssembly() can return null when called in the context of a unit test project.
                // That can also happen when called from an app hosted in IIS, or even a windows service.

                if (assembly == null)
                {
                    assembly = Assembly.GetExecutingAssembly();
                }


                if (assembly == null)
                {
                    // From http://stackoverflow.com/a/14165787/279516:
                    assembly = new StackTrace().GetFrames().Last().GetMethod().Module.Assembly;
                }

                if (assembly == null) { return "Unknown"; }

                return assembly.GetName().Name;
            }
            catch
            {
                return "Unknown";
            }
        }

        // Ensures that the log message entry text length does not exceed the event log viewer maximum length of 32766 characters.
        private static string EnsureLogMessageLimit(string logMessage)
        {
            if (logMessage.Length > MaxEventLogEntryLength)
            {
                string truncateWarningText = string.Format(CultureInfo.CurrentCulture, "... | Log Message Truncated [ Limit: {0} ]", MaxEventLogEntryLength);

                // Set the message to the max minus enough room to add the truncate warning.
                logMessage = logMessage.Substring(0, MaxEventLogEntryLength - truncateWarningText.Length);

                logMessage = string.Format(CultureInfo.CurrentCulture, "{0}{1}", logMessage, truncateWarningText);
            }

            return logMessage;
        }
    }
}

próbować

   System.Diagnostics.EventLog appLog = new System.Diagnostics.EventLog();
   appLog.Source = "This Application's Name";
   appLog.WriteEntry("An entry to the Application event log.");