Macro Wrapper traceLogging

Le macro TraceLoggingWrite e TraceLoggingWriteActivity generano eventi TraceLogging configurati in base ai parametri della macro. Ognuna di queste macro accetta un set di parametri obbligatori seguiti da un massimo di 99 parametri facoltativi. Ogni parametro facoltativo configura l'evento o aggiunge un campo all'evento. Ogni parametro facoltativo deve essere una delle macro TraceLogging Wrapper descritte in questa pagina.

Ad esempio:

TraceLoggingWrite(
    g_hProvider,
    "MyEvent1",
    TraceLoggingLevel(WINEVENT_LEVEL_WARNING), // Levels defined in <winmeta.h>
    TraceLoggingKeyword(MyNetworkingKeyword),
    TraceLoggingString(operationName), // Adds an "operationName" field.
    TraceLoggingHResult(hr, "NetStatus")); // Adds a "NetStatus" field.

In questo esempio g_hProvider e "MyEvent1" sono i parametri necessari. Specificano il provider da usare per l'evento e il nome dell'evento. Ognuno dei parametri rimanenti è una macro wrapper. I TraceLoggingLevel parametri e TraceLoggingKeyword configurano l'evento. I TraceLoggingString parametri e TraceLoggingHResult aggiungono campi all'evento.

Macro di configurazione eventi

Le macro seguenti configurano l'evento.

Se una determinata macro di configurazione non viene fornita nella tracciaLoggingWrite, viene utilizzata un'impostazione predefinita per tale evento. Ad esempio, se non viene usato alcun parametro TraceLoggingLevel per un evento, l'evento usa un livello predefinito di 5 (VERBOSE).

  • TraceLoggingLevel imposta il livello dell'evento. Il livello è un valore a 8 bit che indica la gravità degli eventi. I livelli da 1 (WINEVENT_LEVEL_CRITICAL) a 5 (WINEVENT_LEVEL_VERBOSE) sono definiti in <winmeta.h>. Se non specificato, l'evento viene predefinito a livello 5 (VERBOSE). Il livello è una parte importante del routing degli eventi ETW e del filtro, quindi tutti gli eventi devono avere un livello non zero significativo.
  • TraceLoggingKeyword imposta la parola chiave dell'evento. Una parola chiave è un valore a 64 bit con ogni bit che indica una categoria a cui appartiene l'evento. I 48 bit bassi della parola chiave sono definiti dal proprietario del provider, mentre i 16 bit elevati della parola chiave sono definiti da Microsoft. Ad esempio, è possibile decidere che tutti i provider con il nome "MyCompany.MyComponent" useranno la parola chiave 0x1 per indicare "Rete". Se non specificato, l'evento viene predefinito per la parola chiave 0x0 (Nessuno). La parola chiave è una parte importante del routing degli eventi ETW e del filtro, pertanto tutti gli eventi devono avere una parola chiave non zero significativa.
  • TraceLoggingOpcode imposta il codice opcode dell'evento. Il codice opcode è un valore a 8 bit che indica una semantica speciale per l'evento, ad esempio che l'evento registra l'inizio (WINEVENT_OPCODE_START) o la fine (WINEVENT_OPCODE_STOP) di un'attività ETW (un gruppo di eventi correlati). Se non specificato, l'evento viene predefinito per opcode 0 (WINEVENT_OPCODE_INFO) che indica che non è necessaria alcuna semantica speciale.
  • TraceLoggingChannel imposta il canale dell'evento. Il canale è un valore a 8 bit usato per vari scopi. Se non specificato, l'evento viene predefinito per il canale 11 (WINEVENT_CHANNEL_TRACELOGGING). La maggior parte degli eventi non deve modificare il canale dell'evento e non deve usare TraceLoggingChannel.
  • TraceLoggingEventTag imposta il tag dell'evento. Il tag è un valore a 28 bit con semantica definita dal provider. Ad esempio, un provider potrebbe definire bit di tag 0x1000000 per indicare che l'evento contiene potenzialmente informazioni personali e deve ricevere un trattamento speciale da strumenti di elaborazione eventi specifici del provider. Se non specificato, il tag viene predefinito su 0.
  • TraceLoggingDescription imposta la descrizione dell'evento. La descrizione è un valore letterale stringa con una descrizione leggibile dell'evento. Ciò funge da commento sullo scopo dell'evento e la descrizione viene registrata anche come annotazione nei simboli di debug del componente (PDB). Se non specificato, la descrizione viene predefinita su "".
  • TraceLoggingCustomAttribute aggiunge un'annotazione chiave-valore ai simboli di debug del componente (PDB).

