EventSource Osztály

Definíció

Névtér:: System.Diagnostics.Tracing

Szerelvények:: mscorlib.dll, System.Diagnostics.Tracing.dll

Szerelvények:: netstandard.dll, System.Diagnostics.Tracing.dll

Szerelvény:: System.Diagnostics.Tracing.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Forrás:: EventSource.cs

Forrás:: EventSource.cs

Forrás:: EventSource.cs

Forrás:: EventSource.cs

Forrás:: EventSource.cs

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Lehetővé teszi események létrehozását az események nyomon követéséhez a platformokon.

public ref class EventSource : IDisposable

public class EventSource : IDisposable

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)]
public class EventSource : IDisposable

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)]
public class EventSource : IDisposable

type EventSource = class
    interface IDisposable

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes)>]
type EventSource = class
    interface IDisposable

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All)>]
type EventSource = class
    interface IDisposable

Public Class EventSource
Implements IDisposable

Öröklődés: Object
EventSource

Származtatott: Microsoft.Extensions.Logging.EventSource.LoggingEventSource

Attribútumok: DynamicallyAccessedMembersAttribute

Megvalósítás: IDisposable

Példák

Az alábbi példa az osztály egyszerű implementációját EventSource mutatja be.

using System.Diagnostics.Tracing;

