Omslutningsmakron för spårningsloggning

TraceLoggingWrite och TraceLoggingWriteActivity makron genererar TraceLogging-händelser som konfigurerats enligt makroparametrarna. Var och en av dessa makron accepterar en uppsättning obligatoriska parametrar följt av upp till 99 valfria parametrar. Varje valfri parameter konfigurerar antingen händelsen eller lägger till ett fält i händelsen. Varje valfri parameter måste vara ett av de tracelogging wrapper-makron som beskrivs på den här sidan.

Till exempel:

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.

I det här exemplet är g_hProvider och "MyEvent1" de obligatoriska parametrarna. De anger vilken provider som ska användas för händelsen och händelsens namn. Var och en av de återstående parametrarna är ett omslutningsmakron. Parametrarna TraceLoggingLevel och TraceLoggingKeyword konfigurerar händelsen. Parametrarna TraceLoggingString och TraceLoggingHResult lägger till fält i händelsen.

Händelsekonfigurationsmakron

Följande makron konfigurerar händelsen.

Om ett visst konfigurationsmakro inte anges i TraceLoggingWriteanvänds standardvärdet för den händelsen. Om till exempel ingen TraceLoggingLevel- parameter används för en händelse använder händelsen standardnivån 5 (VERBOSE).

• TraceLoggingLevel anger händelsens nivå. Nivån är ett 8-bitarsvärde som anger händelsens allvarlighetsgrad. Nivåer från 1 (WINEVENT_LEVEL_CRITICAL) till 5 (WINEVENT_LEVEL_VERBOSE) definieras i <winmeta.h>. Om den inte anges är händelsen standardnivå 5 (VERBOSE). Nivå är en viktig del av ETW-händelsedirigering och filtrering, så alla händelser bör ha en meningsfull nivå som inte är noll.
• TraceLoggingKeyword anger händelsens nyckelord. Ett nyckelord är ett 64-bitarsvärde där varje bit anger en kategori som händelsen tillhör. De låga 48 bitarna av nyckelordet definieras av providerns ägare medan de höga 16 bitarna av nyckelordet definieras av Microsoft. Du kan till exempel bestämma att alla leverantörer med namnet "MyCompany.MyComponent" ska använda nyckelordet 0x1 som "Nätverk". Om den inte anges är händelsen som standard nyckelordet 0x0 (Ingen). Nyckelord är en viktig del av ETW-händelseroutning och -filtrering, så alla händelser bör ha ett meningsfullt nyckelord som inte är noll.
• TraceLoggingOpcode anger händelsens opcode-. Opcode är ett 8-bitarsvärde som anger särskilda semantik för händelsen, t.ex. att händelsen registrerar början (WINEVENT_OPCODE_START) eller slutet (WINEVENT_OPCODE_STOP) för en ETW-aktivitet (en grupp relaterade händelser). Om den inte anges är händelsen standard opcode 0 (WINEVENT_OPCODE_INFO) som anger att inga särskilda semantik krävs.
• TraceLoggingChannel anger händelsens kanal. Kanalen är ett 8-bitarsvärde som används för olika syften. Om den inte anges är händelsen som standard kanal 11 (WINEVENT_CHANNEL_TRACELOGGING). De flesta händelser behöver inte ändra händelsens kanal och bör inte använda TraceLoggingChannel.
• TraceLoggingEventTag anger händelsens tagg. Taggen är ett 28-bitarsvärde med providerdefinierad semantik. En provider kan till exempel definiera taggbit 0x1000000 för att indikera att händelsen potentiellt innehåller personligt identifierbar information och bör få särskild behandling från leverantörsspecifika händelsebearbetningsverktyg. Om den inte anges är taggen standard 0.
• TraceLoggingDescription anger händelsens beskrivning. Beskrivningen är en strängliteral med en läsbar beskrivning av händelsen. Detta fungerar som en kommentar om händelsesyftet och beskrivningen registreras också som en anteckning i komponentens felsökningssymboler (PDB). Om den inte anges ""beskrivningen som standard .
• TraceLoggingCustomAttribute lägger till en nyckel/värde-anteckning till komponentens felsökningssymboler (PDB).

Fältmakron

Spårningsloggning stöder många omslutningsmakron för att lägga till fält i en händelse. Varje fält är ett namn/värde-par. Till exempel skulle TraceLoggingInt32(argc, "ArgCount") lägga till ett INT32-fält med namnet "ArgCount" med värdet argc.

