EventSource Klasse

Definition

Bietet die Möglichkeit, Ereignisse für die Ereignisablaufverfolgung auf allen Plattformen zu erstellen.

public ref class EventSource : IDisposable
public class EventSource : IDisposable
type EventSource = class
    interface IDisposable
Public Class EventSource
Implements IDisposable
Vererbung
EventSource
Abgeleitet
Implementiert

Beispiele

Das folgende Beispiel zeigt eine einfache Implementierung der EventSource Klasse.

using System.Diagnostics.Tracing;

namespace Demo1
{
    sealed class MyCompanyEventSource : EventSource
    {
        public static MyCompanyEventSource Log = new MyCompanyEventSource();

        public void Startup() { WriteEvent(1); }
        public void OpenFileStart(string fileName) { WriteEvent(2, fileName); }
        public void OpenFileStop() { WriteEvent(3); }
    }

    class Program1
    {
        static void Main(string[] args)
        {
            MyCompanyEventSource.Log.Startup();
            // ...
            MyCompanyEventSource.Log.OpenFileStart("SomeFile");
            // ...
            MyCompanyEventSource.Log.OpenFileStop();
        }
    }
}
Imports System.Diagnostics.Tracing

Class MyCompanyEventSource
    Inherits EventSource
    Public Shared Log As New MyCompanyEventSource()

    Public Sub Startup()
        WriteEvent(1)
    End Sub

    Public Sub OpenFileStart(ByVal fileName As String)
        WriteEvent(2, fileName)
    End Sub

    Public Sub OpenFileStop()
        WriteEvent(3)
    End Sub
End Class

Class Program

    Shared Sub Main(ByVal args() As String)
        MyCompanyEventSource.Log.Startup()
        ' ...
        MyCompanyEventSource.Log.OpenFileStart("SomeFile")
        ' ...
        MyCompanyEventSource.Log.OpenFileStop()

    End Sub
End Class

Das folgende Beispiel zeigt eine komplexere Implementierung der EventSource Klasse.

using System;
using System.Diagnostics.Tracing;

namespace Demo2
{
    enum MyColor { Red, Yellow, Blue };

    [EventSource(Name = "MyCompany")]
    sealed class MyCompanyEventSource : EventSource
    {
        public static class Keywords
        {
            public const EventKeywords Page = (EventKeywords)1;
            public const EventKeywords DataBase = (EventKeywords)2;
            public const EventKeywords Diagnostic = (EventKeywords)4;
            public const EventKeywords Perf = (EventKeywords)8;
        }

        public static class Tasks
        {
            public const EventTask Page = (EventTask)1;
            public const EventTask DBQuery = (EventTask)2;
        }

        [Event(1, Message = "Application Failure: {0}", Level = EventLevel.Error, Keywords = Keywords.Diagnostic)]
        public void Failure(string message) { WriteEvent(1, message); }

        [Event(2, Message = "Starting up.", Keywords = Keywords.Perf, Level = EventLevel.Informational)]
        public void Startup() { WriteEvent(2); }

        [Event(3, Message = "loading page {1} activityID={0}", Opcode = EventOpcode.Start,
            Task = Tasks.Page, Keywords = Keywords.Page, Level = EventLevel.Informational)]
        public void PageStart(int ID, string url) { if (IsEnabled()) WriteEvent(3, ID, url); }

        [Event(4, Opcode = EventOpcode.Stop, Task = Tasks.Page, Keywords = Keywords.Page, Level = EventLevel.Informational)]
        public void PageStop(int ID) { if (IsEnabled()) WriteEvent(4, ID); }

        [Event(5, Opcode = EventOpcode.Start, Task = Tasks.DBQuery, Keywords = Keywords.DataBase, Level = EventLevel.Informational)]
        public void DBQueryStart(string sqlQuery) { WriteEvent(5, sqlQuery); }

        [Event(6, Opcode = EventOpcode.Stop, Task = Tasks.DBQuery, Keywords = Keywords.DataBase, Level = EventLevel.Informational)]
        public void DBQueryStop() { WriteEvent(6); }

