EventSource.WriteEventCore(Int32, Int32, EventSource+EventData*) Metod

Definition

Namnområde:
System.Diagnostics.Tracing
Sammansättningar:
mscorlib.dll, System.Diagnostics.Tracing.dll
Sammansättning:
mscorlib.dll
Sammansättning:
System.Diagnostics.Tracing.dll
Sammansättning:
netstandard.dll

Viktigt!

Detta API uppfyller inte CLS.

Skapar en ny WriteEvent överlagring med hjälp av den angivna händelseidentifieraren och händelsedata.

protected:
 void WriteEventCore(int eventId, int eventDataCount, System::Diagnostics::Tracing::EventSource::EventData* data);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
protected void WriteEventCore(int eventId, int eventDataCount, System.Diagnostics.Tracing.EventSource.EventData* data);
[System.CLSCompliant(false)]
protected void WriteEventCore(int eventId, int eventDataCount, System.Diagnostics.Tracing.EventSource.EventData* data);
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
member this.WriteEventCore : int * int * nativeptr<System.Diagnostics.Tracing.EventSource.EventData> -> unit
[<System.CLSCompliant(false)>]
member this.WriteEventCore : int * int * nativeptr<System.Diagnostics.Tracing.EventSource.EventData> -> unit

Parametrar

eventId
Int32

Händelseidentifieraren.

eventDataCount
Int32

Antalet händelsedataobjekt.

data
EventSource.EventData

Strukturen som innehåller händelsedata.

Attribut
CLSCompliantAttribute SecurityCriticalAttribute

Kommentarer

eventid bör vara större än 0 eller mindre än 65535 eller fel kan inträffa i åtgärden. Om fel inträffar kan du få mer information om källan till felet genom att kontrollera utdataströmmen för felsökningsprogrammet, om du har ett felsökningsprogram kopplat till processavfyrningshändelserna. Du kan också söka efter fel som rapporterats i ETW-händelseströmmen om du har en ETW-lyssnare på händelsekällan där felet inträffar.

Med den här skyddade metoden kan användare definiera nya WriteEvent överbelastningar som är snabbare än de angivna överlagringarna. Att skapa en ny överlagring innebär osäker kod. Den grundläggande proceduren är att stackallokera en matris med händelsedatabeskrivningar som matchar antalet nyttolastobjekt. För varje nyttolastobjekt anger du rätt storlek och värde i händelsedatamatrisen. Anropa WriteEventCore med den initierade matrisen.

I följande exempel visas hur du lägger till en WriteEvent överlagring som accepterar fyra argument. Ett exempel skulle vara om du har en loggningshändelse som loggar en sträng och tre heltal.

[Event(1)]
public void LogTime(string tag, int hour, int minute, int second)
{
    WriteEvent(1, tag, hour, minute, second);
}

Du kan göra detta utan att anropa WriteEventCore, men det skulle vara långsammare än det behöver vara. Det beror på att den använder matriser och reflektion för att ta reda på vad du ska göra. Om du loggar dessa med hög hastighet (> 1 000 /sek) kan det vara värt att göra en snabb hjälp, som du ser i följande exempel. Metoden skuggar den befintliga WriteEvent. Den ursprungliga nummerpresentationskoden (LogTime) ändras alltså inte, men C#-kompilatorn använder den mer specialiserade versionen som går snabbare.

Om du vill kompilera osäker kod måste du ange kompilatoralternativet /unsafe (C# Compiler Options).

class AnotherEventSource : EventSource {

    [NonEvent]
    public unsafe void WriteEvent(int eventId, string arg1, int arg2, int arg3, int arg4)
    {

        fixed (char* arg1Ptr = arg1)
        {
            EventData* dataDesc = stackalloc EventData[4];

            dataDesc[0].DataPointer = (IntPtr)arg1Ptr;
            dataDesc[0].Size = (arg1.Length + 1) * 2; // Size in bytes, including a null terminator.
            dataDesc[1].DataPointer = (IntPtr)(&arg2);
            dataDesc[1].Size = 4;
            dataDesc[2].DataPointer = (IntPtr)(&arg3);
            dataDesc[2].Size = 4;
            dataDesc[3].DataPointer = (IntPtr)(&arg4);
            dataDesc[3].Size = 4;

            WriteEventCore(eventId, 4, dataDesc);
        }
    }
}

Det här är de förväntade storlekarna och datakodningarna för standard serialiserbara typer:

// bool arg
int temp = arg ? 1 : 0;
desc.DataPointer = (IntPtr)(&temp);
desc.Size = 4;

// byte arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 1;

// sbyte arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 1;

// char arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 2;

// short arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 2;

// ushort arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 2;

// int arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 4;

// uint arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 4;

// long arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 8;

// ulong arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 8;

// float arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 4;

// double arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 8;

// decimal arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 16;

// Guid arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = 16;

// IntPtr arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = IntPtr.Size;

// UIntPtr arg
desc.DataPointer = (IntPtr)(&arg);
desc.Size = UIntPtr.Size;

// DateTime arg
long fileTime = arg.ToUniversalTime() > new DateTime(1601, 1, 1) ? arg.ToFileTimeUtc() : 0;
desc.DataPointer = (IntPtr)(&fileTime);
desc.Size = 8;

// string arg
fixed(char* ptr = arg)
{
    desc.DataPointer = (IntPtr)ptr;
    // strings use 2 byte per char UTF16 encoding and a null terminator at the end
    // only strings without embedded null characters are supported
    desc.Size = (arg.Length + 1) * 2;
}

// byte[] arg
// This one is encoded using two adjacent EventData elements.
fixed(byte* ptr = arg)
{
    int length = arg.Length;
    desc[i].DataPointer = (IntPtr)(&length);
    desc[i].Size = 4;
    desc[i + 1].DataPointer = (IntPtr)ptr;
    desc[i + 1].Size = arg.Length;
}

// enums should be converted to their underlying type and then serialized
// as byte, short, or int.

Gäller för