Macro di campo

TraceLogging supporta molte macro wrapper per l'aggiunta di campi a un evento. Ogni campo è una coppia nome-valore. Ad esempio, TraceLoggingInt32(argc, "ArgCount") aggiungere un campo INT32 denominato "ArgCount" con valore argc.

La maggior parte delle macro wrapper dei campi accetta parametri simili:

  • Valore: Espressione che verrà valutata in fase di esecuzione per determinare i dati da includere nel campo. La maggior parte delle macro del wrapper campo usa un singolo parametro per specificare il valore, ma alcune macro richiedono più parametri per il valore del campo, ad esempio un puntatore e una lunghezza. I parametri dei valori sono sempre necessari.
    • In alcuni casi, il valore del campo viene specificato come pszValue, nel qual caso si tratta di un puntatore a una stringa con terminazione 0 di caratteri da includere nel campo. pszValue può essere NULL, nel qual caso il valore del campo sarà una stringa ""vuota.
    • In alcuni casi, il valore del campo viene specificato come pchValue, nel qual caso è un puntatore a una stringa di caratteri cchValue da includere nel campo. pchValue può essere NULL solo se cchValue è 0.
    • In alcuni casi, il valore del campo viene specificato come pValue con una dimensione determinata automaticamente (nessun parametro cbValue ), nel qual caso è un puntatore al valore da includere nel campo. pValue potrebbe non essere NULL.
    • In alcuni casi, il valore del campo viene specificato come pValue con un parametro cbValue per specificare le dimensioni (in byte) dei dati da includere nel campo. pValue può essere NULL solo se cbValue è 0.
  • Nome: Valore letterale stringa (costante compilazione-tempo) con il nome da usare per il campo. La maggior parte delle macro del wrapper dei campi non richiede un parametro nome. Se si omette il parametro nome, il nome del campo viene determinato in base al testo del preprocessore del valore della macro, pszValue, pchValue o pValue . Ad esempio, TraceLoggingInt32(x[4] + y) equivale a TraceLoggingInt32(x[4] + y, "x[4] + y"). Entrambi aggiungerebbero un campo denominato "x[4] + y" all'evento con un valore determinato valutando l'espressione x[4] + y.
  • Descrizione: Valore letterale stringa (costante compilazione-tempo) con una descrizione da usare per il campo. Ciò viene usato principalmente come luogo pratico per inserire un commento per il campo, ma la descrizione viene registrata anche come annotazione nei simboli di debug del componente (PDB). La descrizione è facoltativa. Se il parametro di descrizione viene omesso, la descrizione del campo viene predefinita su "".
  • tag: Intero a 28 bit (costante di compilazione) con semantica definita dal provider. Ad esempio, un provider potrebbe definire tag 0x2 per indicare che il campo contiene un numero di telefono e deve ricevere un trattamento speciale da strumenti di elaborazione eventi specifici del provider. Se il parametro tag viene omesso, il tag del campo viene predefinito su 0.

Ad esempio, le chiamate macro wrapper seguenti hanno lo stesso effetto:

  • TraceLoggingInt32(argc)
  • TraceLoggingInt32(argc, "argc")
  • TraceLoggingInt32(argc, "argc", "")
  • TraceLoggingInt32(argc, "argc", "", 0)