        [Event(7, Level = EventLevel.Verbose, Keywords = Keywords.DataBase)]
        public void Mark(int ID) { if (IsEnabled()) WriteEvent(7, ID); }

        [Event(8)]
        public void LogColor(MyColor color) { WriteEvent(8, (int) color); }

        public static MyCompanyEventSource Log = new MyCompanyEventSource();
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyCompanyEventSource.Log.Startup();
            Console.WriteLine("Starting up");

            MyCompanyEventSource.Log.DBQueryStart("Select * from MYTable");
            var url = "http://localhost";
            for (int i = 0; i < 10; i++)
            {
                MyCompanyEventSource.Log.PageStart(i, url);
                MyCompanyEventSource.Log.Mark(i);
                MyCompanyEventSource.Log.PageStop(i);
            }
            MyCompanyEventSource.Log.DBQueryStop();
            MyCompanyEventSource.Log.LogColor(MyColor.Blue);

            MyCompanyEventSource.Log.Failure("This is a failure 1");
            MyCompanyEventSource.Log.Failure("This is a failure 2");
            MyCompanyEventSource.Log.Failure("This is a failure 3");
        }
    }
}
Imports System.Diagnostics.Tracing


Enum MyColor
    Red
    Yellow
    Blue
End Enum 'MyColor 
<EventSource(Name:="MyCompany")> _
Class MyCompanyEventSource
    Inherits EventSource

    Public Class Keywords
        Public Const Page As EventKeywords = CType(1, EventKeywords)
        Public Const DataBase As EventKeywords = CType(2, EventKeywords)
        Public Const Diagnostic As EventKeywords = CType(4, EventKeywords)
        Public Const Perf As EventKeywords = CType(8, EventKeywords)
    End Class

    Public Class Tasks
        Public Const Page As EventTask = CType(1, EventTask)
        Public Const DBQuery As EventTask = CType(1, EventTask)
    End Class

    <[Event](1, Message:="Application Failure: {0}", Level:=EventLevel.Error, Keywords:=Keywords.Diagnostic)> _
    Public Sub Failure(ByVal message As String)
        WriteEvent(1, message)
    End Sub

    <[Event](2, Message:="Starting up.", Keywords:=Keywords.Perf, Level:=EventLevel.Informational)> _
    Public Sub Startup()
        WriteEvent(2)
    End Sub

    <[Event](3, Message:="loading page {1} activityID={0}", Opcode:=EventOpcode.Start, Task:=Tasks.Page, Keywords:=Keywords.Page, Level:=EventLevel.Informational)> _
    Public Sub PageStart(ByVal ID As Integer, ByVal url As String)
        If IsEnabled() Then
            WriteEvent(3, ID, url)
        End If
    End Sub

    <[Event](4, Opcode:=EventOpcode.Stop, Task:=Tasks.Page, Keywords:=Keywords.Page, Level:=EventLevel.Informational)> _
    Public Sub PageStop(ByVal ID As Integer)
        If IsEnabled() Then
            WriteEvent(4, ID)
        End If
    End Sub

    <[Event](5, Opcode:=EventOpcode.Start, Task:=Tasks.DBQuery, Keywords:=Keywords.DataBase, Level:=EventLevel.Informational)> _
    Public Sub DBQueryStart(ByVal sqlQuery As String)
        WriteEvent(5, sqlQuery)
    End Sub

    <[Event](6, Opcode:=EventOpcode.Stop, Task:=Tasks.DBQuery, Keywords:=Keywords.DataBase, Level:=EventLevel.Informational)> _
    Public Sub DBQueryStop()
        WriteEvent(6)
    End Sub

    <[Event](7, Level:=EventLevel.Verbose, Keywords:=Keywords.DataBase)> _
    Public Sub Mark(ByVal ID As Integer)
        If IsEnabled() Then
            WriteEvent(7, ID)
        End If
    End Sub

    <[Event](8)> _
    Public Sub LogColor(ByVal color As MyColor)
        WriteEvent(8, Fix(color))
    End Sub
    Public Shared Log As New MyCompanyEventSource()
