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

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)]
[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")]
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)>]
[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("EventSource will serialize the whole object graph. Trimmer will not safely handle this case because properties may be trimmed. This can be suppressed if the object is a primitive type")>]
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

Parameters

Kenmerken

CLSCompliantAttribute SecurityCriticalAttribute RequiresUnreferencedCodeAttribute

Opmerkingen

eventid moet groter zijn dan 0 of kleiner dan 65535 of fouten kunnen optreden in de bewerking. Als er fouten optreden, kunt u meer informatie krijgen over de bron van de fout door de uitvoerstroom van het foutopsporingsprogramma te controleren als er een foutopsporingsprogramma is gekoppeld aan de gebeurtenissen voor het activeren van processen. U kunt ook zoeken naar fouten die zijn gerapporteerd in de ETW-gebeurtenisstroom als u een ETW-listener hebt op de gebeurtenisbron waar de fout optreedt.

Met deze beveiligde methode kunnen gebruikers nieuwe WriteEvent overbelastingen definiëren die sneller zijn dan de opgegeven overbelastingen. Het maken van een nieuwe overbelasting omvat onveilige code. De basisprocedure is het stapelen van een matrix met gebeurtenisgegevensdescriptors die overeenkomen met het aantal nettoladingitems. Stel voor elk nettoladingitem de juiste grootte en waarde in de matrix met gebeurtenisgegevens in. Aanroepen WriteEventCore met de geïnitialiseerde matrix.

In het volgende voorbeeld ziet u hoe u een WriteEvent overbelasting toevoegt die vier argumenten accepteert. Een voorbeeld hiervan is als u een logboekregistratie-gebeurtenis hebt die een tekenreeks en drie gehele getallen registreert.

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

U kunt dit doen zonder te bellen WriteEventCore, maar het zou langzamer zijn dan nodig is. Dat komt doordat het matrices en reflectie gebruikt om erachter te komen wat u moet doen. Als u deze met een hoge snelheid (> 1000 per seconde) aanmeldt, kan het de moeite waard zijn om een snelle helper te maken, zoals wordt weergegeven in het volgende voorbeeld. De methode schaduwt de bestaande WriteEvent. De oorspronkelijke aanroepercode (LogTime) wordt dus niet daadwerkelijk gewijzigd, maar de C#-compiler gebruikt de meer gespecialiseerde versie die sneller zal zijn.

Als u onveilige code wilt compileren, moet u de compileroptie /onveilig (C#-compileropties) opgeven.

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

Dit zijn de verwachte grootten en gegevenscoderingen voor standaard serialiseerbare typen:

// 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.