De flesta fältomslutningsmakronen accepterar liknande parametrar:

• värde: Ett uttryck som ska utvärderas vid körning för att fastställa vilka data som ska inkluderas i fältet. De flesta fältomslutningsmakron använder en enda parameter för att ange värdet, men vissa makron kräver flera parametrar för fältvärdet, t.ex. en pekare och en längd. Värdeparametern(er) krävs alltid.
  • I vissa fall anges fältvärdet som pszValue, i vilket fall det är en pekare till en 0-avslutad teckensträng som ska inkluderas i fältet. pszValue kan vara NULL, i vilket fall fältvärdet blir en tom sträng "".
  • I vissa fall anges fältvärdet som pchValue, i vilket fall det är en pekare till en sträng med cchValue tecken som ska inkluderas i fältet. pchValue kan bara vara NULL om cchValue är 0.
  • I vissa fall anges fältvärdet som pValue med en automatiskt bestämd storlek (ingen cbValue parameter), i vilket fall det är en pekare till värdet som ska inkluderas i fältet. pValue kanske inte är NULL.
  • I vissa fall anges fältvärdet som pValue med en cbValue- parameter för att ange storleken (i byte) på data som ska inkluderas i fältet. pValue kan bara vara NULL om cbValue är 0.
• namn: En strängliteral (kompileringskonstant) med namnet som ska användas för fältet. De flesta fältomslutningsmakron kräver ingen namnparameter. Om du utelämnar namnparametern bestäms fältets namn baserat på förprocessortexten för makrots -värde, pszValue, pchValueeller pValue parameter. Till exempel motsvarar TraceLoggingInt32(x[4] + y)TraceLoggingInt32(x[4] + y, "x[4] + y"). Båda skulle lägga till ett fält med namnet "x[4] + y" till händelsen med ett värde som bestäms genom att utvärdera uttrycket x[4] + y.
• beskrivning: En strängliteral (kompileringskonstant) med en beskrivning som ska användas för fältet. Detta används främst som en praktisk plats för att lägga till en kommentar för fältet, men beskrivningen registreras också som en anteckning i komponentens felsökningssymboler (PDB). Beskrivningen är valfri. Om beskrivningsparametern utelämnas ""fältets beskrivning som standard .
• tagg: Ett 28-bitars heltal (kompileringskonstant) med providerdefinierad semantik. En leverantör kan till exempel definiera taggen 0x2 för att ange att fältet innehåller ett telefonnummer och bör få särskild behandling från leverantörsspecifika verktyg för händelsebearbetning. Om taggparametern utelämnas är fältets tagg standard 0.

Följande omslutningsmakronanrop har till exempel samma effekt:

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