End Class


Class Program

    Shared Sub Main(ByVal args() As String)
        MyCompanyEventSource.Log.Startup()
        Console.WriteLine("Starting up")
        MyCompanyEventSource.Log.DBQueryStart("Select * from MYTable")
        Dim url As String = "http:'localhost"
        Dim i As Integer
        For i = 0 To 9
            MyCompanyEventSource.Log.PageStart(i, url)
            MyCompanyEventSource.Log.Mark(i)
            MyCompanyEventSource.Log.PageStop(i)
        Next i
        MyCompanyEventSource.Log.DBQueryStop()
        MyCompanyEventSource.Log.LogColor(MyColor.Blue)

        MyCompanyEventSource.Log.Failure("This is a failure 1")
        MyCompanyEventSource.Log.Failure("This is a failure 2")
        MyCompanyEventSource.Log.Failure("This is a failure 3")
    End Sub
End Class

Erweiterte Nutzung

Traditionell erwarten benutzerdefinierte EventSource Objekte, dass sie direkt von EventSource. Für erweiterte Szenarien können abstract EventSource Sie jedoch Objekte erstellen, die als Hilfsprogramme bezeichnet werden, und Schnittstellen implementieren. Mit einer oder beiden dieser Techniken können Sie Code zwischen verschiedenen abgeleiteten Quellen freigeben.

Wichtig

Abstrakte EventSource Objekte können keine Schlüsselwörter, Aufgaben, Opcodes, Kanäle oder Ereignisse definieren.

Wichtig

Zum Vermeiden von Namenskonflikten zur Laufzeit beim Generieren von Ereignismetadaten implementieren Sie bei der Verwendung von Schnittstellen mit EventSourceSchnittstellen keine expliziten Schnittstellenmethoden.

Das folgende Beispiel zeigt eine Implementierung, die EventSource eine Schnittstelle verwendet.

public interface IMyLogging
{
    void Error(int errorCode, string message);
    void Warning(string message);
}

public sealed class MySource : EventSource, IMyLogging
{
    public static MySource Log = new();

    [Event(1)]
    public void Error(int errorCode, string message) => WriteEvent(1, errorCode, message);

    [Event(2)]
    public void Warning(string message) => WriteEvent(2, message);
}

Das folgende Beispiel zeigt eine Implementierung, die EventSource das Utility EventSource-Muster verwendet.

public abstract class UtilBaseEventSource : EventSource
{
    protected UtilBaseEventSource()
        : base()
    { }

    protected UtilBaseEventSource(bool throwOnEventWriteErrors)
        : base(throwOnEventWriteErrors)
    { }

    // helper overload of WriteEvent for optimizing writing an event containing
    // payload properties that don't align with a provided overload. This prevents
    // EventSource from using the object[] overload which is expensive.
    protected unsafe void WriteEvent(int eventId, int arg1, short arg2, long arg3)
    {
        if (IsEnabled())
        {
            EventSource.EventData* descrs = stackalloc EventSource.EventData[3];
            descrs[0] = new EventData { DataPointer = (IntPtr)(&arg1), Size = 4 };
            descrs[1] = new EventData { DataPointer = (IntPtr)(&arg2), Size = 2 };
            descrs[2] = new EventData { DataPointer = (IntPtr)(&arg3), Size = 8 };
            WriteEventCore(eventId, 3, descrs);
        }
    }
}

public sealed class OptimizedEventSource : UtilBaseEventSource
{
    public static OptimizedEventSource Log = new();

    public static class Keywords
    {
        public const EventKeywords Kwd1 = (EventKeywords)1;
    }

    [Event(1, Keywords = Keywords.Kwd1, Level = EventLevel.Informational, Message = "LogElements called {0}/{1}/{2}.")]
    public void LogElements(int n, short sh, long l) => WriteEvent(1, n, sh, l); // uses the overload we added!
}

Das folgende Beispiel zeigt eine Implementierung für EventSource Ablaufverfolgungsinformationen zu einer Komponente in einer Bibliothek.