Scalari

  • TraceLoggingValue(value, [name, ...]):

    Aggiunge un campo con un tipo dedotto automaticamente dal tipo del parametro value. (solo C++)

  • TraceLoggingInt8(value, [name, ...]):

    Aggiunge un campo con un valore INT8.

  • TraceLoggingUInt8(value, [name, ...]):

    Aggiunge un campo con un valore UINT8.

  • TraceLoggingInt16(value, [name, ...]):

    Aggiunge un campo con un valore INT16.

  • TraceLoggingUInt16(value, [name, ...]):

    Aggiunge un campo con un valore UINT16.

  • TraceLoggingInt32(value, [name, ...]):

    Aggiunge un campo con un valore INT32.

  • TraceLoggingUInt32(value, [name, ...]):

    Aggiunge un campo con un valore UINT32.

  • TraceLoggingInt64(value, [name, ...]):

    Aggiunge un campo con un valore INT64.

  • TraceLoggingUInt64(value, [name, ...]):

    Aggiunge un campo con un valore UINT64.

  • TraceLoggingIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore INT_PTR (intero con segno con le stesse dimensioni di un puntatore).

  • TraceLoggingUIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore UINT_PTR (intero senza segno con le stesse dimensioni di un puntatore).

  • TraceLoggingLong(value, [name, ...]):

    Aggiunge un campo con un valore LONG (con segno long int, 32 bit nelle piattaforme Windows).

  • TraceLoggingULong(value, [name, ...]):

    Aggiunge un campo con un valore ULONG (unsigned long int, 32 bit nelle piattaforme Windows).

  • TraceLoggingHexInt8(value, [name, ...]):

    Aggiunge un campo con un valore INT8 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt8(value, [name, ...]):

    Aggiunge un campo con un valore UINT8 con un hint di formattazione esadecimale.

  • TraceLoggingHexInt16(value, [name, ...]):

    Aggiunge un campo con un valore INT16 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt16(value, [name, ...]):

    Aggiunge un campo con un valore UINT16 con un hint di formattazione esadecimale.

  • TraceLoggingHexInt32(value, [name, ...]):

    Aggiunge un campo con un valore INT32 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt32(value, [name, ...]):

    Aggiunge un campo con un valore UINT32 con un hint di formattazione esadecimale.

  • TraceLoggingHexInt64(value, [name, ...]):

    Aggiunge un campo con un valore INT64 con un hint di formattazione esadecimale.

  • TraceLoggingHexUInt64(value, [name, ...]):

    Aggiunge un campo con un valore UINT64 con un hint di formattazione esadecimale.

  • TraceLoggingHexIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore INT_PTR con un hint di formattazione esadecimale.

  • TraceLoggingHexUIntPtr(value, [name, ...]):

    Aggiunge un campo con un valore UINT_PTR con un hint di formattazione esadecimale.

  • TraceLoggingHexLong(value, [name, ...]):

    Aggiunge un campo con un valore LONG con un hint di formattazione esadecimale.

  • TraceLoggingHexULong(value, [name, ...]):

    Aggiunge un campo con un valore ULONG con un hint di formattazione esadecimale.

  • TraceLoggingFloat32(value, [name, ...]):

    Aggiunge un campo con un valore FLOAT (a 32 bit a virgola mobile).

  • TraceLoggingFloat64(value, [name, ...]):

    Aggiunge un campo con un valore DOUBLE (a 64 bit a virgola mobile).

  • TraceLoggingBoolean(value, [name, ...]):

    Aggiunge un campo con un valore booleano a 8 bit (Win32 BOOLEAN o C++ bool).

  • TraceLoggingBool(value, [name, ...]):

    Aggiunge un campo con un valore booleano a 32 bit (Win32 BOOL).

  • TraceLoggingChar(value, [name, ...]):

    Aggiunge un campo con un char valore (intero a 8 bit con hint di formattazione stringa, in genere considerato come tabella codici 1252).

  • TraceLoggingChar16(value, [name, ...]):

    Aggiunge un campo con un char16_t valore (intero a 16 bit con hint di formattazione stringa, in genere considerato come UCS-2).

  • TraceLoggingWChar(value, [name, ...]):

    Aggiunge un campo con un wchar_t valore (uguale alle char16_t piattaforme Windows).

  • TraceLoggingPointer(value, [name, ...]):

    Aggiunge un campo con un void* valore (valore di dimensioni puntatore con un hint di formattazione esadecimale).

  • TraceLoggingCodePointer(value, [name, ...]):

    Aggiunge un campo con un valore (valore di dimensioni puntatore con un void* hint di formattazione del puntatore del codice).

  • TraceLoggingPid(value, [name, ...]):

    Aggiunge un campo con un valore INT32 con un hint di formattazione ID processo.

  • TraceLoggingTid(value, [name, ...]):

    Aggiunge un campo con un valore INT32 con un hint di formattazione ID thread.

  • TraceLoggingIPv4Address(value, [name, ...]):

    Aggiunge un campo con un valore UINT32 con un hint di formattazione IPv4 (ordine di byte di rete).

  • TraceLoggingIPv6Address(pValue, [name, ...]):

    Aggiunge un campo con un valore binario a 16 byte con un hint di formattazione IPv6.

  • TraceLoggingPort(value, [name, ...]):

    Aggiunge un campo con un valore UINT16 con un hint di formattazione della porta IP (ordine di byte di rete).

  • TraceLoggingSocketAddress(pValue, cbValue, [name, ...]):

    Aggiunge un campo con un valore SOCKADDR .

  • TraceLoggingWinError(value, [name, ...]):

    Aggiunge un campo con un valore UINT32 con un hint di formattazione del codice di errore Win32.

  • TraceLoggingNTStatus(value, [name, ...]):

    Aggiunge un campo con un valore NTSTATUS (LONG) con un hint di formattazione del codice di errore WinNT.

  • TraceLoggingHResult(value, [name, ...]):

    Aggiunge un campo con un valore HRESULT (LONG) con un hint di formattazione HRESULT di Windows.

  • TraceLoggingFileTime(value, [name, ...]):

    Aggiunge un campo con un valore FILETIME . Se usato nel codice C, il parametro deve essere un'espressione value lvalue.

  • TraceLoggingFileTimeUtc(value, [name, ...]):

    Aggiunge un campo con un valore FILETIME con un hint di formattazione del fuso orario UTC. Se usato nel codice C, il parametro deve essere un'espressione value lvalue.

  • TraceLoggingSystemTime(value, [name, ...]):

    Aggiunge un campo con un valore SYSTEMTIME . Se usato nel codice C, il parametro deve essere un'espressione value lvalue.

  • TraceLoggingSystemTimeUtc(value, [name, ...]):

    Aggiunge un campo con un valore SYSTEMTIME con un hint di formattazione del fuso orario UTC. Se usato nel codice C, il parametro deve essere un'espressione value lvalue.

  • TraceLoggingGuid(value, [name, ...]):

    Aggiunge un campo con un valore GUID . Se usato nel codice C, il parametro deve essere un'espressione value lvalue.

  • TraceLoggingString(pszValue, [name, ...]):

    Aggiunge un campo con una stringa con terminazione char 0 (in genere considerata come tabella codici 1252). Se pszValue è NULL, viene usata una stringa "" vuota come valore del campo.

  • TraceLoggingUtf8String(pszValue, [name, ...]):

    Aggiunge un campo con una stringa con terminazione char 0 con un hint di formattazione UTF-8. Se pszValue è NULL, viene usata una stringa "" vuota come valore del campo.

  • TraceLoggingString16(pszValue, [name, ...]):

    Aggiunge un campo con una stringa con terminazione char16_t 0 (UTF-16). Se pszValue è NULL, viene usata una stringa u"" vuota come valore del campo.

  • TraceLoggingWideString(pszValue, [name, ...]):

    Aggiunge un campo con una stringa con terminazione wchar_t 0 (UTF-16 in Windows). Se pszValue è NULL, viene usata una stringa L"" vuota come valore del campo.

  • TraceLoggingCountedString(pchValue, cchValue, [name, ...]):

    Aggiunge un campo con una stringa conteggiata char (in genere considerata come tabella codici 1252). pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingCountedUtf8String(pchValue, cchValue, [name, description, tag]):

    Aggiunge un campo con una stringa conteggiata char con un hint di formattazione UTF-8. pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingCountedString16(pchValue, cchValue, [name, ...]):

    Aggiunge un campo con una stringa conteggiata char16_t (UTF-16). pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingCountedWideString(pchValue, cchValue, [name, description, tag]):

    Aggiunge un campo con una stringa conteggiata wchar_t (UTF-16 in Windows). pchValue può essere NULL solo se cchValue è 0.

  • TraceLoggingAnsiString(pValue, [name, ...]):

    Aggiunge un campo con un valore ANSI_STRING . Il puntatore pValue non deve essere NULL.

  • TraceLoggingUnicodeString(pValue, [name, ...]):

    Aggiunge un campo con un valore UNICODE_STRING . Il puntatore pValue non deve essere NULL.

  • TraceLoggingSid(pValue, [name, ...]):

    Aggiunge un campo con un valore SID . Il puntatore pValue non deve essere NULL e deve puntare a un SID correttamente inizializzato (revisione e SubAuthorityCount deve essere valido).

  • TraceLoggingBinary(pValue, cbValue, [name, ...]):

    Aggiunge un campo con dati binari.

  • TraceLoggingBinaryEx(pValue, cbValue, outType, [name, ...]):

    Aggiunge un campo con dati binari con l'hint di formattazione specificato da outType.

  • TraceLoggingBinaryBuffer(pValue, StructType, [name, ...]):

    Aggiunge un campo con dati binari. pValue deve essere un puntatore non NULL a uno StructType struct. pValue->Buffer deve puntare all'inizio dei dati e pValue->Length deve essere il numero di byte di dati da includere nel campo.

  • TraceLoggingBinaryBufferEx(pValue, StructType, outType, name, description, tag):

    Aggiunge un campo con dati binari con l'hint di formattazione specificato da outType. pValue deve essere un puntatore non NULL a uno StructType struct. pValue->Buffer deve puntare all'inizio dei dati e pValue->Length deve essere il numero di byte di dati da includere nel campo.

  • TraceLoggingCustom(pValue, cbValue, protocol, bSchema, cbSchema, [name, ...]):

    Aggiunge un campo con dati binari serializzati in base a un protocollo di serializzazione. Le informazioni di decodifica costante in fase di compilazione verranno incluse insieme all'evento per consentire la deserializzazione dal decodificatore eventi.