Skalär

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

  Lägger till ett fält med en typ som automatiskt härleds från typen av värdeparametern. (endast C++)

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

  Lägger till ett fält med ett INT8-värde.

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

  Lägger till ett fält med ett UINT8-värde.

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

  Lägger till ett fält med ett INT16-värde.

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

  Lägger till ett fält med ett UINT16-värde.

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

  Lägger till ett fält med ett INT32-värde.

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

  Lägger till ett fält med ett UINT32-värde.

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

  Lägger till ett fält med ett INT64-värde.

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

  Lägger till ett fält med ett UINT64-värde.

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

  Lägger till ett fält med ett INT_PTR värde (signerat heltal med samma storlek som en pekare).

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

  Lägger till ett fält med ett UINT_PTR värde (osignerat heltal med samma storlek som en pekare).

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

  Lägger till ett fält med ett LONG-värde (signerat långt int, 32-bitars på Windows-plattformar).

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

  Lägger till ett fält med ett ULONG-värde (osignerad lång int, 32-bitars på Windows-plattformar).

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

  Lägger till ett fält med ett INT8-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett UINT8-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett INT16-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett UINT16-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett INT32-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett UINT32-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett INT64-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett UINT64-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett INT_PTR värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett UINT_PTR värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett LONG-värde med ett hexadecimalt formateringstips.

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

  Lägger till ett fält med ett ULONG-värde med en hexadecimal formateringstips.

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

  Lägger till ett fält med ett FLOAT-värde (32-bitars flyttal).

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

  Lägger till ett fält med värdet DOUBLE (64-bitars flyttal).

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

  Lägger till ett fält med ett 8-bitars booleskt värde (Win32 BOOLEAN eller C++ bool).

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

  Lägger till ett fält med ett 32-bitars booleskt värde (Win32 BOOL).

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

  Lägger till ett fält med ett char värde (8-bitars heltal med tips om strängformatering, som vanligtvis behandlas som kodsida 1252).

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

  Lägger till ett fält med ett char16_t värde (16-bitars heltal med tips om strängformatering, som vanligtvis behandlas som UCS-2).

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

  Lägger till ett fält med ett wchar_t värde (samma som char16_t på Windows-plattformar).

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

  Lägger till ett fält med ett void* värde (pekarstorleksvärde med ett hexadecimalt formateringstips).

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

  Lägger till ett fält med ett void* värde (värde i pekarstorlek med en kodpekarformateringstips).

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

  Lägger till ett fält med ett INT32-värde med ett formateringstips för process-ID.

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

  Lägger till ett fält med ett INT32-värde med en tråd-ID-formateringstips.

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

  Lägger till ett fält med ett UINT32-värde med en IPv4-formateringstips (nätverksbyteordning).

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

  Lägger till ett fält med ett binärt värde på 16 byte med en IPv6-formateringstips.

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

  Lägger till ett fält med ett UINT16-värde med en IP-portformateringstips (nätverksbyteordning).

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

  Lägger till ett fält med ett SOCKADDR- värde.

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

  Lägger till ett fält med ett UINT32-värde med en Win32-felkodsformateringstips.

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

  Lägger till ett fält med ett NTSTATUS-värde (LONG) med en WinNT-felkodsformateringstips.

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

  Lägger till ett fält med ett HRESULT-värde (LONG) med en Windows HRESULT-formateringstips.

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

  Lägger till ett fält med ett FILETIME- värde. När den används i C-kod måste parametern value vara ett lvalue-uttryck.

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

  Lägger till ett fält med ett FILETIME- värde med ett formateringstips för UTC-tidszon. När den används i C-kod måste parametern value vara ett lvalue-uttryck.

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

  Lägger till ett fält med ett SYSTEMTIME- värde. När den används i C-kod måste parametern value vara ett lvalue-uttryck.

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

  Lägger till ett fält med ett SYSTEMTIME--värde med ett formateringstips för UTC-tidszon. När den används i C-kod måste parametern value vara ett lvalue-uttryck.

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

  Lägger till ett fält med ett GUID- värde. När den används i C-kod måste parametern value vara ett lvalue-uttryck.

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

  Lägger till ett fält med en 0-avslutad char sträng (behandlas vanligtvis som kodsida 1252). Om pszValue är NULL används en tom sträng "" som fältvärde.

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

  Lägger till ett fält med en 0-avslutad char sträng med formateringstipset UTF-8. Om pszValue är NULL används en tom sträng "" som fältvärde.

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

  Lägger till ett fält med en 0-avslutad char16_t sträng (UTF-16). Om pszValue är NULL används en tom sträng u"" som fältvärde.

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

  Lägger till ett fält med en 0-avslutad wchar_t sträng (UTF-16 i Windows). Om pszValue är NULL används en tom sträng L"" som fältvärde.

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

  Lägger till ett fält med en räknad char sträng (behandlas vanligtvis som kodsida 1252). pchValue kan bara vara NULL om cchValue är 0.

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

  Lägger till ett fält med en räknad char sträng med en UTF-8-formateringstips. pchValue kan bara vara NULL om cchValue är 0.

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

  Lägger till ett fält med en räknad char16_t sträng (UTF-16). pchValue kan bara vara NULL om cchValue är 0.

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

  Lägger till ett fält med en räknad wchar_t sträng (UTF-16 i Windows). pchValue kan bara vara NULL om cchValue är 0.

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

  Lägger till ett fält med ett ANSI_STRING värde. PValue-pekaren får inte vara NULL.

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

  Lägger till ett fält med ett UNICODE_STRING värde. PValue-pekaren får inte vara NULL.

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

  Lägger till ett fält med ett SID- värde. PValue-pekaren får inte vara NULL och måste peka på ett korrekt initierat SID (Revision och SubAuthorityCount måste vara giltiga).

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

  Lägger till ett fält med binära data.

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

  Lägger till ett fält med binära data med formateringstipset som anges av outType.

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

  Lägger till ett fält med binära data. pValue måste vara en icke-NULL-pekare till en StructType struct. pValue->Buffer måste peka i början av data och pValue->Length måste vara antalet byte med data som ska ingå i fältet.

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

  Lägger till ett fält med binära data med formateringstipset som anges av outType. pValue måste vara en icke-NULL-pekare till en StructType struct. pValue->Buffer måste peka i början av data och pValue->Length måste vara antalet byte med data som ska ingå i fältet.

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

  Lägger till ett fält med binära data som har serialiserats enligt ett serialiseringsprotokoll. Kompilering av konstant avkodningsinformation inkluderas tillsammans med händelsen för att tillåta deserialisering av händelsedekodaren.