public class ComplexComponent : IDisposable
{
    internal static Dictionary<string, string> _internalState = new();

    private string _name;

    public ComplexComponent(string name)
    {
        _name = name ?? throw new ArgumentNullException(nameof(name));
        ComplexSource.Log.NewComponent(_name);
    }

    public void SetState(string key, string value)
    {
        lock (_internalState)
        {
            _internalState[key] = value;
            ComplexSource.Log.SetState(_name, key, value);
        }
    }

    private void ExpensiveWork1() => System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(250));
    private void ExpensiveWork2() => System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(250));
    private void ExpensiveWork3() => System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(250));
    private void ExpensiveWork4() => System.Threading.Thread.Sleep(TimeSpan.FromMilliseconds(250));

    public void DoWork()
    {
        ComplexSource.Log.ExpensiveWorkStart(_name);

        ExpensiveWork1();
        ExpensiveWork2();
        ExpensiveWork3();
        ExpensiveWork4();

        ComplexSource.Log.ExpensiveWorkStop(_name);
    }

    public void Dispose()
    {
        ComplexSource.Log.ComponentDisposed(_name);
    }
}

internal sealed class ComplexSource : EventSource
{
    public static ComplexSource Log = new();

    public static class Keywords
    {
        public const EventKeywords ComponentLifespan = (EventKeywords)1;
        public const EventKeywords StateChanges = (EventKeywords)(1 << 1);
        public const EventKeywords Performance = (EventKeywords)(1 << 2);
        public const EventKeywords DumpState = (EventKeywords)(1 << 3);
        // a utility keyword for a common combination of keywords users might enable
        public const EventKeywords StateTracking = ComponentLifespan & StateChanges & DumpState;
    }

    protected override void OnEventCommand(EventCommandEventArgs args)
    {
        base.OnEventCommand(args);

        if (args.Command == EventCommand.Enable)
        {
            DumpComponentState();
        }
    }

    [Event(1, Keywords = Keywords.ComponentLifespan, Message = "New component with name '{0}'.")]
    public void NewComponent(string name) => WriteEvent(1, name);

    [Event(2, Keywords = Keywords.ComponentLifespan, Message = "Component with name '{0}' disposed.")]
    public void ComponentDisposed(string name) => WriteEvent(2, name);

    [Event(3, Keywords = Keywords.StateChanges)]
    public void SetState(string name, string key, string value) => WriteEvent(3, name, key, value);

    [Event(4, Keywords = Keywords.Performance)]
    public void ExpensiveWorkStart(string name) => WriteEvent(4, name);

    [Event(5, Keywords = Keywords.Performance)]
    public void ExpensiveWorkStop(string name) => WriteEvent(5, name);

    [Event(6, Keywords = Keywords.DumpState)]
    public void ComponentState(string key, string value) => WriteEvent(6, key, value);

    [NonEvent]
    public void DumpComponentState()
    {
        if (IsEnabled(EventLevel.Informational, Keywords.DumpState))
        {
            lock (ComplexComponent._internalState)
            {
                foreach (var (key, value) in ComplexComponent._internalState)
                    ComponentState(key, value);
            }
        }
    }
}

Hinweise

Diese Klasse soll von einer Benutzerklasse geerbt werden, die bestimmte Ereignisse bereitstellt, die für die Ereignisablaufverfolgung verwendet werden sollen. Die EventSource.WriteEvent Methoden werden aufgerufen, um die Ereignisse zu protokollieren.

Die grundlegende Funktionalität ist EventSource für die meisten Anwendungen ausreichend. Wenn Sie mehr Kontrolle über die erstellten Ereignismetadaten wünschen, können Sie das EventAttribute Attribut auf die Methoden anwenden. Für erweiterte Ereignisquellenanwendungen ist es möglich, die Befehle abzufangen, die an die abgeleitete Ereignisquelle gesendet werden, und die Filterung zu ändern oder Aktionen (z. B. eine Datenstruktur zu dumpingn) zu verursachen, die vom Erber ausgeführt werden. Eine Ereignisquelle kann mithilfe von EventPipe-basierten Tools wie dotnet-trace oder ETW-basierten Logman``PerfView Tools (Event Tracing for Windows, ETW) mithilfe EventListener von Prozessen aktiviert werden. Es ist auch möglich, den Datenversand programmgesteuert zu steuern und abzufangen. Die EventListener Klasse bietet zusätzliche Funktionen.