Strutture

È possibile usare la macro TraceLoggingStruct(fieldCount, name, [...]) per creare una struttura denominata (gruppo di campi). Il parametro fieldCount indica quanti dei campi successivi devono essere conteggiati come parte della struttura. Le strutture possono essere annidate, in tal caso ogni struttura nidificata e i relativi campi contenuti vengono conteggiati come un singolo campo allo scopo di definire lo struct padre.

Matrici

È possibile creare un campo contenente una matrice di valori scalari (singolo). Ad esempio, si aggiunge una matrice di GUID come singolo campo nell'evento.

Nota

Mentre il protocollo TraceLogging supporta matrici di tutti i tipi, TraceLoggingProvider.h fornisce solo macro wrapper per matrici di valori semplici, ad esempio fornisce macro per matrici di INT32 e GUID, ma non fornisce macro per le matrici di stringhe o matrici di strutture. È possibile creare eventi con matrici di valori complessi eseguendo il marshalling dei dati in un buffer e quindi usando le TraceLoggingPacked macro descritte di seguito.

TraceLogging supporta matrici a lunghezza fissa e a lunghezza variabile.

  • Usare la macro nei casi in cui la lunghezza della Array matrice non è nota in fase di compilazione e può essere diversa ogni volta che viene generato l'evento.
  • Usare la macro nei casi in cui la lunghezza della FixedArray matrice è nota in fase di compilazione (ad esempio quando la lunghezza della matrice è una costante). Questo comunica al consumer di eventi che tutti gli eventi con un determinato nome evento avranno lo stesso numero di elementi nel campo matrice.

