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

Definisi

Ruang nama:

System.Diagnostics.Tracing

Rakitan:

System.Diagnostics.Tracing.dll

Sumber:

EventSource.cs

Penting

API ini bukan kompatibel CLS.

Membuat kelebihan beban baru WriteEvent dengan menggunakan pengidentifikasi peristiwa dan data peristiwa yang disediakan.

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)>]
member this.WriteEventCore : int * int * nativeptr<System.Diagnostics.Tracing.EventSource.EventData> -> unit

Parameter

eventId

Int32

Pengidentifikasi peristiwa.

eventDataCount

Int32

Jumlah item data peristiwa.

data

EventSource.EventData

Struktur yang berisi data peristiwa.

Atribut

CLSCompliantAttribute

Keterangan

eventid harus lebih besar dari 0 atau kurang dari 65535 atau kesalahan dapat terjadi dalam operasi. Jika kesalahan terjadi, Anda bisa mendapatkan informasi lebih lanjut tentang sumber kesalahan dengan memeriksa aliran output debugger, jika Anda memiliki debugger yang melekat pada proses menembakkan peristiwa. Anda juga dapat mencari kesalahan yang dilaporkan dalam aliran peristiwa ETW, jika Anda memiliki pendengar ETW di sumber peristiwa tempat kesalahan terjadi.

Metode yang dilindungi ini memungkinkan pengguna untuk menentukan kelebihan beban baru WriteEvent yang lebih cepat daripada kelebihan beban yang disediakan. Membuat kelebihan beban baru melibatkan kode yang tidak aman. Prosedur dasarnya adalah mengalokasikan array deskriptor data peristiwa yang cocok dengan jumlah item payload. Untuk setiap item payload, atur ukuran dan nilai yang benar dalam array data peristiwa. Panggil WriteEventCore dengan array yang diinisialisasi.

Contoh berikut menunjukkan cara menambahkan WriteEvent kelebihan beban yang menerima empat argumen. Contohnya adalah jika Anda memiliki peristiwa pengelogan yang mencatat string dan 3 bilangan bulat.

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

Anda dapat melakukan ini tanpa memanggil WriteEventCore, tetapi akan lebih lambat dari yang diperlukan. Itu karena menggunakan array dan refleksi untuk mencari tahu apa yang harus dilakukan. Jika Anda mencatat ini pada tingkat tinggi (> 1000 / detik), ada baiknya membuat pembantu yang cepat, seperti yang ditunjukkan dalam contoh berikut. Metode membayangi yang ada WriteEvent. Dengan demikian kode pemanggil asli (LogTime) tidak benar-benar berubah, tetapi pengkompilasi C# akan menggunakan versi yang lebih khusus yang akan lebih cepat.

Untuk mengkompilasi kode yang tidak aman, Anda harus menentukan opsi pengkompilasi /unsafe (Opsi Pengkompilasi C#).

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

Ini adalah ukuran dan pengodean data yang diharapkan untuk jenis serialisasi standar:

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