Konventionen

EventSource-abgeleitete Klassen sollten den folgenden Konventionen folgen:

  • Benutzerdefinierte Klassen sollten ein Singletonmuster implementieren. Die Singleton-Instanz wird traditionell benannt Log. Durch Die Erweiterung sollten Benutzer nicht manuell aufrufen IDisposable.Dispose und der Laufzeit erlauben, die Singleton-Instanz am Ende der Ausführung von verwaltetem Code zu bereinigen.
  • Eine benutzerdefinierte, abgeleitete Klasse sollte als sealed gekennzeichnet werden, es sei denn, sie implementiert die erweiterte Konfiguration "Utility EventSource", die im Abschnitt "Erweiterte Verwendung" erläutert wird.
  • Rufen Sie auf IsEnabled() , bevor Sie eine ressourcenintensive Arbeit ausführen, die sich auf das Auslösen eines Ereignisses bezieht.
  • Sie können implizit Objekte erstellenEventTask, indem Sie zwei Ereignismethoden mit nachfolgenden Ereignis-IDs deklarieren, die über das Benennungsmuster und <EventName>Stopdas Benennungsmuster <EventName>Start verfügen. Diese Ereignisse müssen in der Klassendefinition nebeneinander deklariert werden, und die <EventName>Start Methode muss zuerst kommen.
  • Versuchen Sie, Objekte abwärtskompatibel zu halten und sie entsprechend zu versionieren EventSource . Die Standardversion für ein Ereignis lautet 0. Die Version kann durch Festlegen Versiongeändert werden. Ändern Sie die Version eines Ereignisses, wenn Sie die Eigenschaften der Nutzlast ändern. Fügen Sie immer neue Nutzlasteigenschaften am Ende der Ereignisdeklaration hinzu. Wenn dies nicht möglich ist, erstellen Sie ein neues Ereignis mit einer neuen ID, um die alte zu ersetzen.
  • Geben Sie beim Deklarieren von Ereignismethoden die Nutzlasteigenschaften fester Größe vor variabel angepassten Eigenschaften an.
  • EventKeywords werden als Bitmaske zum Angeben bestimmter Ereignisse beim Abonnieren eines Anbieters verwendet. Sie können Schlüsselwörter angeben, indem Sie eine public static class Keywords Memberklasse public const EventKeywords mit Mitgliedern definieren.
  • Ordnen Sie teure Ereignisse einer Verwendung EventAttributezuEventKeywords. Dieses Muster ermöglicht Es Benutzern, EventSource diese kostspieligen Vorgänge abzumelden.

Selbstbeschreibung (Tracelogging) vs. Manifestereignisformate

EventSource kann auf zwei verschiedene Modi basierend auf dem verwendeten Konstruktor konfiguriert werden oder auf welche Flags festgelegt EventSourceOptionswerden.

In der Vergangenheit werden diese beiden Formate aus zwei Formaten abgeleitet, die die Ereignisablaufverfolgung für Windows (ETW) verwendet. Diese beiden Modi wirken sich zwar nicht auf die Möglichkeit aus, Ereignisablaufverfolgung für Windows (ETW) oder EventPipe-basierte Listener zu verwenden, sie generieren jedoch die Metadaten für Ereignisse anders.

Das Standardereignisformat ist EtwManifestEventFormat, das festgelegt wird, falls nicht angegeben.EventSourceSettings Manifestbasierte EventSource Objekte generieren ein XML-Dokument, das die für die Klasse definierten Ereignisse bei der Initialisierung darstellt. Dies erfordert die EventSource Reflexion über sich selbst, um die Anbieter- und Ereignismetadaten zu generieren.