Tutte le macro della matrice richiedono che siano specificati i parametri pValues e cValues , con pValues che punta all'inizio del contenuto della matrice e cValues impostato sul numero di elementi nella matrice. pValues può essere NULL solo se cValues è 0.

Tutte le macro della matrice accettano facoltativamente i parametri nome, descrizione e tag , come descritto per le macro scalari. Se il nome non è specificato, il nome del campo viene determinato dal testo del preprocessore di pValues. Se la descrizione non è specificata, la descrizione del campo sarà "". Se il tag non è specificato, il tag di campo sarà 0.

Nota

Per assicurarsi che ETW non elimina gli eventi, evitare di creare eventi con matrici di grandi dimensioni. ETW non supporta eventi di dimensioni superiori a 64 KB. Qualsiasi evento di questo tipo verrà eliminato in modo silenzioso da ETW. Inoltre, gli eventi più grandi rispetto a BufferSize della sessione consumer verranno eliminati anche da ETW. La dimensione dell'evento è basata sulla somma delle intestazioni dell'evento, dei metadati (provider, evento e nomi di campo) e dei dati (valori di campo).

  • TraceLoggingInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingUInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingUIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingUIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingLongArray(pValues, cValues, [name, ...])
  • TraceLoggingLongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingULongArray(pValues, cValues, [name, ...])
  • TraceLoggingULongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt8Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt8FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt16Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt32Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingHexInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt64Array(pValues, cValues, [name, ...])
  • TraceLoggingHexUInt64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingHexIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUIntPtrArray(pValues, cValues, [name, ...])
  • TraceLoggingHexUIntPtrFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexLongArray(pValues, cValues, [name, ...])
  • TraceLoggingHexLongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingHexULongArray(pValues, cValues, [name, ...])
  • TraceLoggingHexULongFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFloat32Array(pValues, cValues, [name, ...])
  • TraceLoggingFloat32FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFloat64Array(pValues, cValues, [name, ...])
  • TraceLoggingFloat64FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingBooleanArray(pValues, cValues, [name, ...])
  • TraceLoggingBooleanFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingBoolArray(pValues, cValues, [name, ...])
  • TraceLoggingBoolFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingCharArray(pValues, cValues, [name, ...])
  • TraceLoggingCharFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingChar16Array(pValues, cValues, [name, ...])
  • TraceLoggingChar16FixedArray(pValues, cValues, [name, ...])
  • TraceLoggingWCharArray(pValues, cValues, [name, ...])
  • TraceLoggingWCharFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingPointerArray(pValues, cValues, [name, ...])
  • TraceLoggingPointerFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingCodePointerArray(pValues, cValues, [name, ...])
  • TraceLoggingCodePointerFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeUtcArray(pValues, cValues, [name, ...])
  • TraceLoggingFileTimeUtcFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeUtcArray(pValues, cValues, [name, ...])
  • TraceLoggingSystemTimeUtcFixedArray(pValues, cValues, [name, ...])
  • TraceLoggingGuidArray(pValues, cValues, [name, ...])
  • TraceLoggingGuidFixedArray(pValues, cValues, [name, ...])

