it-swarm.com.de

Schreiben Sie in das Windows-Anwendungsereignisprotokoll

Gibt es eine Möglichkeit, in dieses Ereignisprotokoll zu schreiben:

enter image description here

Oder zumindest ein anderes Windows-Standardprotokoll, wo muss ich keine Ereignisquelle registrieren?

98
Jerther

Ja, es gibt eine Möglichkeit, in das Ereignisprotokoll zu schreiben, nach dem Sie suchen. Sie müssen keine neue Quelle erstellen. Verwenden Sie einfach die vorhandene Quelle, die oft denselben Namen wie der Name des EventLogs hat und in einigen Fällen wie die Ereignisprotokollanwendung auch ohne Administratorrechte zugänglich ist *.

* Andere Fälle, in denen Sie nicht direkt darauf zugreifen können, sind beispielsweise das Security EventLog, auf das nur das Betriebssystem zugreifen kann.

Ich habe diesen Code verwendet, um direkt in die Ereignisprotokollanwendung zu schreiben:

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

Wie Sie sehen, stimmt die EventLog-Quelle mit dem Namen des EventLog überein. Den Grund dafür finden Sie in Event Sources @ Windows Dev Center (Ich habe den Teil, der sich auf den Quellnamen bezieht, fett gedruckt):

Jedes Protokoll im Ereignisprotokollschlüssel enthält Unterschlüssel, die als Ereignisquellen bezeichnet werden. Die Ereignisquelle ist der Name der Software, die das Ereignis protokolliert. Es ist oft der Name der Anwendung oder der Name einer Unterkomponente der Anwendung, wenn die Anwendung groß ist. Sie können der Registrierung maximal 16.384 Ereignisquellen hinzufügen.

169
cloud120

Sie können die EventLog-Klasse verwenden, wie unter Gewusst wie: Schreiben in das Anwendungsereignisprotokoll (Visual C #) beschrieben:

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

Sie müssen dieses source "MySource" jedoch mit Administratorrechten konfigurieren:

Verwenden Sie WriteEvent und WriteEntry, um Ereignisse in ein Ereignisprotokoll zu schreiben. Sie müssen eine Ereignisquelle angeben, um Ereignisse zu schreiben. Sie müssen die Ereignisquelle erstellen und konfigurieren, bevor Sie den ersten Eintrag mit der Quelle schreiben.

9
CodeCaster

Dies ist die Logger-Klasse, die ich verwende. Die private Log () -Methode enthält EventLog.WriteEntry(). So schreiben Sie tatsächlich in das Ereignisprotokoll. Ich füge den gesamten Code hier ein, weil er praktisch ist. Zusätzlich zur Protokollierung stellt diese Klasse auch sicher, dass die Nachricht nicht zu lang ist, um in das Ereignisprotokoll geschrieben zu werden (die Nachricht wird dadurch abgeschnitten). Wenn die Nachricht zu lang war, erhalten Sie eine Ausnahme. Der Anrufer kann auch die Quelle angeben. Wenn der Anrufer dies nicht tut, erhält diese Klasse die Quelle. Ich hoffe es hilft.

Übrigens können Sie einen ObjectDumper aus dem Web beziehen. Ich wollte das nicht alles hier posten. Ich habe meine von hier: 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;
        }
    }
}
8
Bob Horn

Wie in MSDN angegeben (z. B. https://msdn.Microsoft.com/de-de/library/system.diagnostics.eventlog(v=vs.110).aspx ), wird eine nicht vorhandene Quelle geprüft und erstellt Eine Quelle erfordert Administratorrechte.

Es ist jedoch möglich, source "Application" ohne ..__ zu verwenden. In meinem Test unter Windows 2012 Server r2 bekomme ich jedoch den folgenden Protokolleintrag mit der Quelle "Application":

Die Beschreibung für Ereignis-ID xxxx aus der Quellanwendung kann nicht gefunden werden. Entweder ist die Komponente, die dieses Ereignis auslöst, nicht auf Ihrem lokalen Computer installiert oder die Installation ist beschädigt. Sie können die Komponente auf dem lokalen Computer installieren oder reparieren. Wenn das Ereignis von einem anderen Computer stammt, mussten die Anzeigeinformationen mit dem Ereignis gespeichert werden. Die folgenden Informationen wurden in die Veranstaltung aufgenommen: {meine Ereigniseintragsnachricht} Die Nachrichtenressource ist vorhanden, aber die Nachricht wurde nicht in der Zeichenfolge-/Nachrichtentabelle gefunden

Ich habe die folgende Methode zum Erstellen der Quelle definiert:

    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;
    }

Ich rufe es mit currentAppName = AppDomain.CurrentDomain.FriendlyName auf

Es kann möglich sein, die EventLogPermission-Klasse anstelle von try/catch zu verwenden, aber nicht sicher, dass wir den catch vermeiden können.

Es ist auch möglich, die Quelle extern zu erstellen, z. B. in erhöhter Powershell:

New-EventLog -LogName Application -Source MyApp

Wenn Sie in der obigen Methode 'MyApp' verwenden, wird KEINE Ausnahme generiert, und das EventLog kann mit dieser Quelle erstellt werden.

4
EricBDev

EventLog Class Bietet Interaktion mit Windows-Ereignisprotokollen. Dieses Beispiel zeigt, wie Sie in EventViewer schreiben.

        public void WriteEventLog(string message)
        {

           EventLog eventLog = new EventLog() { Source = "application Name",           
           EnableRaisingEvents = true };
           eventLog.WriteEntry( message);

        }
0