Um das Ereignisformat selbst zu beschreiben (Tracelogging) zu verwenden, erstellen Sie Dies EventSource mithilfe des Konstruktors, des EventSource(String) EventSource(String, EventSourceSettings) Konstruktors oder durch Festlegen des EtwSelfDescribingEventFormat Flags auf EventSourceSettings. Selbstbeschreibungsquellen generieren minimale Anbietermetadaten bei der Initialisierung und generieren nur Ereignismetadaten, wenn Write(String) aufgerufen wird.

In der Praxis wirken sich diese Ereignisformateinstellungen nur auf die Verwendung mit Lesern basierend auf der Ereignisablaufverfolgung für Windows (ETW) aus. Sie können jedoch einen kleinen Einfluss auf die Initialisierungszeit und die Schreibzeiten pro Ereignis haben, da die für die Reflexion erforderliche Zeit und das Generieren der Metadaten erforderlich ist.

Konstruktoren

EventSource()

Erstellt eine neue Instanz der EventSource-Klasse.

EventSource(Boolean)

Erstellt eine neue Instanz der EventSource-Klasse und gibt an, ob eine Ausnahme ausgelöst werden soll, wenn ein Fehler im zugrunde liegenden Windows-Code auftritt.

EventSource(EventSourceSettings)

Erstellt eine neue Instanz der EventSource-Klasse mit den angegebenen Konfigurationseinstellungen.

EventSource(EventSourceSettings, String[])

Initialisiert eine neue mit nicht im Vertrag enthaltenen Ereignissen zu verwendende Instanz von EventSource, die die angegebenen Einstellungen und Merkmale enthält.

EventSource(String)

Erstellt eine neue Instanz der EventSource-Klasse mit dem angegebenen Namen.

EventSource(String, EventSourceSettings)

Erstellt eine neue Instanz der EventSource-Klasse mit dem angegebenen Namen und den angegebenen Einstellungen.

EventSource(String, EventSourceSettings, String[])

Erstellt eine neue Instanz der EventSource-Klasse mit den angegebenen Konfigurationseinstellungen.

Eigenschaften

ConstructionException

Ruft alle Ausnahmen, die während der Konstruktion einer Ereignisquelle ausgelöst wurden.

CurrentThreadActivityId

Ruft die Aktivitäts-ID des aktuellen Threads ab.

Guid

Der eindeutige Bezeichner für die Ereignisquelle.

Name

Der Anzeigename der Klasse, die von der Ereignisquelle abgeleitet ist.

Settings

Ruft die Einstellungen ab, die für diese Ereignisquelle verwendet wurden.

Methoden

Dispose()

Gibt alle von der aktuellen Instanz der EventSource-Klasse verwendeten Ressourcen frei.

Dispose(Boolean)

Gibt die von der EventSource-Klasse verwendeten nicht verwalteten Ressourcen frei und gibt (optional) auch die verwalteten Ressourcen frei.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Finalize()

Ermöglicht es dem Objekt, Ressourcen freizugeben und andere Bereinigungsvorgänge auszuführen, bevor das EventSource Objekt von der Garbage Collection erneut zurückgegeben wird.

GenerateManifest(Type, String)

Gibt eine Zeichenfolge des XML-Manifests zurück, das der aktuellen Ereignisquelle zugeordnet ist.

GenerateManifest(Type, String, EventManifestOptions)

Gibt eine Zeichenfolge des XML-Manifests zurück, das der aktuellen Ereignisquelle zugeordnet ist.

GetGuid(Type)

Ruft den eindeutigen Bezeichner für diese Implementierung der Ereignisquelle ab.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
IsEnabled()

Bestimmt, ob die aktuelle Ereignisquelle aktiviert ist.

IsEnabled(EventLevel, EventKeywords)

Bestimmt, ob die aktuelle Ereignisquelle, die die angegebene Ebene und das Schlüsselwort enthält, aktiviert ist.

IsEnabled(EventLevel, EventKeywords, EventChannel)

Bestimmt, ob die aktuelle Ereignisquelle für Ereignisse mit der angegebenen Ebene, Schlüsselwort und Kanal aktiviert ist.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
OnEventCommand(EventCommandEventArgs)