Macro confezionate

TraceLoggingProvider.h fornisce solo macro di campo per i tipi di campo blittable, ovvero campi in cui ogni macro di campo corrisponde a un singolo campo e una singola area contigua di memoria con il valore del campo.

TraceLoggingProvider.h non fornisce supporto diretto per casi più complessi, ad esempio:

  • Registrazione di una matrice di tipo a lunghezza variabile, ad esempio una matrice di stringhe.
  • Registrazione di una matrice di strutture.
  • Passando più campi a ETW tramite un singolo buffer per ridurre il sovraccarico della registrazione eventi.

Per supportare questi scenari, TraceLoggingProvider.h definisce diverse TraceLoggingPacked macro che consentono di modificare direttamente la definizione dell'evento (metadati) e i valori di campo (dati) dell'evento.

Avviso

Le TraceLoggingPacked macro sono difficili da usare correttamente e richiedono una buona comprensione del modo in cui vengono creati gli eventi TraceLogging. Se usato in modo errato, genera eventi danneggiati che non decodificano correttamente.

Per informazioni dettagliate sull'uso di queste macro, vedere i commenti nell'intestazione TraceLoggingProvider.h.

  • TraceLoggingPackedField(pValue, cbValue, inType, [name, description, tags]):

    Aggiunge i dati dei campi (pValue, cbValue) e i metadati dei campi (nome, inType).

  • TraceLoggingPackedFieldEx(pValue, cbValue, inType, outType, [name, ...]):

    Aggiunge dati di campo (pValue, cbValue) e metadati di campo (nome, inType) insieme a un hint di formattazione (outType).

  • TraceLoggingPackedMetadata(inType, [name, ...]):

    Aggiunge metadati di campo (nome, inType) senza aggiungere dati di campo. I dati dei campi corrispondenti devono essere aggiunti tramite TraceLoggingPackedData.

  • TraceLoggingPackedMetadataEx(inType, outType, [name, ...]):

    Aggiunge metadati di campo (nome, inType) e un hint di formattazione (outType) senza aggiungere dati di campo. I dati dei campi corrispondenti devono essere aggiunti tramite TraceLoggingPackedData.

  • TraceLoggingPackedStruct(fieldCount, name, [...]):

    Aggiunge metadati di campo (nome, fieldCount) per uno struct.

  • TraceLoggingPackedStructArray(fieldCount, [name, ...]):

    Aggiunge metadati di campo (nome, fieldCount) per una matrice a lunghezza variabile di struct. La lunghezza della matrice deve essere specificata tramite TraceLoggingPackedData.

  • TraceLoggingPackedData(pValue, cbValue):

    Aggiunge i dati del campo a un evento senza aggiungere metadati di campo. I metadati corrispondenti devono essere aggiunti tramite le macro Metadati.

  • TraceLoggingPackedDataEx(pValue, cbValue, dataDescType):

    Aggiunge i dati del campo a un evento senza aggiungere metadati di campo, usando uno specifico Typenell'EVENT_DATA_DESCRIPTOR per i dati. I metadati corrispondenti devono essere aggiunti tramite le macro Metadati.