Strukturer

Du kan använda TraceLoggingStruct(fieldCount, name, [...]) makro för att skapa en namngiven struktur (grupp med fält). Parametern fieldCount anger hur många av de efterföljande fälten som ska räknas som en del av strukturen. Strukturer kan kapslas, i vilket fall varje kapslad struktur och dess inneslutna fält räknas som ett enda fält i syfte att definiera den överordnade strukturen.

Matriser

Du kan skapa ett fält som innehåller en matris med skalära (enkla) värden. Du kan till exempel lägga till en matris med GUID:er som ett enda fält i din händelse.

TraceLogging stöder matriser med fast längd och variabel längd.

• Använd Array makrot i fall där matrislängden inte är känd vid kompileringstid och kan vara olika varje gång händelsen genereras.
• Använd FixedArray makrot i fall där matrislängden är känd vid kompileringstid (dvs. när matrislängden är en konstant). Detta meddelar händelsekonsumenten att alla händelser med ett visst händelsenamn kommer att ha samma antal objekt i matrisfältet.

Alla matrismakron kräver att pValues och cValues parametrar anges, där pValues pekar på början av matrisinnehållet och cValues inställt på antalet objekt i matrisen. pValues kan bara vara NULL om cValues är 0.

Alla matrismakron kan också acceptera namn, beskrivningoch tagga parametrar enligt beskrivningen för Scalar-makron. Om namn inte anges, bestäms fältnamnet från förprocessortexten för pValues. Om beskrivning inte anges kommer fältbeskrivningen att "". Om tagg inte har angetts 0fälttaggen .

• 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, ...])

Packade makron

TraceLoggingProvider.h tillhandahåller endast fältmakron för blittable-fälttyper, dvs. fält där varje fältmakron motsvarar ett enda fält och en enda sammanhängande minnesregion med fältets värde.

TraceLoggingProvider.h ger inte direkt stöd för mer komplexa fall, till exempel:

• Logga en matris av en variabellängdstyp, till exempel en matris med strängar.
• Logga en matris med strukturer.
• Skicka flera fält till ETW via en enda buffert för att minska kostnaderna för händelseloggning.

För att stödja dessa scenarier definierar TraceLoggingProvider.h flera TraceLoggingPacked makron som gör att du direkt kan ändra händelsedefinitionen (metadata) och fältvärdena (data) för händelsen.

Mer information om hur du använder dessa makron finns i kommentarerna i rubriken TraceLoggingProvider.h.

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

  Lägger till fältdata (pValue, cbValue) och fältmetadata (namn, inType).

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

  Lägger till fältdata (pValue, cbValue) och fältmetadata (namn, inType) tillsammans med en formateringstips (outType).

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

  Lägger till fältmetadata (namn, inType) utan att lägga till fältdata. Motsvarande fältdata måste läggas till via TraceLoggingPackedData.

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

  Lägger till fältmetadata (namn, inType) och ett formateringstips (outType) utan att lägga till fältdata. Motsvarande fältdata måste läggas till via TraceLoggingPackedData.

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

  Lägger till fältmetadata (namn, fieldCount) för en struct.

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

  Lägger till fältmetadata (namn, fieldCount) för en matris med variabel längd av struct. Matrislängden måste anges via TraceLoggingPackedData.

• TraceLoggingPackedData(pValue, cbValue):

  Lägger till fältdata till en händelse utan att lägga till några fältmetadata. Motsvarande metadata måste läggas till via metadatamakronen.

• TraceLoggingPackedDataEx(pValue, cbValue, dataDescType):

  Lägger till fältdata till en händelse utan att lägga till några fältmetadata med hjälp av en specifik Type i EVENT_DATA_DESCRIPTOR för data. Motsvarande metadata måste läggas till via metadatamakronen.