Wird aufgerufen, wenn die aktuelle Ereignisquelle vom Controller aktualisiert wird.

SendCommand(EventSource, EventCommand, IDictionary<String,String>)

Sendet einen Befehl an eine angegebene Ereignisquelle.

SetCurrentThreadActivityId(Guid)

Legt die Aktivitäts-ID auf den aktuellen Threads fest.

SetCurrentThreadActivityId(Guid, Guid)

Legt die Aktivitäts-ID für den aktuellen Thread fest und gibt die vorherige Aktivitäts-ID zurück.

ToString()

Ruft eine Zeichenfolgendarstellung der aktuellen Ereignisquellinstanz ab.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
Write(String)

Schreibt ein Ereignis ohne Felder, jedoch mit dem angegebenen Namen und den Standardoptionen.

Write(String, EventSourceOptions)

Schreibt ein Ereignis ohne Felder, jedoch mit dem angegebenen Namen und den angegebenen Optionen.

Write<T>(String, EventSourceOptions, Guid, Guid, T)

Schreibt ein Ereignis mit dem angegebenen Namen, verwandten Aktivitäten und den angegebenen Optionen und Ereignisdaten.

Write<T>(String, EventSourceOptions, T)

Schreibt ein Ereignis mit dem angegebenen Namen und den angegebenen Daten und Optionen.

Write<T>(String, EventSourceOptions, T)

Schreibt ein Ereignis mit dem angegebenen Namen und den angegebenen Optionen und Ereignisdaten.

Write<T>(String, T)

Schreibt ein Ereignis mit dem angegebenen Namen und den angegebenen Daten.

WriteEvent(Int32)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichner.

WriteEvent(Int32, Byte[])

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Bytearray-Arguments.

WriteEvent(Int32, Int32)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Arguments.

WriteEvent(Int32, Int32, Int32)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Argumente.

WriteEvent(Int32, Int32, Int32, Int32)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 32-Bit-Ganzzahl-Argumente.

WriteEvent(Int32, Int32, String)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und den 32-Bit-Ganzzahl- und Zeichenfolgenargumenten.

WriteEvent(Int32, Int64)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Ganzzahl-Arguments.

WriteEvent(Int32, Int64, Byte[])

Schreibt die Ereignisdaten mithilfe des bereitgestellten Bezeichners und den 64-Bit-Ganzzahl- und Bytearray-Argumenten.

WriteEvent(Int32, Int64, Int64)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Argumente.

WriteEvent(Int32, Int64, Int64, Int64)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und 64-Bit-Argumente.

WriteEvent(Int32, Int64, String)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und den 64-Bit-Ganzzahl- und Zeichenfolgenargumenten.

WriteEvent(Int32, Object[])

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumentarrays.

WriteEvent(Int32, String)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargument.

WriteEvent(Int32, String, Int32)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.

WriteEvent(Int32, String, Int32, Int32)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.

WriteEvent(Int32, String, Int64)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Argumente.

WriteEvent(Int32, String, String)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargumente.

WriteEvent(Int32, String, String, String)

Schreibt ein Ereignis mithilfe des bereitgestellten Ereignisbezeichners und Zeichenfolgenargumente.

WriteEventCore(Int32, Int32, EventSource+EventData*)

Erstellt eine neue WriteEvent-Überladung mithilfe des bereitgestellten Ereignisbezeichners und den Ereignisdaten.

WriteEventWithRelatedActivityId(Int32, Guid, Object[])

Schreibt ein Ereignis, die angibt, dass die aktuelle Aktivität mit einer andere Aktivität in Beziehung steht.

WriteEventWithRelatedActivityIdCore(Int32, Guid*, Int32, EventSource+EventData*)

Schreibt ein Ereignis, die angibt, dass die aktuelle Aktivität mit einer andere Aktivität in Beziehung steht.

Ereignisse

EventCommandExecuted

Tritt auf, wenn ein Befehl von einem Ereignislistener stammt.

Gilt für

Threadsicherheit

Dieser Typ ist threadsicher.