namespace Demo
{
    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 Program
    {
        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

Az alábbi példa az osztály összetettebb implementációját EventSource mutatja be.

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 Program
    {
        static void Main(string[] args)
        {
            MyCompanyEventSource.Log.Startup();
            // ...
            MyCompanyEventSource.Log.OpenFileStart("SomeFile");
            // ...
            MyCompanyEventSource.Log.OpenFileStop();
        }
    }
}

Imports System.Diagnostics.Tracing

Enum MyColor
    Red
    Yellow
    Blue
End Enum 'MyColor
<EventSource(Name:="MyCompany")>
Class MyCompanyEventSource1
    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 MyCompanyEventSource1()
End Class

Class Program1

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

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

Haladó szintű használat

Hagyományosan a felhasználó által definiált EventSource objektumok közvetlenül öröklődnek EventSource-ből. Speciális forgatókönyvek esetén azonban létrehozhat abstractEventSource objektumokat, úgynevezett segédprogramforrásokat, és implementálhat interfészeket. Az egyik vagy mindkét módszer használatával kódot oszthat meg a különböző származtatott források között.

Important

Az absztrakt EventSource objektumok nem határozhatnak meg kulcsszavakat, feladatokat, opcode-okat, csatornákat vagy eseményeket.

Important

Ha el szeretné kerülni a névütközést futásidőben az esemény metaadatainak létrehozásakor, ne implementáljon explicit módon felületi metódusokat a felületekkel való EventSourcehasználat során.

Az alábbi példa egy felületet használó implementációt EventSource mutat be.

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

Az alábbi példa az Utility EventSource-mintát használó implementációt EventSource mutatja be.

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

Az alábbi példa egy kódtár egy összetevőjére vonatkozó nyomkövetési EventSource információk implementálását mutatja be.

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

Megjegyzések

Az EventSource osztályt egy olyan felhasználói osztály örökli, amely az eseménykövetéshez használandó konkrét eseményeket biztosít. A EventSource.WriteEvent metódusok az események naplózására vannak meghívva.

Az alapvető funkciók EventSource a legtöbb alkalmazáshoz elegendőek. Ha jobban szeretné szabályozni a létrehozott esemény metaadatait, alkalmazhatja az EventAttribute attribútumot a metódusokra. Haladó eseményforrás-alkalmazások esetén lehetőség van arra, hogy elfogja a származtatott eseményforrásnak küldött parancsokat, és módosítsa a szűrést, vagy az öröklő program által végrehajtandó műveleteket (például egy adatstruktúra memóriaképének kiírását) kezdeményezze. Az eseményforrást folyamaton belül lehet aktiválni EventListener használatával, míg folyamaton kívül EventPipe-alapú eszközökkel, mint például dotnet-trace, vagy az Event Tracing for Windows (ETW)-alapú eszközökkel, mint például PerfView vagy Logman. Az adatküldő programozott módon is vezérelhető és elfogható. Az EventListener osztály további funkciókat biztosít.

Conventions

EventSource Származtatott osztályoknak a következő konvenciók szerint kell eljárniuk:

A felhasználó által definiált osztályoknak egységes mintát kell implementálniuk. A singleton példány neve hagyományosan Log. A felhasználók ne hívják meg IDisposable.Dispose manuálisan, és hagyják a futtatókörnyezetnek, hogy megtisztítsa a singleton példányt a felügyelt kód végrehajtásának végén.
A felhasználó által definiált, származtatott osztályt sealed kell megjelölni, kivéve, ha megvalósítja a Speciális használat szakaszban tárgyalt "Utility EventSource" konfigurációt.
Hívja meg a IsEnabled() komponenst, mielőtt bármilyen, az esemény kiváltásához kapcsolódó erőforrás-igényes tevékenységet végezne.
Objektumokat implicit módon hozhat létre EventTask azáltal, hogy deklarál két olyan eseménymetódust, amelyek elnevezési mintája <EventName>Start és <EventName>Stop eseményazonosítókkal van ellátva. Ezeket az eseményeket egymás mellett kell deklarálni az osztálydefinícióban, és először a <EventName>Start metódusnak kell lennie.
Próbálja meg visszafelé kompatibilisen tartani EventSource az objektumokat, és megfelelően verziószámozza őket. Az esemény alapértelmezett verziója a következő 0: . A verzió a beállítással Versionmódosítható. Az esemény verzióját módosítsa, amikor a hasznos adatok tulajdonságait megváltoztatja. Az új payload tulajdonságokat mindig az eseménydeklaráció végéhez adja hozzá. Ha ez nem lehetséges, hozzon létre egy új eseményt egy új azonosítóval a régi helyett.
Eseménymódszerek deklarálásakor adja meg a rögzített méretű hasznos adat tulajdonságokat a változó méretű tulajdonságok előtt.
EventKeywords a rendszer bitmaszkként használja a szolgáltatóra való feliratkozáskor megadott események megadásához. Kulcsszavakat úgy adhat meg, ha egy public static class Keywords tagosztályt határoz meg, amelynek tagjai vannak public const EventKeywords .
Egy EventKeywords társítása drága eseményekhez a EventAttribute segítségével. Ez a minta lehetővé teszi a EventSource felhasználók számára, hogy kikapcsolják ezeket a drága műveleteket.

Önleíró (nyomkövetési) és jegyzékes eseményformátumok

EventSource konfigurálható két különböző módra a használt konstruktor vagy a beállított jelölők EventSourceOptionsalapján.

Korábban ez a két formátum két olyan formátumból származik, amelyeket az Event Tracing for Windows (ETW) használt. Bár ez a két mód nem befolyásolja az Eseménykövetés Windowsos (ETW) vagy EventPipe-alapú figyelők használatát, az események metaadatait különböző módon generálják.

Az alapértelmezett eseményformátum az EtwManifestEventFormat, amely akkor van beállítva, ha nincs megadva a EventSourceSettings-en. A jegyzékalapú EventSource objektumok létrehoznak egy XML-dokumentumot, amely az osztályban az inicializáláskor meghatározott eseményeket jelöli. Ehhez a EventSource-nak saját magán kell tükröznie, hogy létrehozza a szolgáltató és az esemény metaadatait.

Ha önleíró (nyomkövetési) eseményformátumot szeretne használni, készítse el a EventSource-t a EventSource(String) vagy a EventSource(String, EventSourceSettings) konstruktor segítségével, vagy állítsa be a EtwSelfDescribingEventFormat jelölőt a EventSourceSettings-on/-en/-ön. Az önleíró források minimális szolgáltatói metaadatokat hoznak létre az inicializáláskor, és csak akkor hoznak létre esemény metaadatokat, ha Write(String) meghívják őket. A jegyzékalapú formátumtól eltérően az ETW-en keresztüli hallgatáskor csak a Szint, a Kulcsszó és az Opcode metaadatai szerepelnek az EventAttribute attribútumban. Más tulajdonságok, például az EventId vagy az Üzenet nem szerepelnek benne.

A gyakorlatban ezek az eseményformátum-beállítások csak a Windows eseménykövetése (ETW) alapján befolyásolják az olvasók használatát. Ezek azonban kis hatással lehetnek az inicializálási időre és az eseményenkénti írási időkre a tükrözéshez és a metaadatok létrehozásához szükséges idő miatt.

Konstruktorok

Name	Description
EventSource()	Létrehozza az osztály új példányát EventSource .
EventSource(Boolean)	Létrehozza a EventSource osztály új példányát, és megadja, hogy kivételt adjon-e ki, ha hiba történik az alapul szolgáló Windows kódban.
EventSource(EventSourceSettings, String[])	Inicializálja a használni kívánt új példányt a EventSource megadott beállításokat és tulajdonságokat tartalmazó, szerződésen kívüli eseményekkel.
EventSource(EventSourceSettings)	Létrehozza az osztály új példányát EventSource a megadott konfigurációs beállításokkal.
EventSource(String, EventSourceSettings, String[])	Létrehozza az osztály új példányát EventSource a megadott konfigurációs beállításokkal.
EventSource(String, EventSourceSettings)	Létrehozza az osztály új példányát EventSource a megadott névvel és beállításokkal.
EventSource(String, Guid, EventSourceSettings, String[])	Lehetővé teszi események létrehozását az események nyomon követéséhez a platformokon.
EventSource(String, Guid)	Lehetővé teszi események létrehozását az események nyomon követéséhez a platformokon.
EventSource(String)	Létrehozza az osztály új példányát EventSource a megadott névvel.

Tulajdonságok

Name	Description
ConstructionException	Kivételt kap, amely az eseményforrás felépítése során történt.
CurrentThreadActivityId	Lekéri az aktuális szál tevékenységazonosítóját.
Guid	Az eseményforrás egyedi azonosítója.
Name	Az eseményforrásból származtatott osztály rövid neve.
Settings	Lekéri az eseményforrásra alkalmazott beállításokat.

Metódusok

Name	Description
Dispose()	Az osztály aktuális példánya által használt összes erőforrást felszabadítja EventSource .
Dispose(Boolean)	Felszabadítja az osztály által EventSource használt nem felügyelt erőforrásokat, és opcionálisan felszabadítja a felügyelt erőforrásokat.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
Finalize()	Lehetővé teszi, hogy az EventSource objektum megkísérlje felszabadítani az erőforrásokat, és más tisztítási műveleteket hajt végre, mielőtt a szemétgyűjtés visszanyeri az objektumot.
GenerateManifest(Type, String, EventManifestOptions)	Az aktuális eseményforráshoz társított XML-jegyzék sztringét adja vissza.
GenerateManifest(Type, String)	Az aktuális eseményforráshoz társított XML-jegyzék sztringét adja vissza.
GetGuid(Type)	Lekéri az eseményforrás implementációjának egyedi azonosítóját.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetName(Type)	Lekéri az esemény forrásának rövid nevét.
GetSources()	Pillanatképet kap az alkalmazástartomány összes eseményforrásáról.
GetTrait(String)	Lekéri a megadott kulccsal társított tulajdonságértéket.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
IsEnabled()	Meghatározza, hogy az aktuális eseményforrás engedélyezve van-e.
IsEnabled(EventLevel, EventKeywords, EventChannel)	Meghatározza, hogy az aktuális eseményforrás engedélyezve van-e a megadott szinttel, kulcsszavakkal és csatornával rendelkező eseményekhez.
IsEnabled(EventLevel, EventKeywords)	Meghatározza, hogy engedélyezve van-e az aktuális eseményforrás, amely rendelkezik a megadott szinttel és kulcsszóval.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
OnEventCommand(EventCommandEventArgs)	Akkor hívjuk meg, ha a vezérlő frissíti az aktuális eseményforrást.
SendCommand(EventSource, EventCommand, IDictionary<String,String>)	Parancsot küld egy megadott eseményforrásnak.
SetCurrentThreadActivityId(Guid, Guid)	Beállítja az aktuális szál tevékenységazonosítóját, és visszaadja az előző tevékenységazonosítót.
SetCurrentThreadActivityId(Guid)	Beállítja a tevékenységazonosítót az aktuális szálon.
ToString()	Lekéri az aktuális eseményforráspéldány sztringképét.
Write(String, EventSourceOptions)	Eseményt ír mezők nélkül, de a megadott névvel és beállításokkal.
Write(String)	Eseményt ír mezők nélkül, de a megadott névvel és alapértelmezett beállításokkal.
Write<T>(String, EventSourceOptions, Guid, Guid, T)	A megadott névvel, beállításokkal, kapcsolódó tevékenységgel és eseményadatokkal rendelkező eseményt ír.
Write<T>(String, EventSourceOptions, T)	A megadott névvel, eseményadatokkal és beállításokkal rendelkező eseményt ír.
Write<T>(String, EventSourceOptions, T)	A megadott névvel, beállításokkal és eseményadatokkal rendelkező eseményt ír.
Write<T>(String, T)	A megadott névvel és adatokkal rendelkező eseményt ír.
WriteEvent(Int32, Byte[])	Esemény írása a megadott eseményazonosító és bájttömb argumentum használatával.
WriteEvent(Int32, EventSource+EventSourcePrimitive[])	Eseményt ír a megadott eseményazonosító és az eseményforrás-primitívek változó száma alapján.
WriteEvent(Int32, Int32, Int32, Int32)	Eseményt ír a megadott eseményazonosító és 32 bites egész szám argumentumok használatával.
WriteEvent(Int32, Int32, Int32)	Eseményt ír a megadott eseményazonosító és 32 bites egész szám argumentumok használatával.
WriteEvent(Int32, Int32, String)	Eseményt ír a megadott eseményazonosító, valamint 32 bites egész szám és sztringargumentumok használatával.
WriteEvent(Int32, Int32)	Eseményt ír a megadott eseményazonosító és 32 bites egész szám argumentum használatával.
WriteEvent(Int32, Int64, Byte[])	Az eseményadatokat a megadott azonosítóval, valamint 64 bites egész számokkal és bájttömbargumentumokkal írja.
WriteEvent(Int32, Int64, Int64, Int64)	Eseményt ír a megadott eseményazonosító és 64 bites argumentumok használatával.
WriteEvent(Int32, Int64, Int64)	Eseményt ír a megadott eseményazonosító és 64 bites argumentumok használatával.
WriteEvent(Int32, Int64, String)	Eseményt ír a megadott eseményazonosító és 64 bites egész szám, valamint sztringargumentumok használatával.
WriteEvent(Int32, Int64)	Eseményt ír a megadott eseményazonosító és 64 bites egész szám argumentum használatával.
WriteEvent(Int32, Object[])	Eseményt ír a megadott eseményazonosító és argumentumtömb használatával.
WriteEvent(Int32, String, Int32, Int32)	Esemény írása a megadott eseményazonosító és argumentumok használatával.
WriteEvent(Int32, String, Int32)	Esemény írása a megadott eseményazonosító és argumentumok használatával.
WriteEvent(Int32, String, Int64)	Esemény írása a megadott eseményazonosító és argumentumok használatával.
WriteEvent(Int32, String, String, String)	Eseményt ír a megadott eseményazonosító és sztringargumentumok használatával.
WriteEvent(Int32, String, String)	Eseményt ír a megadott eseményazonosító és sztringargumentumok használatával.
WriteEvent(Int32, String)	Esemény írása a megadott eseményazonosító és sztringargumentum használatával.
WriteEvent(Int32)	Eseményt ír a megadott eseményazonosító használatával.
WriteEventCore(Int32, Int32, EventSource+EventData*)	Új WriteEvent túlterhelést hoz létre a megadott eseményazonosító és eseményadatok használatával.
WriteEventWithRelatedActivityId(Int32, Guid, Object[])	Olyan eseményt ír, amely azt jelzi, hogy az aktuális tevékenység egy másik tevékenységhez kapcsolódik.
WriteEventWithRelatedActivityIdCore(Int32, Guid, Int32, EventSource+EventData)	Olyan eseményt ír, amely azt jelzi, hogy az aktuális tevékenység egy másik tevékenységhez kapcsolódik.

esemény

Name	Description
EventCommandExecuted	Akkor fordul elő, ha egy parancs egy eseményfigyelőtől származik.

A következőre érvényes:

Szálbiztonság

Ez a típus szálbiztos.

Visszajelzés

Hasznosnak találta ezt az oldalt?