sean-m
/
Vanara
mirror of https://github.com/dahall/Vanara.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Vanara/PInvoke/Pdh/Pdh.cs

5272 lines
263 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using Vanara.Extensions;
using Vanara.InteropServices;
using static Vanara.PInvoke.Kernel32;
using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
namespace Vanara.PInvoke
{
/// <summary>Pdh Performance Counter functions and structures.</summary>
public static partial class Pdh
{
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
public const uint PDH_CVERSION_WIN40 = 0x0400;
public const uint PDH_CVERSION_WIN50 = 0x0500;
public const int PDH_MAX_COUNTER_PATH = 2048;
// v1.1 revision of PDH -- basic log functions v1.2 of the PDH -- adds variable instance counters v1.3 of the PDH -- adds log service
// control & stubs for NT5/PDH v2 fn's v2.0 of the PDH -- is the NT v 5.0 B2 version
public const uint PDH_VERSION = PDH_CVERSION_WIN50 + 0x0003;
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
/// <summary>
/// Applications implement the <c>CounterPathCallBack</c> function to process the counter path strings returned by the <c>Browse</c>
/// dialog box.
/// </summary>
/// <param name="Arg1"/>
/// <returns>
/// <para>Return ERROR_SUCCESS if the function succeeds.</para>
/// <para>If the function fails due to a transient error, you can return PDH_RETRY and PDH will call your callback immediately.</para>
/// <para>Otherwise, return an appropriate error code. The error code is passed back to the caller of PdhBrowseCounters.</para>
/// </returns>
/// <remarks>The following members of the PDH_BROWSE_DLG_CONFIG structure are used to communicate with the callback function:</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nc-pdh-counterpathcallback CounterPathCallBack Counterpathcallback;
// PDH_STATUS Counterpathcallback( DWORD_PTR Arg1 ) {...}
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("pdh.h", MSDNShortId = "b7a2112e-9f50-4a36-b022-f9609b2827bc")]
public delegate Win32Error CounterPathCallBack(IntPtr Arg1);
/// <summary>Flags used by PDH_BROWSE_DLG_CONFIG.</summary>
[PInvokeData("pdh.h", MSDNShortId = "8e045e0b-c157-4527-902c-6096c7922642")]
[Flags]
public enum BrowseFlag
{
/// <summary>
/// If this flag is <c>TRUE</c>, the dialog box includes an index number for duplicate instance names. For example, if there are
/// two cmd instances, the instance list will contain cmd and cmd#1. If this flag is <c>FALSE</c>, duplicate instance names will
/// not contain an index number.
/// </summary>
bIncludeInstanceIndex = 1 << 0,
/// <summary>
/// If this flag is <c>TRUE</c>, the dialog returns only one counter. If this flag is <c>FALSE</c>, the dialog can return
/// multiple selections, and wildcard selections are permitted. Selected counters are returned as a MULTI_SZ string.
/// </summary>
bSingleCounterPerAdd = 1 << 1,
/// <summary>
/// If this flag is <c>TRUE</c>, the dialog box uses an OK and Cancel button. The dialog returns when the user clicks either
/// button. If this flag is <c>FALSE</c>, the dialog box uses an Add and Close button. The dialog box closes when the user clicks
/// the Close button. The Add button can be clicked multiple times. The Add button overwrites the previously selected items with
/// the currently selected items.
/// </summary>
bSingleCounterPerDialog = 1 << 2,
/// <summary>
/// If this flag is <c>TRUE</c>, the dialog box lets the user select counters only from the local computer (the path will not
/// contain a computer name). If this flag is <c>FALSE</c>, the user can specify a computer from which to select counters. The
/// computer name will prefix the counter path unless the user selects <c>Use local computer counters</c>.
/// </summary>
bLocalCountersOnly = 1 << 3,
/// <summary>
/// <para>
/// If this flag is <c>TRUE</c> and the user selects <c>All instances</c>, the counter path will include the wildcard character
/// for the instance field.
/// </para>
/// <para>
/// If this flag is <c>FALSE</c>, and the user selects <c>All instances</c>, all the instances currently found for that object
/// will be returned in a MULTI_SZ string.
/// </para>
/// </summary>
bWildCardInstances = 1 << 4,
/// <summary>
/// <para>
/// If this flag is <c>TRUE</c>, this removes <c>Detail level</c> from the dialog box so the user cannot change the detail level
/// of the counters displayed in the dialog box. The detail level will be fixed to the value of the <c>dwDefaultDetailLevel</c> member.
/// </para>
/// <para>
/// If this flag is <c>FALSE</c>, this displays <c>Detail level</c> in the dialog box, allowing the user to change the detail
/// level of the counters displayed.
/// </para>
/// <para>
/// Note that the counters displayed will be those whose detail level is less than or equal to the current detail level
/// selection. Selecting a detail level of Wizard will display all counters and objects.
/// </para>
/// </summary>
bHideDetailBox = 1 << 5,
/// <summary>
/// <para>
/// If this flag is <c>TRUE</c>, the dialog highlights the counter and object specified in <c>szReturnPathBuffer</c> when the
/// dialog box is first displayed, instead of using the default counter and object specified by the computer.
/// </para>
/// <para>
/// If this flag is <c>FALSE</c>, this selects the initial counter and object using the default counter and object information
/// returned by the computer.
/// </para>
/// </summary>
bInitializePath = 1 << 6,
/// <summary>
/// <para>If this flag is <c>TRUE</c>, the user cannot select a computer from <c>Select counters from computer</c>.</para>
/// <para>
/// If this flag is <c>FALSE</c>, the user can select a computer from <c>Select counters from computer</c>. This is the default
/// value. The list contains the local computer only unless you call the PdhConnectMachine to connect to other computers first.
/// </para>
/// </summary>
bDisableMachineSelection = 1 << 7,
/// <summary>
/// <para>
/// If this flag is <c>TRUE</c>, the counters list will also contain costly data—that is, data that requires a relatively large
/// amount of processor time or memory overhead to collect.
/// </para>
/// <para>If this flag is <c>FALSE</c>, the list will not contain costly counters. This is the default value.</para>
/// </summary>
bIncludeCostlyObjects = 1 << 8,
/// <summary>
/// If this flag is <c>TRUE</c>, the dialog lists only performance objects. When the user selects an object, the dialog returns a
/// counter path that includes the object and wildcard characters for the instance name and counter if the object is a multiple
/// instance object. For example, if the "Process" object is selected, the dialog returns the string "\Process(*)*". If the
/// object is a single instance object, the path contains a wildcard character for counter only. For example, "\System*". You can
/// then pass the path to PdhExpandWildCardPath to retrieve a list of actual paths for the object.
/// </summary>
bShowObjectBrowser = 1 << 9,
}
/// <summary>Performance counter type.</summary>
[Flags]
public enum CounterType : uint
{
/// <summary>A number (not a counter)</summary>
PERF_TYPE_NUMBER = 0x00000000,
/// <summary>32 bit field</summary>
PERF_SIZE_DWORD = 0x00000000,
/// <summary>64 bit field</summary>
PERF_SIZE_LARGE = 0x00000100,
/// <summary>for Zero Length fields</summary>
PERF_SIZE_ZERO = 0x00000200,
/// <summary>length is in CounterLength field</summary>
PERF_SIZE_VARIABLE_LEN = 0x00000300,
/// <summary>An increasing numeric value</summary>
PERF_TYPE_COUNTER = 0x00000400,
/// <summary>A text field</summary>
PERF_TYPE_TEXT = 0x00000800,
/// <summary>Displays a zero</summary>
PERF_TYPE_ZERO = 0x00000C00,
/// <summary>Display as HEX value</summary>
PERF_NUMBER_HEX = 0x00000000,
/// <summary>Display as a decimal integer</summary>
PERF_NUMBER_DECIMAL = 0x00010000,
/// <summary>Display as a decimal/1000</summary>
PERF_NUMBER_DEC_1000 = 0x00020000,
/// <summary>Display counter value</summary>
PERF_COUNTER_VALUE = 0x00000000,
/// <summary>Divide ctr / delta time</summary>
PERF_COUNTER_RATE = 0x00010000,
/// <summary>Divide ctr / base</summary>
PERF_COUNTER_FRACTION = 0x00020000,
/// <summary>Base value used in fractions</summary>
PERF_COUNTER_BASE = 0x00030000,
/// <summary>Subtract counter from current time</summary>
PERF_COUNTER_ELAPSED = 0x00040000,
/// <summary>Use Queuelen processing func.</summary>
PERF_COUNTER_QUEUELEN = 0x00050000,
/// <summary>Counter begins or ends a histogram</summary>
PERF_COUNTER_HISTOGRAM = 0x00060000,
/// <summary>Divide ctr / private clock</summary>
PERF_COUNTER_PRECISION = 0x00070000,
/// <summary>Type of text in text field</summary>
PERF_TEXT_UNICODE = 0x00000000,
/// <summary>ASCII using the CodePage field</summary>
PERF_TEXT_ASCII = 0x00010000,
/// <summary>Use system perf. freq for base</summary>
PERF_TIMER_TICK = 0x00000000,
/// <summary>Use 100 NS timer time base units</summary>
PERF_TIMER_100NS = 0x00100000,
/// <summary>Use the object timer freq</summary>
PERF_OBJECT_TIMER = 0x00200000,
/// <summary>Compute difference first</summary>
PERF_DELTA_COUNTER = 0x00400000,
/// <summary>Compute base diff as well</summary>
PERF_DELTA_BASE = 0x00800000,
/// <summary>Show as 1.00-value (assumes:</summary>
PERF_INVERSE_COUNTER = 0x01000000,
/// <summary>Sum of multiple instances</summary>
PERF_MULTI_COUNTER = 0x02000000,
/// <summary>No suffix</summary>
PERF_DISPLAY_NO_SUFFIX = 0x00000000,
/// <summary>"/sec"</summary>
PERF_DISPLAY_PER_SEC = 0x10000000,
/// <summary>"%"</summary>
PERF_DISPLAY_PERCENT = 0x20000000,
/// <summary>"secs"</summary>
PERF_DISPLAY_SECONDS = 0x30000000,
/// <summary>Value is not displayed</summary>
PERF_DISPLAY_NOSHOW = 0x40000000,
/// <summary>32-bit Counter. Divide delta by delta time. Display suffix: "/sec"</summary>
PERF_COUNTER_COUNTER = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PER_SEC,
/// <summary>64-bit Timer. Divide delta by delta time. Display suffix: "%"</summary>
PERF_COUNTER_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>Queue Length Space-Time Product. Divide delta by delta time. No Display Suffix.</summary>
PERF_COUNTER_QUEUELEN_TYPE = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX,
/// <summary>Queue Length Space-Time Product. Divide delta by delta time. No Display Suffix.</summary>
PERF_COUNTER_LARGE_QUEUELEN_TYPE = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX,
/// <summary>Queue Length Space-Time Product using 100 Ns timebase. Divide delta by delta time. No Display Suffix.</summary>
PERF_COUNTER_100NS_QUEUELEN_TYPE = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX,
/// <summary>Queue Length Space-Time Product using Object specific timebase. Divide delta by delta time. No Display Suffix.</summary>
PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_QUEUELEN | PERF_OBJECT_TIMER | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX,
/// <summary>64-bit Counter. Divide delta by delta time. Display Suffix: "/sec"</summary>
PERF_COUNTER_BULK_COUNT = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PER_SEC,
/// <summary>Indicates the counter is not a counter but rather Unicode text Display as text.</summary>
PERF_COUNTER_TEXT = PERF_SIZE_VARIABLE_LEN | PERF_TYPE_TEXT | PERF_TEXT_UNICODE | PERF_DISPLAY_NO_SUFFIX,
/// <summary>
/// Indicates the data is a counter which should not be time averaged on display (such as an error counter on a serial line)
/// Display as is. No Display Suffix.
/// </summary>
PERF_COUNTER_RAWCOUNT = PERF_SIZE_DWORD | PERF_TYPE_NUMBER | PERF_NUMBER_DECIMAL | PERF_DISPLAY_NO_SUFFIX,
/// <summary>Same as PERF_COUNTER_RAWCOUNT except its size is a large integer</summary>
PERF_COUNTER_LARGE_RAWCOUNT = PERF_SIZE_LARGE | PERF_TYPE_NUMBER | PERF_NUMBER_DECIMAL | PERF_DISPLAY_NO_SUFFIX,
/// <summary>
/// Special case for RAWCOUNT that want to be displayed in hex Indicates the data is a counter which should not be time averaged
/// on display (such as an error counter on a serial line) Display as is. No Display Suffix.
/// </summary>
PERF_COUNTER_RAWCOUNT_HEX = PERF_SIZE_DWORD | PERF_TYPE_NUMBER | PERF_NUMBER_HEX | PERF_DISPLAY_NO_SUFFIX,
/// <summary>Same as PERF_COUNTER_RAWCOUNT_HEX except its size is a large integer</summary>
PERF_COUNTER_LARGE_RAWCOUNT_HEX = PERF_SIZE_LARGE | PERF_TYPE_NUMBER | PERF_NUMBER_HEX | PERF_DISPLAY_NO_SUFFIX,
/// <summary>
/// A count which is either 1 or 0 on each sampling interrupt (% busy) Divide delta by delta base. Display Suffix: "%"
/// </summary>
PERF_SAMPLE_FRACTION = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_FRACTION | PERF_DELTA_COUNTER | PERF_DELTA_BASE | PERF_DISPLAY_PERCENT,
/// <summary>A count which is sampled on each sampling interrupt (queue length) Divide delta by delta time. No Display Suffix.</summary>
PERF_SAMPLE_COUNTER = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX,
/// <summary>A label: no data is associated with this counter (it has 0 length) Do not display.</summary>
PERF_COUNTER_NODATA = PERF_SIZE_ZERO | PERF_DISPLAY_NOSHOW,
/// <summary>
/// 64-bit Timer inverse (e.g., idle is measured, but display busy %) Display 100 - delta divided by delta time. Display suffix: "%"
/// </summary>
PERF_COUNTER_TIMER_INV = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>
/// The divisor for a sample, used with the previous counter to form a sampled %. You must check for &gt;0 before dividing by
/// this! This counter will directly follow the numerator counter. It should not be displayed to the user.
/// </summary>
PERF_SAMPLE_BASE = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_BASE | PERF_DISPLAY_NOSHOW | 0x00000001,
/// <summary>
/// A timer which, when divided by an average base, produces a time in seconds which is the average time of some operation. This
/// timer times total operations, and the base is the number of operations. Display Suffix: "sec"
/// </summary>
PERF_AVERAGE_TIMER = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_FRACTION | PERF_DISPLAY_SECONDS,
/// <summary>
/// Used as the denominator in the computation of time or count averages. Must directly follow the numerator counter. Not
/// displayed to the user.
/// </summary>
PERF_AVERAGE_BASE = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_BASE | PERF_DISPLAY_NOSHOW | 0x00000002,
/// <summary>
/// A bulk count which, when divided (typically) by the number of operations, gives (typically) the number of bytes per
/// operation. No Display Suffix.
/// </summary>
PERF_AVERAGE_BULK = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_FRACTION | PERF_DISPLAY_NOSHOW,
/// <summary>
/// 64-bit Timer in object specific units. Display delta divided by delta time as returned in the object type header structure.
/// Display suffix: "%"
/// </summary>
PERF_OBJ_TIME_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_OBJECT_TIMER | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>64-bit Timer in 100 nsec units. Display delta divided by delta time. Display suffix: "%"</summary>
PERF_100NSEC_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>
/// 64-bit Timer inverse (e.g., idle is measured, but display busy %) Display 100 - delta divided by delta time. Display suffix: "%"
/// </summary>
PERF_100NSEC_TIMER_INV = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>
/// 64-bit Timer. Divide delta by delta time. Display suffix: "%" Timer for multiple instances, so result can exceed 100%.
/// </summary>
PERF_COUNTER_MULTI_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_DELTA_COUNTER | PERF_TIMER_TICK | PERF_MULTI_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>
/// 64-bit Timer inverse (e.g., idle is measured, but display busy %) Display 100 * _MULTI_BASE - delta divided by delta time.
/// Display suffix: "%" Timer for multiple instances, so result can exceed 100%. Followed by a counter of type _MULTI_BASE.
/// </summary>
PERF_COUNTER_MULTI_TIMER_INV = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_RATE | PERF_DELTA_COUNTER | PERF_MULTI_COUNTER | PERF_TIMER_TICK | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>Number of instances to which the preceding _MULTI_..._INV counter applies. Used as a factor to get the percentage.</summary>
PERF_COUNTER_MULTI_BASE = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_BASE | PERF_MULTI_COUNTER | PERF_DISPLAY_NOSHOW,
/// <summary>
/// 64-bit Timer in 100 nsec units. Display delta divided by delta time. Display suffix: "%" Timer for multiple instances, so
/// result can exceed 100%.
/// </summary>
PERF_100NSEC_MULTI_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_DELTA_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_MULTI_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>
/// 64-bit Timer inverse (e.g., idle is measured, but display busy %) Display 100 * _MULTI_BASE - delta divided by delta time.
/// Display suffix: "%" Timer for multiple instances, so result can exceed 100%. Followed by a counter of type _MULTI_BASE.
/// </summary>
PERF_100NSEC_MULTI_TIMER_INV = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_DELTA_COUNTER | PERF_COUNTER_RATE | PERF_TIMER_100NS | PERF_MULTI_COUNTER | PERF_INVERSE_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>
/// Indicates the data is a fraction of the following counter which should not be time averaged on display (such as free space
/// over total space.) Display as is. Display the quotient as "%".
/// </summary>
PERF_RAW_FRACTION = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_FRACTION | PERF_DISPLAY_PERCENT,
/// <summary>
/// Indicates the data is a fraction of the following counter which should not be time averaged on display (such as free space
/// over total space.) Display as is. Display the quotient as "%".
/// </summary>
PERF_LARGE_RAW_FRACTION = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_FRACTION | PERF_DISPLAY_PERCENT,
/// <summary>
/// Indicates the data is a base for the preceding counter which should not be time averaged on display (such as free space over
/// total space.)
/// </summary>
PERF_RAW_BASE = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_BASE | PERF_DISPLAY_NOSHOW | 0x00000003, // for compatibility with pre-beta version,
/// <summary>
/// Indicates the data is a base for the preceding counter which should not be time averaged on display (such as free space over
/// total space.)
/// </summary>
PERF_LARGE_RAW_BASE = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_BASE | PERF_DISPLAY_NOSHOW,
/// <summary>
/// The data collected in this counter is actually the start time of the item being measured. For display, this data is
/// subtracted from the sample time to yield the elapsed time as the difference between the two. In the definition below, the
/// PerfTime field of the Object contains the sample time as indicated by the PERF_OBJECT_TIMER bit and the difference is scaled
/// by the PerfFreq of the Object to convert the time units into seconds.
/// </summary>
PERF_ELAPSED_TIME = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_ELAPSED | PERF_OBJECT_TIMER | PERF_DISPLAY_SECONDS,
/// <summary>
/// The following counter type can be used with the preceding types to define a range of values to be displayed in a histogram.
/// </summary>
PERF_COUNTER_HISTOGRAM_TYPE = 0x8000000,
/// <summary>
/// This counter is used to display the difference from one sample to the next. The counter value is a constantly increasing
/// number and the value displayed is the difference between the current value and the previous value. Negative numbers are not
/// allowed which shouldn't be a problem as long as the counter value is increasing or unchanged.
/// </summary>
PERF_COUNTER_DELTA = PERF_SIZE_DWORD | PERF_TYPE_COUNTER | PERF_COUNTER_VALUE | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX,
/// <summary>
/// This counter is used to display the difference from one sample to the next. The counter value is a constantly increasing
/// number and the value displayed is the difference between the current value and the previous value. Negative numbers are not
/// allowed which shouldn't be a problem as long as the counter value is increasing or unchanged.
/// </summary>
PERF_COUNTER_LARGE_DELTA = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_VALUE | PERF_DELTA_COUNTER | PERF_DISPLAY_NO_SUFFIX,
/// <summary>The timer used has the same frequency as the System Performance Timer</summary>
PERF_PRECISION_SYSTEM_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_PRECISION | PERF_TIMER_TICK | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>The timer used has the same frequency as the 100 NanoSecond Timer</summary>
PERF_PRECISION_100NS_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_PRECISION | PERF_TIMER_100NS | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT,
/// <summary>The timer used is of the frequency specified in the Object header's PerfFreq field (PerfTime is ignored)</summary>
PERF_PRECISION_OBJECT_TIMER = PERF_SIZE_LARGE | PERF_TYPE_COUNTER | PERF_COUNTER_PRECISION | PERF_OBJECT_TIMER | PERF_DELTA_COUNTER | PERF_DISPLAY_PERCENT,
}
/// <summary>Determines the data type of the calculated value.</summary>
[PInvokeData("pdh.h", MSDNShortId = "fd50b1fd-29b7-49a8-bbcc-4d7f0cbd7079")]
public enum PDH_FMT
{
/// <summary/>
PDH_FMT_RAW = 0x00000010,
/// <summary>Return the calculated value as an ANSI string.</summary>
PDH_FMT_ANSI = 0x00000020,
/// <summary>Return the calculated value as a Unicode string.</summary>
PDH_FMT_UNICODE = 0x00000040,
/// <summary>Return the calculated value as a long integer.</summary>
PDH_FMT_LONG = 0x00000100,
/// <summary>Return the calculated value as a double-precision floating point real.</summary>
PDH_FMT_DOUBLE = 0x00000200,
/// <summary>Return the calculated value as a 64-bit integer.</summary>
PDH_FMT_LARGE = 0x00000400,
/// <summary>Do not apply the counter's scaling factor in the calculation.</summary>
PDH_FMT_NOSCALE = 0x00001000,
/// <summary>Multiply the final value by 1,000.</summary>
PDH_FMT_1000 = 0x00002000,
/// <summary/>
PDH_FMT_NODATA = 0x00004000,
/// <summary>
/// Counter values greater than 100 (for example, counter values measuring the processor load on multiprocessor computers) will
/// not be reset to 100. The default behavior is that counter values are capped at a value of 100.
/// </summary>
PDH_FMT_NOCAP100 = 0x00008000,
}
/// <summary>Type of record for <c>PDH_RAW_LOG_RECORD</c>.</summary>
[PInvokeData("pdh.h", MSDNShortId = "ae96515f-ea3f-4578-a249-fb8f41cdfa69")]
public enum PDH_LOG_TYPE
{
/// <summary>Undefined record format.</summary>
PDH_LOG_TYPE_UNDEFINED = 0,
/// <summary>A comma-separated-value format record</summary>
PDH_LOG_TYPE_CSV = 1,
/// <summary>A tab-separated-value format record</summary>
PDH_LOG_TYPE_TSV = 2,
/// <summary/>
PDH_LOG_TYPE_TRACE_KERNEL = 4,
/// <summary/>
PDH_LOG_TYPE_TRACE_GENERIC = 5,
/// <summary>A Perfmon format record</summary>
PDH_LOG_TYPE_PERFMON = 6,
/// <summary>A SQL format record</summary>
PDH_LOG_TYPE_SQL = 7,
/// <summary>A binary trace format record</summary>
PDH_LOG_TYPE_BINARY = 8,
}
/// <summary>Format of the input and output counter values.</summary>
[PInvokeData("pdh.h", MSDNShortId = "f2dc5f77-9f9e-4290-95fa-ce2f1e81fc69")]
public enum PDH_PATH
{
/// <summary>Returns the path in the PDH format, for example, \\computer\object(parent/instance#index)\counter.</summary>
PDH_PATH_DEFAULT = 0x00000000,
/// <summary>Converts a PDH path to the WMI class and property name format.</summary>
PDH_PATH_WBEM_RESULT = 0x00000001,
/// <summary>Converts the WMI class and property name to a PDH path.</summary>
PDH_PATH_WBEM_INPUT = 0x00000002
}
/// <summary>Flags that indicate which wildcard characters not to expand.</summary>
[PInvokeData("pdh.h", MSDNShortId = "415da310-de56-4d58-8959-231426867526")]
[Flags]
public enum PdhExpandFlags
{
/// <summary>Do not expand the counter name if the path contains a wildcard character for counter name.</summary>
PDH_NOEXPANDCOUNTERS = 1,
/// <summary>
/// Do not expand the instance name if the path contains a wildcard character for parent instance, instance name, or instance index.
/// </summary>
PDH_NOEXPANDINSTANCES = 2,
/// <summary/>
PDH_REFRESHCOUNTERS = 4
}
/// <summary>Type of access to use to open the log file.</summary>
[PInvokeData("pdh.h", MSDNShortId = "a8457959-af3a-497f-91ca-0876cbb552cc")]
[Flags]
public enum PdhLogAccess : uint
{
/// <summary>Open the log file for reading.</summary>
PDH_LOG_READ_ACCESS = 0x00010000,
/// <summary>Open a new log file for writing.</summary>
PDH_LOG_WRITE_ACCESS = 0x00020000,
/// <summary>Open an existing log file for writing.</summary>
PDH_LOG_UPDATE_ACCESS = 0x00040000,
/// <summary>Creates a new log file with the specified name.</summary>
PDH_LOG_CREATE_NEW = 0x00000001,
/// <summary>
/// Creates a new log file with the specified name. If the log file already exists, the function removes the existing log file
/// before creating the new file.
/// </summary>
PDH_LOG_CREATE_ALWAYS = 0x00000002,
/// <summary>
/// Opens an existing log file with the specified name or creates a new log file with the specified name.Opens an existing log
/// file with the specified name or creates a new log file with the specified name.
/// </summary>
PDH_LOG_OPEN_ALWAYS = 0x00000003,
/// <summary>
/// Opens an existing log file with the specified name. If a log file with the specified name does not exist, this is equal to PDH_LOG_CREATE_NEW.
/// </summary>
PDH_LOG_OPEN_EXISTING = 0x00000004,
/// <summary>
/// Used with PDH_LOG_TYPE_TSV to write the user caption or log file description indicated by the szUserString parameter of
/// PdhUpdateLog or PdhOpenLog. The user caption or log file description is written as the last column in the first line of the
/// text log.
/// </summary>
PDH_LOG_OPT_USER_STRING = 0x01000000,
/// <summary>
/// Creates a circular log file with the specified name. When the file reaches the value of the dwMaxSize parameter, data wraps
/// to the beginning of the log file. You can specify this flag only if the lpdwLogType parameter is PDH_LOG_TYPE_BINARY.
/// </summary>
PDH_LOG_OPT_CIRCULAR = 0x02000000,
/// <summary/>
PDH_LOG_OPT_MAX_IS_BYTES = 0x04000000,
/// <summary/>
PDH_LOG_OPT_APPEND = 0x08000000,
}
/// <summary>Dialog boxes that will be displayed to prompt for the data source.</summary>
[PInvokeData("pdh.h", MSDNShortId = "211d4504-e1f9-48a0-8ddd-613f2f183c59")]
public enum PdhSelectDataSourceFlags
{
/// <summary>
/// Display the data source selection dialog box. The dialog box lets the user select performance data from either a log file or
/// a real-time source. If the user specified that data is to be collected from a log file, a file browser is displayed for the
/// user to specify the name and location of the log file.
/// </summary>
Default,
/// <summary>
/// Display the file browser only. Set this flag when you want to prompt for the name and location of a log file only.
/// </summary>
PDH_FLAGS_FILE_BROWSER_ONLY
}
/// <summary>
/// Default detail level to show in the Detail level list if bHideDetailBox is FALSE. If bHideDetailBox is TRUE, the dialog uses this
/// value to filter the displayed performance counters and objects.
/// </summary>
[PInvokeData("winperf.h")]
public enum PERF_DETAIL
{
/// <summary>A novice user can understand the counter data.</summary>
PERF_DETAIL_NOVICE = 100,
/// <summary>The counter data is provided for advanced users.</summary>
PERF_DETAIL_ADVANCED = 200,
/// <summary>The counter data is provided for expert users.</summary>
PERF_DETAIL_EXPERT = 300,
/// <summary>The counter data is provided for system designers.</summary>
PERF_DETAIL_WIZARD = 400
}
/// <summary>Adds the specified counter to the query.</summary>
/// <param name="hQuery">
/// Handle to the query to which you want to add the counter. This handle is returned by the PdhOpenQuery function.
/// </param>
/// <param name="szFullCounterPath">
/// Null-terminated string that contains the counter path. For details on the format of a counter path, see Specifying a Counter
/// Path. The maximum length of a counter path is PDH_MAX_COUNTER_PATH.
/// </param>
/// <param name="dwUserData">
/// User-defined value. This value becomes part of the counter information. To retrieve this value later, call the PdhGetCounterInfo
/// function and access the <c>dwUserData</c> member of the PDH_COUNTER_INFO structure.
/// </param>
/// <param name="phCounter">
/// Handle to the counter that was added to the query. You may need to reference this handle in subsequent calls.
/// </param>
/// <returns>
/// <para>Return ERROR_SUCCESS if the function succeeds.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_CSTATUS_BAD_COUNTERNAME</term>
/// <term>The counter path could not be parsed or interpreted.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTER</term>
/// <term>Unable to find the specified counter on the computer or in the log file.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTERNAME</term>
/// <term>The counter path is empty.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The path did not contain a computer name, and the function was unable to retrieve the local computer name.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>Unable to find the specified object on the computer or in the log file.</term>
/// </item>
/// <item>
/// <term>PDH_FUNCTION_NOT_FOUND</term>
/// <term>Unable to determine the calculation function to use for this counter.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>One or more arguments are not valid.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The query handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory required to complete the function.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// If the counter path contains a wildcard character, all counter names matching the wildcard character are added to the query.
/// </para>
/// <para>
/// If a counter instance is specified that does not yet exist, <c>PdhAddCounter</c> does not report an error condition. Instead, it
/// returns ERROR_SUCCESS. The reason for this behavior is that it is not known whether a nonexistent counter instance has been
/// specified or whether one will exist but has not yet been created.
/// </para>
/// <para>To remove the counter from the query, use the PdhRemoveCounter function.</para>
/// <para>Examples</para>
/// <para>For an example, see Browsing Performance Counters or Reading Performance Data from a Log File.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhaddcountera PDH_FUNCTION PdhAddCounterA( PDH_HQUERY hQuery,
// LPCSTR szFullCounterPath, DWORD_PTR dwUserData, PDH_HCOUNTER *phCounter );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "b8b9a332-ce28-46d4-92e2-91f9f6c24da5")]
public static extern Win32Error PdhAddCounter(PDH_HQUERY hQuery, string szFullCounterPath, IntPtr dwUserData, out SafePDH_HCOUNTER phCounter);
/// <summary>Adds the specified language-neutral counter to the query.</summary>
/// <param name="hQuery">
/// Handle to the query to which you want to add the counter. This handle is returned by the PdhOpenQuery function.
/// </param>
/// <param name="szFullCounterPath">
/// Null-terminated string that contains the counter path. For details on the format of a counter path, see Specifying a Counter
/// Path. The maximum length of a counter path is PDH_MAX_COUNTER_PATH.
/// </param>
/// <param name="dwUserData">
/// User-defined value. This value becomes part of the counter information. To retrieve this value later, call the PdhGetCounterInfo
/// function and access the <c>dwQueryUserData</c> member of the PDH_COUNTER_INFO structure.
/// </param>
/// <param name="phCounter">
/// Handle to the counter that was added to the query. You may need to reference this handle in subsequent calls.
/// </param>
/// <returns>
/// <para>Return ERROR_SUCCESS if the function succeeds.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_CSTATUS_BAD_COUNTERNAME</term>
/// <term>The counter path could not be parsed or interpreted.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTER</term>
/// <term>Unable to find the specified counter on the computer or in the log file.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTERNAME</term>
/// <term>The counter path is empty.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The path did not contain a computer name and the function was unable to retrieve the local computer name.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>Unable to find the specified object on the computer or in the log file.</term>
/// </item>
/// <item>
/// <term>PDH_FUNCTION_NOT_FOUND</term>
/// <term>Unable to determine the calculation function to use for this counter.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>One or more arguments are not valid.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The query handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory required to complete the function.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// This function provides a language-neutral way to add performance counters to the query. In contrast, the counter path that you
/// specify in the PdhAddCounter function must be localized.
/// </para>
/// <para>
/// If a counter instance is specified that does not yet exist, <c>PdhAddEnglishCounter</c> does not report an error condition.
/// Instead, it returns ERROR_SUCCESS. The reason for this behavior is that it is not known whether a nonexistent counter instance
/// has been specified or whether one will exist but has not yet been created.
/// </para>
/// <para>To remove the counter from the query, use the PdhRemoveCounter function.</para>
/// <para>
/// <c>Note</c> If the counter path contains a wildcard character, the non-wildcard portions of the path will be localized, but
/// wildcards will not be expanded before adding the localized counter path to the query. In this case, you will need use the
/// following procedure to add all matching counter names to the query.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhaddenglishcountera PDH_FUNCTION PdhAddEnglishCounterA( PDH_HQUERY
// hQuery, LPCSTR szFullCounterPath, DWORD_PTR dwUserData, PDH_HCOUNTER *phCounter );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "6a94b40d-0105-4358-93e1-dae603a35cc4")]
public static extern Win32Error PdhAddEnglishCounter(PDH_HQUERY hQuery, string szFullCounterPath, IntPtr dwUserData, out SafePDH_HCOUNTER phCounter);
/// <summary>Binds one or more binary log files together for reading log data.</summary>
/// <param name="phDataSource">Handle to the bound data sources.</param>
/// <param name="LogFileNameList">
/// <para>
/// One or more binary log files to bind together. The log file names can contain absolute or relative paths. You cannot specify more
/// than 32 log files.
/// </para>
/// <para>If <c>NULL</c>, the source is a real-time data source.</para>
/// </param>
/// <returns>
/// <para>Returns ERROR_SUCCESS if the function succeeds.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function is used with the PDH functions that require a handle to a data source. For a list of these functions, see See Also.
/// </para>
/// <para>
/// You cannot specify more than one comma-delimited (CSV) or tab-delimited (TSV) file. The list can contain only one type of
/// file—you cannot combine multiple file types.
/// </para>
/// <para>To close the bound log files, call the PdhCloseLog function using the log handle.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhbindinputdatasourcea PDH_FUNCTION PdhBindInputDataSourceA(
// PDH_HLOG *phDataSource, LPCSTR LogFileNameList );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "eaed9b28-eb09-4123-9317-5d3d50e2d77a")]
public static extern Win32Error PdhBindInputDataSource(out SafePDH_HLOG phDataSource, [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(NullTermStringArrayMarshaler), MarshalCookie = "Auto")] string[] LogFileNameList);
/// <summary>Binds one or more binary log files together for reading log data.</summary>
/// <param name="LogFileNameList">
/// <para>
/// One or more binary log files to bind together. The log file names can contain absolute or relative paths. You cannot specify more
/// than 32 log files.
/// </para>
/// <para>If <c>NULL</c>, the source is a real-time data source.</para>
/// </param>
/// <returns>Handle to the bound data sources.</returns>
/// <remarks>
/// <para>
/// This function is used with the PDH functions that require a handle to a data source. For a list of these functions, see See Also.
/// </para>
/// <para>
/// You cannot specify more than one comma-delimited (CSV) or tab-delimited (TSV) file. The list can contain only one type of
/// file—you cannot combine multiple file types.
/// </para>
/// </remarks>
[PInvokeData("pdh.h", MSDNShortId = "eaed9b28-eb09-4123-9317-5d3d50e2d77a")]
public static SafePDH_HLOG PdhBindInputDataSource(params string[] LogFileNameList)
{
var err = PdhBindInputDataSource(out var hLog, LogFileNameList is null || LogFileNameList.Length == 0 ? null : LogFileNameList);
return err.Succeeded ? hLog : throw err.GetException();
}
/// <summary>
/// <para>
/// Displays a <c>Browse Counters</c> dialog box that the user can use to select one or more counters that they want to add to the query.
/// </para>
/// <para>To use handles to data sources, use the PdhBrowseCountersH function.</para>
/// </summary>
/// <param name="pBrowseDlgData">A PDH_BROWSE_DLG_CONFIG structure that specifies the behavior of the dialog box.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// </returns>
/// <remarks>
/// <para>
/// Note that the dialog box can return PDH_DIALOG_CANCELLED if <c>bSingleCounterPerDialog</c> is <c>FALSE</c> and the user clicks
/// the <c>Close</c> button, so your error handling would have to account for this.
/// </para>
/// <para>For information on using this function, see Browsing Counters.</para>
/// <para>Examples</para>
/// <para>For an example, see Browsing Performance Counters.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhbrowsecountersa PDH_FUNCTION PdhBrowseCountersA(
// PPDH_BROWSE_DLG_CONFIG_A pBrowseDlgData );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "4e9e4b20-a573-4f6d-97e8-63bcc675032b")]
public static extern Win32Error PdhBrowseCounters(ref PDH_BROWSE_DLG_CONFIG pBrowseDlgData);
/// <summary>
/// <para>
/// Displays a <c>Browse Counters</c> dialog box that the user can use to select one or more counters that they want to add to the query.
/// </para>
/// <para>This function is identical to the PdhBrowseCounters function, except that it supports the use of handles to data sources.</para>
/// </summary>
/// <param name="pBrowseDlgData">A PDH_BROWSE_DLG_CONFIG_H structure that specifies the behavior of the dialog box.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// </returns>
/// <remarks>
/// Note that the dialog box can return PDH_DIALOG_CANCELLED if <c>bSingleCounterPerDialog</c> is <c>FALSE</c> and the user clicks
/// the <c>Close</c> button, so your error handling would have to account for this.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhbrowsecountersha PDH_FUNCTION PdhBrowseCountersHA(
// PPDH_BROWSE_DLG_CONFIG_HA pBrowseDlgData );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "ab835bf8-1adc-463f-99c3-654a328af98a")]
public static extern Win32Error PdhBrowseCountersH(in PDH_BROWSE_DLG_CONFIG_H pBrowseDlgData);
/// <summary>Calculates the displayable value of two raw counter values.</summary>
/// <param name="hCounter">
/// Handle to the counter to calculate. The function uses information from the counter to determine how to calculate the value. This
/// handle is returned by the PdhAddCounter function.
/// </param>
/// <param name="dwFormat">
/// <para>Determines the data type of the calculated value. Specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_DOUBLE</term>
/// <term>Return the calculated value as a double-precision floating point real.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LARGE</term>
/// <term>Return the calculated value as a 64-bit integer.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LONG</term>
/// <term>Return the calculated value as a long integer.</term>
/// </item>
/// </list>
/// <para>You can use the bitwise inclusive OR operator (|) to combine the data type with one of the following scaling factors.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_NOSCALE</term>
/// <term>Do not apply the counter's scaling factor in the calculation.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_NOCAP100</term>
/// <term>
/// Counter values greater than 100 (for example, counter values measuring the processor load on multiprocessor computers) will not
/// be reset to 100. The default behavior is that counter values are capped at a value of 100.
/// </term>
/// </item>
/// <item>
/// <term>PDH_FMT_1000</term>
/// <term>Multiply the final value by 1,000.</term>
/// </item>
/// </list>
/// </param>
/// <param name="rawValue1">
/// Raw counter value used to compute the displayable counter value. For details, see the PDH_RAW_COUNTER structure.
/// </param>
/// <param name="rawValue2">
/// Raw counter value used to compute the displayable counter value. For details, see PDH_RAW_COUNTER. Some counters (for example,
/// rate counters) require two raw values to calculate a displayable value. If the counter type does not require a second value, set
/// this parameter to <c>NULL</c>. This value must be the older of the two raw values.
/// </param>
/// <param name="fmtValue">A PDH_FMT_COUNTERVALUE structure that receives the calculated counter value.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>An argument is not correct or is incorrectly formatted.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>To retrieve the current raw counter value from the query, call the PdhGetRawCounterValue function.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhcalculatecounterfromrawvalue PDH_FUNCTION
// PdhCalculateCounterFromRawValue( PDH_HCOUNTER hCounter, DWORD dwFormat, PPDH_RAW_COUNTER rawValue1, PPDH_RAW_COUNTER rawValue2,
// PPDH_FMT_COUNTERVALUE fmtValue );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "fd50b1fd-29b7-49a8-bbcc-4d7f0cbd7079")]
public static extern Win32Error PdhCalculateCounterFromRawValue(PDH_HCOUNTER hCounter, PDH_FMT dwFormat, in PDH_RAW_COUNTER rawValue1, in PDH_RAW_COUNTER rawValue2, out PDH_FMT_COUNTERVALUE fmtValue);
/// <summary>Calculates the displayable value of two raw counter values.</summary>
/// <param name="hCounter">
/// Handle to the counter to calculate. The function uses information from the counter to determine how to calculate the value. This
/// handle is returned by the PdhAddCounter function.
/// </param>
/// <param name="dwFormat">
/// <para>Determines the data type of the calculated value. Specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_DOUBLE</term>
/// <term>Return the calculated value as a double-precision floating point real.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LARGE</term>
/// <term>Return the calculated value as a 64-bit integer.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LONG</term>
/// <term>Return the calculated value as a long integer.</term>
/// </item>
/// </list>
/// <para>You can use the bitwise inclusive OR operator (|) to combine the data type with one of the following scaling factors.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_NOSCALE</term>
/// <term>Do not apply the counter's scaling factor in the calculation.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_NOCAP100</term>
/// <term>
/// Counter values greater than 100 (for example, counter values measuring the processor load on multiprocessor computers) will not
/// be reset to 100. The default behavior is that counter values are capped at a value of 100.
/// </term>
/// </item>
/// <item>
/// <term>PDH_FMT_1000</term>
/// <term>Multiply the final value by 1,000.</term>
/// </item>
/// </list>
/// </param>
/// <param name="rawValue1">
/// Raw counter value used to compute the displayable counter value. For details, see the PDH_RAW_COUNTER structure.
/// </param>
/// <param name="rawValue2">
/// Raw counter value used to compute the displayable counter value. For details, see PDH_RAW_COUNTER. Some counters (for example,
/// rate counters) require two raw values to calculate a displayable value. If the counter type does not require a second value, set
/// this parameter to <c>NULL</c>. This value must be the older of the two raw values.
/// </param>
/// <param name="fmtValue">A PDH_FMT_COUNTERVALUE structure that receives the calculated counter value.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>An argument is not correct or is incorrectly formatted.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>To retrieve the current raw counter value from the query, call the PdhGetRawCounterValue function.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhcalculatecounterfromrawvalue PDH_FUNCTION
// PdhCalculateCounterFromRawValue( PDH_HCOUNTER hCounter, DWORD dwFormat, PPDH_RAW_COUNTER rawValue1, PPDH_RAW_COUNTER rawValue2,
// PPDH_FMT_COUNTERVALUE fmtValue );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "fd50b1fd-29b7-49a8-bbcc-4d7f0cbd7079")]
public static extern Win32Error PdhCalculateCounterFromRawValue(PDH_HCOUNTER hCounter, PDH_FMT dwFormat, in PDH_RAW_COUNTER rawValue1, [Optional] IntPtr rawValue2, out PDH_FMT_COUNTERVALUE fmtValue);
/// <summary>Closes the specified log file.</summary>
/// <param name="hLog">Handle to the log file to be closed. This handle is returned by the PdhOpenLog function.</param>
/// <param name="dwFlags">
/// <para>You can specify the following flag.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FLAGS_CLOSE_QUERY</term>
/// <term>Closes the query associated with the specified log file handle. See the hQuery parameter of PdhOpenLog.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS and closes and deletes the query.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following is a possible value.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The log file handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhcloselog PDH_FUNCTION PdhCloseLog( PDH_HLOG hLog, DWORD dwFlags );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "74039bdf-d1b5-41ba-aa4e-4779ce0dd02a")]
public static extern Win32Error PdhCloseLog(PDH_HLOG hLog, uint dwFlags);
/// <summary>
/// Closes all counters contained in the specified query, closes all handles related to the query, and frees all memory associated
/// with the query.
/// </summary>
/// <param name="hQuery">Handle to the query to close. This handle is returned by the PdhOpenQuery function.</param>
/// <returns>
/// <para>
/// If the function succeeds, it returns ERROR_SUCCESS. Otherwise, the function returns a system error code or a PDH error code.
/// </para>
/// <para>The following is a possible value.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The query handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>Do not use the counter handles associated with this query after calling this function.</para>
/// <para>The following shows the syntax if calling this function from Visual Basic.</para>
/// <para>Examples</para>
/// <para>For an example, see Browsing Performance Counters or Reading Performance Data from a Log File.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhclosequery PDH_FUNCTION PdhCloseQuery( PDH_HQUERY hQuery );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "af0fb9f4-3999-48fa-88d7-aa59b5caed75")]
public static extern Win32Error PdhCloseQuery(PDH_HQUERY hQuery);
/// <summary>
/// Collects the current raw data value for all counters in the specified query and updates the status code of each counter.
/// </summary>
/// <param name="hQuery">Handle of the query for which you want to collect data. The PdhOpenQuery function returns this handle.</param>
/// <returns>
/// <para>
/// If the function succeeds, it returns ERROR_SUCCESS. Otherwise, the function returns a system error code or a PDH error code.
/// </para>
/// <para>The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The query handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_NO_DATA</term>
/// <term>
/// The query does not currently contain any counters. The query may not contain data because the user is not running with an
/// elevated token (see Limited User Access Support).
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// Call this function when you want to collect counter data for the counters in the query. PDH stores the raw counter values for the
/// current and previous collection.
/// </para>
/// <para>
/// If you want to retrieve the current raw counter value, call the PdhGetRawCounterValue function. If you want to compute a
/// displayable value for the counter value, call the PdhGetFormattedCounterValue function. If the counter path contains a wildcard
/// for the instance name, instead call the PdhGetRawCounterArray and PdhGetFormattedCounterArray functions, respectively.
/// </para>
/// <para>
/// When <c>PdhCollectQueryData</c> is called for data from one counter instance only and the counter instance does not exist, the
/// function returns PDH_NO_DATA. However, if data from more than one counter is queried, <c>PdhCollectQueryData</c> may return
/// ERROR_SUCCESS even if one of the counter instances does not yet exist. This is because it is not known if the specified counter
/// instance does not exist, or if it will exist but has not yet been created. In this case, call PdhGetRawCounterValue or
/// PdhGetFormattedCounterValue for each of the counter instances of interest to determine whether they exist.
/// </para>
/// <para>The following shows the syntax if calling this function from Visual Basic.</para>
/// <para>Examples</para>
/// <para>For an example, see Browsing Performance Counters or Reading Performance Data from a Log File.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhcollectquerydata PDH_FUNCTION PdhCollectQueryData( PDH_HQUERY
// hQuery );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "1d83325b-8deb-4731-9df4-6201da292cdc")]
public static extern Win32Error PdhCollectQueryData(PDH_HQUERY hQuery);
/// <summary>
/// Uses a separate thread to collect the current raw data value for all counters in the specified query. The function then signals
/// the application-defined event and waits the specified time interval before returning.
/// </summary>
/// <param name="hQuery">
/// Handle of the query. The query identifies the counters that you want to collect. The PdhOpenQuery function returns this handle.
/// </param>
/// <param name="dwIntervalTime">Time interval to wait, in seconds.</param>
/// <param name="hNewDataEvent">
/// Handle to the event that you want PDH to signal after the time interval expires. To create an event object, call the CreateEvent function.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The query handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_NO_DATA</term>
/// <term>The query does not currently have any counters.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// PDH terminates the thread when you call the PdhCloseQuery function. If you call <c>PdhCollectQueryDataEx</c> more than once, each
/// subsequent call terminates the thread from the previous call and then starts a new thread.
/// </para>
/// <para>
/// When <c>PdhCollectQueryDataEx</c> is called for data from one counter instance only and the counter instance does not exist, the
/// function returns PDH_NO_DATA. However, if data from more than one counter is queried, <c>PdhCollectQueryDataEx</c> may return
/// ERROR_SUCCESS even if one of the counter instances does not yet exist. This is because it is not known if the specified counter
/// instance does not exist, or if it will exist but has not yet been created. In this case, call PdhGetRawCounterValue or
/// PdhGetFormattedCounterValue for each of the counter instances of interest to determine whether they exist.
/// </para>
/// <para>
/// PDH stores the raw counter values for the current and previous collection. If you want to retrieve the current raw counter value,
/// call the PdhGetRawCounterValue function. If you want to compute a displayable value for the counter value, call the
/// PdhGetFormattedCounterValue. If the counter path contains a wildcard for the instance name, instead call the
/// PdhGetRawCounterArray and PdhGetFormattedCounterArray functions, respectively.
/// </para>
/// <para>Examples</para>
/// <para>The following example shows how to use this function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhcollectquerydataex PDH_FUNCTION PdhCollectQueryDataEx( PDH_HQUERY
// hQuery, DWORD dwIntervalTime, HANDLE hNewDataEvent );
[DllImport(Lib.Pdh, SetLastError = true, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "3fa1d193-03d0-44d8-a32b-b7754594d0ca")]
public static extern Win32Error PdhCollectQueryDataEx(PDH_HQUERY hQuery, uint dwIntervalTime, SafeEventHandle hNewDataEvent);
/// <summary>
/// Collects the current raw data value for all counters in the specified query and updates the status code of each counter.
/// </summary>
/// <param name="hQuery">Handle of the query for which you want to collect data. The PdhOpenQuery function returns this handle.</param>
/// <param name="pllTimeStamp">Time stamp when the first counter value in the query was retrieved. The time is specified as FILETIME.</param>
/// <returns>
/// <para>
/// If the function succeeds, it returns ERROR_SUCCESS. Otherwise, the function returns a system error code or a PDH error code.
/// </para>
/// <para>The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The query handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_NO_DATA</term>
/// <term>The query does not currently have any counters.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// Call this function when you want to collect counter data for the counters in the query. PDH stores the raw counter values for the
/// current and previous collection.
/// </para>
/// <para>
/// If you want to retrieve the current raw counter value, call the PdhGetRawCounterValue function. If you want to compute a
/// displayable value for the counter value, call the PdhGetFormattedCounterValue. If the counter path contains a wildcard for the
/// instance name, instead call the PdhGetRawCounterArray and PdhGetFormattedCounterArray functions, respectively.
/// </para>
/// <para>
/// When PdhCollectQueryDataEx is called for data from one counter instance only, and the counter instance does not exist, the
/// function returns PDH_NO_DATA. However, if data from more than one counter is queried, <c>PdhCollectQueryDataEx</c> may return
/// ERROR_SUCCESS even if one of the counter instances does not yet exist. This is because it is not known if the specified counter
/// instance does not exist, or if it will exist but has not yet been created. In this case, call the PdhGetRawCounterValue or
/// PdhGetFormattedCounterValue function for each of the counter instances of interest to determine whether they exist.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhcollectquerydatawithtime PDH_FUNCTION
// PdhCollectQueryDataWithTime( PDH_HQUERY hQuery, LONGLONG *pllTimeStamp );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "2c47c690-0748-4ed4-a138-894d45c72581")]
public static extern Win32Error PdhCollectQueryDataWithTime(PDH_HQUERY hQuery, out FILETIME pllTimeStamp);
/// <summary>Computes statistics for a counter from an array of raw values.</summary>
/// <param name="hCounter">
/// Handle of the counter for which you want to compute statistics. The PdhAddCounter function returns this handle.
/// </param>
/// <param name="dwFormat">
/// <para>Determines the data type of the formatted value. Specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_DOUBLE</term>
/// <term>Return the calculated value as a double-precision floating point real.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LARGE</term>
/// <term>Return the calculated value as a 64-bit integer.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LONG</term>
/// <term>Return the calculated value as a long integer.</term>
/// </item>
/// </list>
/// <para>You can use the bitwise inclusive OR operator (|) to combine the data type with one of the following scaling factors.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_NOSCALE</term>
/// <term>Do not apply the counter's scaling factors in the calculation.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_NOCAP100</term>
/// <term>
/// Counter values greater than 100 (for example, counter values measuring the processor load on multiprocessor computers) will not
/// be reset to 100. The default behavior is that counter values are capped at a value of 100.
/// </term>
/// </item>
/// <item>
/// <term>PDH_FMT_1000</term>
/// <term>Multiply the final value by 1,000.</term>
/// </item>
/// </list>
/// </param>
/// <param name="dwFirstEntry">
/// Zero-based index of the first raw counter value to use to begin the calculations. The index value must point to the oldest entry
/// in the buffer. The function starts at this entry and scans through the buffer, wrapping at the last entry back to the beginning
/// of the buffer and up to the dwFirstEntry-1 entry, which is assumed to be the newest or most recent data.
/// </param>
/// <param name="dwNumEntries">Number of raw counter values in the lpRawValueArray buffer.</param>
/// <param name="lpRawValueArray">Array of PDH_RAW_COUNTER structures that contain dwNumEntries entries.</param>
/// <param name="data">A PDH_STATISTICS structure that receives the counter statistics.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>An argument is not correct or is incorrectly formatted.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhcomputecounterstatistics PDH_FUNCTION
// PdhComputeCounterStatistics( PDH_HCOUNTER hCounter, DWORD dwFormat, DWORD dwFirstEntry, DWORD dwNumEntries, PPDH_RAW_COUNTER
// lpRawValueArray, PPDH_STATISTICS data );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "a986ae6c-88ee-4a03-9077-3d286157b9d1")]
public static extern Win32Error PdhComputeCounterStatistics(PDH_HCOUNTER hCounter, PDH_FMT dwFormat, uint dwFirstEntry, uint dwNumEntries, [In] PDH_RAW_COUNTER[] lpRawValueArray, out PDH_STATISTICS data);
/// <summary>Connects to the specified computer.</summary>
/// <param name="szMachineName">
/// <c>Null</c>-terminated string that specifies the name of the computer to connect to. If <c>NULL</c>, PDH connects to the local computer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>
/// Unable to connect to the specified computer. Could be caused by the computer not being on, not supporting PDH, not being
/// connected to the network, or having the permissions set on the registry that prevent remote connections or remote performance
/// monitoring by the user.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>
/// Unable to allocate a dynamic memory block. Occurs when there is a serious memory shortage in the system due to too many
/// applications running on the system or an insufficient memory paging file.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// Typically, applications do not call this function and instead the connection is made when the application adds the counter to the query.
/// </para>
/// <para>
/// However, you can use this function if you want to include more than the local computer in the <c>Select counters from
/// computer</c> list on the <c>Browse Counters</c> dialog box. For details, see the PDH_BROWSE_DLG_CONFIG structure.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhconnectmachinea PDH_FUNCTION PdhConnectMachineA( LPCSTR
// szMachineName );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "8f8b4651-b550-4b34-bb2f-d2497c56b572")]
public static extern Win32Error PdhConnectMachine([Optional] string szMachineName);
/// <summary>Enumerates the names of the log sets within the DSN.</summary>
/// <param name="szDataSource"><c>Null</c>-terminated string that specifies the DSN.</param>
/// <param name="mszDataSetNameList">
/// Caller-allocated buffer that receives the list of <c>null</c>-terminated log set names. The list is terminated with a
/// <c>null</c>-terminator character. Set to <c>NULL</c> if the pcchBufferLength parameter is zero.
/// </param>
/// <param name="pcchBufferLength">
/// Size of the mszLogSetNameList buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The size of the mszLogSetNameList buffer is too small to contain all the data. This return value is expected if pcchBufferLength
/// is zero on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set mszLogSetNameList to <c>NULL</c> and
/// pcchBufferLength to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenumlogsetnamesa PDH_FUNCTION PdhEnumLogSetNamesA( LPCSTR
// szDataSource, PZZSTR mszDataSetNameList, LPDWORD pcchBufferLength );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "c74cc8a6-915b-40ed-a88b-bc2147215d52")]
public static extern Win32Error PdhEnumLogSetNames(string szDataSource, IntPtr mszDataSetNameList, ref uint pcchBufferLength);
/// <summary>
/// <para>
/// Returns a list of the computer names associated with counters in a log file. The computer names were either specified when adding
/// counters to the query or when calling the PdhConnectMachine function. The computers listed include those that are currently
/// connected and online, in addition to those that are offline or not returning performance data.
/// </para>
/// <para>To use handles to data sources, use the PdhEnumMachinesH function.</para>
/// </summary>
/// <param name="szDataSource">
/// <c>Null</c>-terminated string that specifies the name of a log file. The function enumerates the names of the computers whose
/// counter data is in the log file. If <c>NULL</c>, the function enumerates the list of computers that were specified when adding
/// counters to a real time query or when calling the PdhConnectMachine function.
/// </param>
/// <param name="mszMachineList">
/// Caller-allocated buffer to receive the list of <c>null</c>-terminated strings that contain the computer names. The list is
/// terminated with two <c>null</c>-terminator characters. Set to <c>NULL</c> if pcchBufferLength is zero.
/// </param>
/// <param name="pcchBufferSize">
/// Size of the mszMachineNameList buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The mszMachineNameList buffer is too small to contain all the data. This return value is expected if pcchBufferLength is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set mszMachineNameList to <c>NULL</c> and
/// pcchBufferLength to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenummachinesa PDH_FUNCTION PdhEnumMachinesA( LPCSTR szDataSource,
// PZZSTR mszMachineList, LPDWORD pcchBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "77584d3b-3ba5-4288-b730-be2458f4fc1c")]
public static extern Win32Error PdhEnumMachines([Optional] string szDataSource, IntPtr mszMachineList, ref uint pcchBufferSize);
/// <summary>
/// <para>
/// Returns a list of the computer names associated with counters in a log file. The computer names were either specified when adding
/// counters to the query or when calling the PdhConnectMachine function. The computers listed include those that are currently
/// connected and online, in addition to those that are offline or not returning performance data.
/// </para>
/// <para>This function is identical to the PdhEnumMachines function, except that it supports the use of handles to data sources.</para>
/// </summary>
/// <param name="hDataSource">Handle to a data source returned by the PdhBindInputDataSource function.</param>
/// <param name="mszMachineList">
/// Caller-allocated buffer to receive the list of <c>null</c>-terminated strings that contain the computer names. The list is
/// terminated with two <c>null</c>-terminator characters. Set to <c>NULL</c> if pcchBufferLength is zero.
/// </param>
/// <param name="pcchBufferSize">
/// Size of the mszMachineNameList buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The mszMachineNameList buffer is too small to contain all the data. This return value is expected if pcchBufferLength is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set mszMachineNameList to <c>NULL</c> and
/// pcchBufferLength to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenummachinesha PDH_FUNCTION PdhEnumMachinesHA( PDH_HLOG
// hDataSource, PZZSTR mszMachineList, LPDWORD pcchBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "7e8dc113-76a7-4a7a-bbad-1a4387831501")]
public static extern Win32Error PdhEnumMachinesH([Optional] PDH_HLOG hDataSource, IntPtr mszMachineList, ref uint pcchBufferSize);
/// <summary>
/// <para>
/// Returns the specified object's counter and instance names that exist on the specified computer or in the specified log file.
/// </para>
/// <para>To use handles to data sources, use the PdhEnumObjectItemsH function.</para>
/// </summary>
/// <param name="szDataSource">
/// <para>
/// <c>Null</c>-terminated string that specifies the name of the log file used to enumerate the counter and instance names. If
/// <c>NULL</c>, the function uses the computer specified in
/// </para>
/// <para>the szMachineName parameter to enumerate the names.</para>
/// </param>
/// <param name="szMachineName">
/// <para>
/// <c>Null</c>-terminated string that specifies the name of the computer that contains the counter and instance names that you want
/// to enumerate.
/// </para>
/// <para>Include the leading slashes in the computer name, for example, \computername.</para>
/// <para>If the szDataSource parameter is <c>NULL</c>, you can set szMachineName to <c>NULL</c> to specify the local computer.</para>
/// </param>
/// <param name="szObjectName">
/// <c>Null</c>-terminated string that specifies the name of the object whose counter and instance names you want to enumerate.
/// </param>
/// <param name="mszCounterList">
/// Caller-allocated buffer that receives a list of <c>null</c>-terminated counter names provided by the specified object. The list
/// contains unique counter names. The list is terminated by two <c>NULL</c> characters. Set to <c>NULL</c> if the
/// pcchCounterListLengthparameter is zero.
/// </param>
/// <param name="pcchCounterListLength">
/// Size of the mszCounterList buffer, in <c>TCHARs</c>. If zero on input and the object exists, the function returns PDH_MORE_DATA
/// and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function sets this
/// parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less than the
/// required size, you should not rely on the returned size to reallocate the buffer.
/// </param>
/// <param name="mszInstanceList">
/// Caller-allocated buffer that receives a list of <c>null</c>-terminated instance names provided by the specified object. The list
/// contains unique instance names. The list is terminated by two <c>NULL</c> characters. Set to <c>NULL</c> if
/// pcchInstanceListLength is zero.
/// </param>
/// <param name="pcchInstanceListLength">
/// <para>
/// Size of the mszInstanceList buffer, in <c>TCHARs</c>. If zero on input and the object exists, the function returns PDH_MORE_DATA
/// and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function sets this
/// parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less than the
/// required size, you should not rely on the returned size to reallocate the buffer.
/// </para>
/// <para>
/// If the specified object does not support variable instances, then the returned value will be zero. If the specified object does
/// support variable instances, but does not currently have any instances, then the value returned is 2, which is the size of an
/// empty MULTI_SZ list string.
/// </para>
/// </param>
/// <param name="dwDetailLevel">
/// <para>
/// Detail level of the performance items to return. All items that are of the specified detail level or less will be returned (the
/// levels are listed in increasing order). This parameter can be one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PERF_DETAIL_NOVICE</term>
/// <term>Novice user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_ADVANCED</term>
/// <term>Advanced user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_EXPERT</term>
/// <term>Expert user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_WIZARD</term>
/// <term>System designer level of detail.</term>
/// </item>
/// </list>
/// </param>
/// <param name="dwFlags">This parameter must be zero.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// One of the buffers is too small to contain the list of names. This return value is expected if pcchCounterListLength or
/// pcchInstanceListLength is zero on input. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory to support this function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified object could not be found on the specified computer or in the specified log file.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set the buffers to <c>NULL</c> and the sizes
/// to 0), and the second time to get the data.
/// </para>
/// <para>
/// Consecutive calls to this function will return identical lists of counters and instances, because <c>PdhEnumObjectItems</c> will
/// always query the list of performance objects defined by the last call to PdhEnumObjects or <c>PdhEnumObjectItems</c>. To refresh
/// the list of performance objects, call <c>PdhEnumObjects</c> with a bRefresh flag value of <c>TRUE</c> before calling
/// <c>PdhEnumObjectItems</c> again.
/// </para>
/// <para>The order of the instance and counter names is undetermined.</para>
/// <para>Examples</para>
/// <para>For an example, see Enumerating Process Objects.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenumobjectitemsa PDH_FUNCTION PdhEnumObjectItemsA( LPCSTR
// szDataSource, LPCSTR szMachineName, LPCSTR szObjectName, PZZSTR mszCounterList, LPDWORD pcchCounterListLength, PZZSTR
// mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "b3efdd31-44e6-47ff-bd0e-d31451c32818")]
public static extern Win32Error PdhEnumObjectItems([Optional] string szDataSource, [Optional] string szMachineName, string szObjectName, [Optional] IntPtr mszCounterList, ref uint pcchCounterListLength, [Optional] IntPtr mszInstanceList, ref uint pcchInstanceListLength, PERF_DETAIL dwDetailLevel, uint dwFlags = 0);
/// <summary>
/// <para>
/// Returns the specified object's counter and instance names that exist on the specified computer or in the specified log file.
/// </para>
/// <para>This function is identical to the PdhEnumObjectItems function, except that it supports the use of handles to data sources.</para>
/// </summary>
/// <param name="hDataSource">Handle to a data source returned by the PdhBindInputDataSource function.</param>
/// <param name="szMachineName">
/// <para>
/// <c>Null</c>-terminated string that specifies the name of the computer that contains the counter and instance names that you want
/// to enumerate.
/// </para>
/// <para>Include the leading slashes in the computer name, for example, \computername.</para>
/// <para>If the szDataSource parameter is <c>NULL</c>, you can set szMachineName to <c>NULL</c> to specify the local computer.</para>
/// </param>
/// <param name="szObjectName">
/// <c>Null</c>-terminated string that specifies the name of the object whose counter and instance names you want to enumerate.
/// </param>
/// <param name="mszCounterList">
/// Caller-allocated buffer that receives a list of <c>null</c>-terminated counter names provided by the specified object. The list
/// contains unique counter names. The list is terminated by two <c>NULL</c> characters. Set to <c>NULL</c> if the
/// pcchCounterListLength parameter is zero.
/// </param>
/// <param name="pcchCounterListLength">
/// Size of the mszCounterList buffer, in <c>TCHARs</c>. If zero on input and the object exists, the function returns PDH_MORE_DATA
/// and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function sets this
/// parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less than the
/// required size, you should not rely on the returned size to reallocate the buffer.
/// </param>
/// <param name="mszInstanceList">
/// Caller-allocated buffer that receives a list of <c>null</c>-terminated instance names provided by the specified object. The list
/// contains unique instance names. The list is terminated by two <c>NULL</c> characters. Set to <c>NULL</c> if the
/// pcchInstanceListLength parameter is zero.
/// </param>
/// <param name="pcchInstanceListLength">
/// <para>
/// Size of the mszInstanceList buffer, in <c>TCHARs</c>. If zero on input and the object exists, the function returns PDH_MORE_DATA
/// and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function sets this
/// parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less than the
/// required size, you should not rely on the returned size to reallocate the buffer.
/// </para>
/// <para>
/// If the specified object does not support variable instances, then the returned value will be zero. If the specified object does
/// support variable instances, but does not currently have any instances, then the value returned is 2, which is the size of an
/// empty MULTI_SZ list string.
/// </para>
/// </param>
/// <param name="dwDetailLevel">
/// <para>
/// Detail level of the performance items to return. All items that are of the specified detail level or less will be returned (the
/// levels are listed in increasing order). This parameter can be one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PERF_DETAIL_NOVICE</term>
/// <term>Novice user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_ADVANCED</term>
/// <term>Advanced user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_EXPERT</term>
/// <term>Expert user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_WIZARD</term>
/// <term>System designer level of detail.</term>
/// </item>
/// </list>
/// </param>
/// <param name="dwFlags">This parameter must be zero.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// One of the buffers is too small to contain the list of names. This return value is expected if pcchCounterListLength or
/// pcchInstanceListLength is zero on input. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory to support this function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified object could not be found on the specified computer or in the specified log file.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set the buffers to <c>NULL</c> and the sizes
/// to 0), and the second time to get the data.
/// </para>
/// <para>
/// Consecutive calls to this function will return identical lists of counters and instances, because <c>PdhEnumObjectItemsH</c> will
/// always query the list of performance objects defined by the last call to PdhEnumObjectsH or <c>PdhEnumObjectItemsH</c>. To
/// refresh the list of performance objects, call <c>PdhEnumObjectsH</c> with a bRefresh flag value of <c>TRUE</c> before calling
/// <c>PdhEnumObjectItemsH</c> again.
/// </para>
/// <para>The order of the instance and counter names is undetermined.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenumobjectitemsha PDH_FUNCTION PdhEnumObjectItemsHA( PDH_HLOG
// hDataSource, LPCSTR szMachineName, LPCSTR szObjectName, PZZSTR mszCounterList, LPDWORD pcchCounterListLength, PZZSTR
// mszInstanceList, LPDWORD pcchInstanceListLength, DWORD dwDetailLevel, DWORD dwFlags );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "2cea7d0a-cea2-4fee-a087-37663de254e9")]
public static extern Win32Error PdhEnumObjectItemsH([Optional] PDH_HLOG hDataSource, [Optional] string szMachineName, string szObjectName, [Optional] IntPtr mszCounterList, ref uint pcchCounterListLength, [Optional] IntPtr mszInstanceList, ref uint pcchInstanceListLength, PERF_DETAIL dwDetailLevel, uint dwFlags = 0);
/// <summary>
/// <para>Returns a list of objects available on the specified computer or in the specified log file.</para>
/// <para>To use handles to data sources, use the PdhEnumObjectsH function.</para>
/// </summary>
/// <param name="szDataSource">
/// <para>
/// <c>Null</c>-terminated string that specifies the name of the log file used to enumerate the performance objects. If <c>NULL</c>,
/// the function uses the computer specified in
/// </para>
/// <para>the szMachineName parameter to enumerate the names.</para>
/// </param>
/// <param name="szMachineName">
/// <para><c>Null</c>-terminated string that specifies the name of the computer used to enumerate the performance objects.</para>
/// <para>Include the leading slashes in the computer name, for example, \computername.</para>
/// <para>If the szDataSource parameter is <c>NULL</c>, you can set szMachineName to <c>NULL</c> to specify the local computer.</para>
/// </param>
/// <param name="mszObjectList">
/// Caller-allocated buffer that receives the list of object names. Each object name in this list is terminated by a <c>null</c>
/// character. The list is terminated with two <c>null</c>-terminator characters. Set to <c>NULL</c> if the pcchBufferLength
/// parameter is zero.
/// </param>
/// <param name="pcchBufferSize">
/// <para>
/// Size of the mszObjectList buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this parameter
/// to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size
/// of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not
/// rely on the returned size to reallocate the buffer.
/// </para>
/// <para><c>Windows XP:</c> Add one to the required buffer size.</para>
/// </param>
/// <param name="dwDetailLevel">
/// <para>
/// Detail level of the performance items to return. All items that are of the specified detail level or less will be returned (the
/// levels are listed in increasing order). This parameter can be one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PERF_DETAIL_NOVICE</term>
/// <term>Novice user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_ADVANCED</term>
/// <term>Advanced user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_EXPERT</term>
/// <term>Expert user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_WIZARD</term>
/// <term>System designer level of detail.</term>
/// </item>
/// </list>
/// </param>
/// <param name="bRefresh">
/// <para>Indicates if the cached object list should be automatically refreshed. Specify one of the following values.</para>
/// <para>
/// If you call this function twice, once to get the size of the list and a second time to get the actual list, set this parameter to
/// <c>TRUE</c> on the first call and <c>FALSE</c> on the second call. If both calls are <c>TRUE</c>, the second call may also return
/// PDH_MORE_DATA because the object data may have changed between calls.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>TRUE</term>
/// <term>The object cache is automatically refreshed before the objects are returned.</term>
/// </item>
/// <item>
/// <term>FALSE</term>
/// <term>Do not automatically refresh the cache.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The mszObjectList buffer is too small to hold the list of objects. This return value is expected if pcchBufferLength is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified object could not be found.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set mszObjectList to <c>NULL</c> and
/// pcchBufferLength to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenumobjectsa PDH_FUNCTION PdhEnumObjectsA( LPCSTR szDataSource,
// LPCSTR szMachineName, PZZSTR mszObjectList, LPDWORD pcchBufferSize, DWORD dwDetailLevel, BOOL bRefresh );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "dfa4b10f-5134-4620-a6b0-0fa2c13a33ec")]
public static extern Win32Error PdhEnumObjects([Optional] string szDataSource, [Optional] string szMachineName, [Optional] IntPtr mszObjectList, ref uint pcchBufferSize, PERF_DETAIL dwDetailLevel, [MarshalAs(UnmanagedType.Bool)] bool bRefresh);
/// <summary>
/// <para>Returns a list of objects available on the specified computer or in the specified log file.</para>
/// <para>This function is identical to PdhEnumObjects, except that it supports the use of handles to data sources.</para>
/// </summary>
/// <param name="hDataSource">Handle to a data source returned by the PdhBindInputDataSource function.</param>
/// <param name="szMachineName">
/// <para><c>Null</c>-terminated string that specifies the name of the computer used to enumerate the performance objects.</para>
/// <para>Include the leading slashes in the computer name, for example, \computername.</para>
/// <para>If szDataSource is <c>NULL</c>, you can set szMachineName to <c>NULL</c> to specify the local computer.</para>
/// </param>
/// <param name="mszObjectList">
/// Caller-allocated buffer that receives the list of object names. Each object name in this list is terminated by a <c>null</c>
/// character. The list is terminated with two <c>null</c>-terminator characters. Set to <c>NULL</c> if pcchBufferLength is zero.
/// </param>
/// <param name="pcchBufferSize">
/// <para>
/// Size of the mszObjectList buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this parameter
/// to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size
/// of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not
/// rely on the returned size to reallocate the buffer.
/// </para>
/// <para><c>Windows XP:</c> Add one to the required buffer size.</para>
/// </param>
/// <param name="dwDetailLevel">
/// <para>
/// Detail level of the performance items to return. All items that are of the specified detail level or less will be returned (the
/// levels are listed in increasing order). This parameter can be one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PERF_DETAIL_NOVICE</term>
/// <term>Novice user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_ADVANCED</term>
/// <term>Advanced user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_EXPERT</term>
/// <term>Expert user level of detail.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_WIZARD</term>
/// <term>System designer level of detail.</term>
/// </item>
/// </list>
/// </param>
/// <param name="bRefresh">
/// <para>Indicates if the cached object list should be automatically refreshed. Specify one of the following values.</para>
/// <para>
/// If you call this function twice, once to get the size of the list and a second time to get the actual list, set this parameter to
/// <c>TRUE</c> on the first call and <c>FALSE</c> on the second call. If both calls are <c>TRUE</c>, the second call may also return
/// PDH_MORE_DATA because the object data may have changed between calls.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>TRUE</term>
/// <term>The object cache is automatically refreshed before the objects are returned.</term>
/// </item>
/// <item>
/// <term>FALSE</term>
/// <term>Do not automatically refresh the cache.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The mszObjectList buffer is too small to hold the list of objects. This return value is expected if pcchBufferLength is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified object could not be found.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set mszObjectList to <c>NULL</c> and
/// pcchBufferLength to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenumobjectsha PDH_FUNCTION PdhEnumObjectsHA( PDH_HLOG
// hDataSource, LPCSTR szMachineName, PZZSTR mszObjectList, LPDWORD pcchBufferSize, DWORD dwDetailLevel, BOOL bRefresh );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "8f68a7a8-cc56-4f7f-a86f-4b439738808d")]
public static extern Win32Error PdhEnumObjectsH([Optional] PDH_HLOG hDataSource, [Optional] string szMachineName, [Optional] IntPtr mszObjectList, ref uint pcchBufferSize, PERF_DETAIL dwDetailLevel, [MarshalAs(UnmanagedType.Bool)] bool bRefresh);
/// <summary>
/// <para>
/// Examines the specified computer (or local computer if none is specified) for counters and instances of counters that match the
/// wildcard strings in the counter path.
/// </para>
/// <para><c>Note</c> This function is superseded by the PdhExpandWildCardPath function.</para>
/// </summary>
/// <param name="szWildCardPath">
/// <c>Null</c>-terminated string that contains the counter path to expand. The function searches the computer specified in the path
/// for matches. If the path does not specify a computer, the function searches the local computer. The maximum length of a counter
/// path is PDH_MAX_COUNTER_PATH.
/// </param>
/// <param name="mszExpandedPathList">
/// Caller-allocated buffer that receives the list of expanded counter paths that match the wildcard specification in szWildCardPath.
/// Each counter path in this list is terminated by a <c>null</c> character. The list is terminated with two <c>NULL</c> characters.
/// Set to <c>NULL</c> if pcchPathListLength is zero.
/// </param>
/// <param name="pcchPathListLength">
/// <para>
/// Size of the mszExpandedPathList buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </para>
/// <para><c>Note</c> You must add one to the required size on Windows XP.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The mszExpandedPathList buffer is too small to contain the list of paths. This return value is expected if pcchPathListLength is
/// zero on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory to support this function.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set mszExpandedPathList to <c>NULL</c> and
/// pcchPathListLength to 0), and the second time to get the data.
/// </para>
/// <para>The general counter path format is as follows:</para>
/// <para>\computer\object(parent/instance#index)\counter</para>
/// <para>
/// The parent, instance, index, and counter components of the counter path may contain either a valid name or a wildcard character.
/// The computer, parent, instance, and index components are not necessary for all counters.
/// </para>
/// <para>
/// The counter paths that you must use is determined by the counter itself. For example, the LogicalDisk object has an instance
/// index, so you must provide the #index, or a wildcard. Therefore, you could use the following format:
/// </para>
/// <para>\LogicalDisk(/#*)*</para>
/// <para>In comparison, the Process object does not require an instance index. Therefore, you could use the following format:</para>
/// <para>\Process(*)\ID Process</para>
/// <para>The following is a list of the possible formats:</para>
/// <list type="bullet">
/// <item>
/// <term>\\computer\object(parent/instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(parent/instance)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(instance)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object\counter</term>
/// </item>
/// <item>
/// <term>\object(parent/instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\object(parent/instance)\counter</term>
/// </item>
/// <item>
/// <term>\object(instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\object(instance)\counter</term>
/// </item>
/// <item>
/// <term>\object\counter</term>
/// </item>
/// </list>
/// <para>
/// If a wildcard character is specified in the parent name, all instances of the specified object that match the specified instance
/// and counter fields will be returned.
/// </para>
/// <para>
/// If a wildcard character is specified in the instance name, all instances of the specified object and parent object will be
/// returned if all instance names corresponding to the specified index match the wildcard character.
/// </para>
/// <para>If a wildcard character is specified in the counter name, all counters of the specified object are returned.</para>
/// <para>Partial counter path string matches (for example, "pro*") are not supported.</para>
/// <para>Examples</para>
/// <para>The following example demonstrates how to this function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhexpandcounterpatha PDH_FUNCTION PdhExpandCounterPathA( LPCSTR
// szWildCardPath, PZZSTR mszExpandedPathList, LPDWORD pcchPathListLength );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "d90954ab-ec2f-42fd-90b7-66f59f3d1115")]
public static extern Win32Error PdhExpandCounterPath(string szWildCardPath, [Optional] IntPtr mszExpandedPathList, ref uint pcchPathListLength);
/// <summary>
/// <para>
/// Examines the specified computer or log file and returns those counter paths that match the given counter path which contains
/// wildcard characters.
/// </para>
/// <para>To use handles to data sources, use the PdhExpandWildCardPathH function.</para>
/// </summary>
/// <param name="szDataSource">
/// <para>
/// <c>Null</c>-terminated string that contains the name of a log file. The function uses the performance objects and counters
/// defined in the log file to expand the path specified in the szWildCardPath parameter.
/// </para>
/// <para>If <c>NULL</c>, the function searches the computer specified in szWildCardPath.</para>
/// </param>
/// <param name="szWildCardPath">
/// <para><c>Null</c>-terminated string that specifies the counter path to expand. The maximum length of a counter path is PDH_MAX_COUNTER_PATH.</para>
/// <para>
/// If the szDataSource parameter is <c>NULL</c>, the function searches the computer specified in the path for matches. If the path
/// does not specify a computer, the function searches the local computer.
/// </para>
/// </param>
/// <param name="mszExpandedPathList">
/// Caller-allocated buffer that receives a list of <c>null</c>-terminated counter paths that match the wildcard specification in the
/// szWildCardPath. The list is terminated by two <c>NULL</c> characters. Set to <c>NULL</c> if pcchPathListLength is zero.
/// </param>
/// <param name="pcchPathListLength">
/// <para>
/// Size of the mszExpandedPathList buffer, in <c>TCHARs</c>. If zero on input and the object exists, the function returns
/// PDH_MORE_DATA and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function
/// sets this parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less
/// than the required size, you should not rely on the returned size to reallocate the buffer.
/// </para>
/// <para><c>Note</c> You must add one to the required size on Windows XP.</para>
/// </param>
/// <param name="dwFlags">
/// <para>Flags that indicate which wildcard characters not to expand. You can specify one or more flags.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_NOEXPANDCOUNTERS</term>
/// <term>Do not expand the counter name if the path contains a wildcard character for counter name.</term>
/// </item>
/// <item>
/// <term>PDH_NOEXPANDINSTANCES</term>
/// <term>
/// Do not expand the instance name if the path contains a wildcard character for parent instance, instance name, or instance index.
/// </term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The mszExpandedPathList buffer is not large enough to contain the list of paths. This return value is expected if
/// pcchPathListLength is zero on input. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_PATH</term>
/// <term>The specified object does not contain an instance.</term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory to support this function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>Unable to find the specified object on the computer or in the log file.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set mszExpandedPathList to <c>NULL</c> and
/// pcchPathListLength to 0), and the second time to get the data.
/// </para>
/// <para><c>PdhExpandWildCardPath</c> differs from PdhExpandCounterPath in the following ways:</para>
/// <list type="number">
/// <item>
/// <term>Lets you control which wildcard characters are expanded.</term>
/// </item>
/// <item>
/// <term>The contents of a log file can be used as the source of counter names.</term>
/// </item>
/// </list>
/// <para>The general counter path format is as follows:</para>
/// <para>\computer\object(parent/instance#index)\counter</para>
/// <para>
/// The parent, instance, index, and counter components of the counter path may contain either a valid name or a wildcard character.
/// The computer, parent, instance, and index components are not necessary for all counters.
/// </para>
/// <para>The following is a list of the possible formats:</para>
/// <list type="bullet">
/// <item>
/// <term>\\computer\object(parent/instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(parent/instance)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(instance)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object\counter</term>
/// </item>
/// <item>
/// <term>\object(parent/instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\object(parent/instance)\counter</term>
/// </item>
/// <item>
/// <term>\object(instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\object(instance)\counter</term>
/// </item>
/// <item>
/// <term>\object\counter</term>
/// </item>
/// </list>
/// <para>Use an asterisk (*) as the wildcard character, for example, \object(*)\counter.</para>
/// <para>
/// If a wildcard character is specified in the parent name, all instances of the specified object that match the specified instance
/// and counter fields will be returned. For example, \object(*/instance)\counter.
/// </para>
/// <para>
/// If a wildcard character is specified in the instance name, all instances of the specified object and parent object will be
/// returned if all instance names corresponding to the specified index match the wildcard character. For example,
/// \object(parent/*)\counter. If the object does not contain an instance, an error occurs.
/// </para>
/// <para>If a wildcard character is specified in the counter name, all counters of the specified object are returned.</para>
/// <para>Partial counter path string matches (for example, "pro*") are supported.</para>
/// <para><c>Prior to Windows Vista:</c> Partial wildcard matches are not supprted.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhexpandwildcardpatha PDH_FUNCTION PdhExpandWildCardPathA( LPCSTR
// szDataSource, LPCSTR szWildCardPath, PZZSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "415da310-de56-4d58-8959-231426867526")]
public static extern Win32Error PdhExpandWildCardPath([Optional] string szDataSource, string szWildCardPath, [Optional] IntPtr mszExpandedPathList, ref uint pcchPathListLength, PdhExpandFlags dwFlags);
/// <summary>
/// <para>
/// Examines the specified computer or log file and returns those counter paths that match the given counter path which contains
/// wildcard characters.
/// </para>
/// <para>This function is identical to the PdhExpandWildCardPath function, except that it supports the use of handles to data sources.</para>
/// </summary>
/// <param name="hDataSource">Handle to a data source returned by the PdhBindInputDataSource function.</param>
/// <param name="szWildCardPath">
/// <para><c>Null</c>-terminated string that specifies the counter path to expand. The maximum length of a counter path is PDH_MAX_COUNTER_PATH.</para>
/// <para>
/// If hDataSource is a real time data source, the function searches the computer specified in the path for matches. If the path does
/// not specify a computer, the function searches the local computer.
/// </para>
/// </param>
/// <param name="mszExpandedPathList">
/// Caller-allocated buffer that receives a list of <c>null</c>-terminated counter paths that match the wildcard specification in the
/// szWildCardPath. The list is terminated by two <c>NULL</c> characters. Set to <c>NULL</c> if pcchPathListLength is zero.
/// </param>
/// <param name="pcchPathListLength">
/// <para>
/// Size of the mszExpandedPathList buffer, in <c>TCHARs</c>. If zero on input and the object exists, the function returns
/// PDH_MORE_DATA and sets this parameter to the required buffer size. If the buffer is larger than the required size, the function
/// sets this parameter to the actual size of the buffer that was used. If the specified size on input is greater than zero but less
/// than the required size, you should not rely on the returned size to reallocate the buffer.
/// </para>
/// <para><c>Note</c> You must add one to the required size on Windows XP.</para>
/// </param>
/// <param name="dwFlags">
/// <para>Flags that indicate which wildcard characters not to expand. You can specify one or more flags.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_NOEXPANDCOUNTERS</term>
/// <term>Do not expand the counter name if the path contains a wildcard character for counter name.</term>
/// </item>
/// <item>
/// <term>PDH_NOEXPANDINSTANCES</term>
/// <term>
/// Do not expand the instance name if the path contains a wildcard character for parent instance, instance name, or instance index.
/// </term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The mszExpandedPathList buffer is not large enough to contain the list of paths. This return value is expected if
/// pcchPathListLength is zero on input. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory to support this function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>Unable to find the specified object on the computer or in the log file.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set mszExpandedPathList to <c>NULL</c> and
/// pcchPathListLength to 0), and the second time to get the data.
/// </para>
/// <para><c>PdhExpandWildCardPathH</c> differs from PdhExpandCounterPath in the following ways:</para>
/// <list type="number">
/// <item>
/// <term>Lets you control which wildcard characters are expanded.</term>
/// </item>
/// <item>
/// <term>The contents of a log file can be used as the source of counter names.</term>
/// </item>
/// </list>
/// <para>The general counter path format is as follows:</para>
/// <para>\computer\object(parent/instance#index)\counter</para>
/// <para>
/// The parent, instance, index, and counter components of the counter path may contain either a valid name or a wildcard character.
/// The computer, parent, instance, and index components are not necessary for all counters.
/// </para>
/// <para>The following is a list of the possible formats:</para>
/// <list type="bullet">
/// <item>
/// <term>\\computer\object(parent/instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(parent/instance)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object(instance)\counter</term>
/// </item>
/// <item>
/// <term>\\computer\object\counter</term>
/// </item>
/// <item>
/// <term>\object(parent/instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\object(parent/instance)\counter</term>
/// </item>
/// <item>
/// <term>\object(instance#index)\counter</term>
/// </item>
/// <item>
/// <term>\object(instance)\counter</term>
/// </item>
/// <item>
/// <term>\object\counter</term>
/// </item>
/// </list>
/// <para>Use an asterisk (*) as the wildcard character, for example, \object(*)\counter.</para>
/// <para>
/// If a wildcard character is specified in the parent name, all instances of the specified object that match the specified instance
/// and counter fields will be returned. For example, \object(*/instance)\counter.
/// </para>
/// <para>
/// If a wildcard character is specified in the instance name, all instances of the specified object and parent object will be
/// returned if all instance names corresponding to the specified index match the wildcard character. For example, \object(parent/*)\counter.
/// </para>
/// <para>If a wildcard character is specified in the counter name, all counters of the specified object are returned.</para>
/// <para>Partial counter path string matches (for example, "pro*") are supported.</para>
/// <para><c>Prior to Windows Vista:</c> Partial wildcard matches are not supprted.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhexpandwildcardpathha PDH_FUNCTION PdhExpandWildCardPathHA(
// PDH_HLOG hDataSource, LPCSTR szWildCardPath, PZZSTR mszExpandedPathList, LPDWORD pcchPathListLength, DWORD dwFlags );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "d7d13beb-02ab-4204-808e-d395197f09e1")]
public static extern Win32Error PdhExpandWildCardPathH([Optional] PDH_HLOG hDataSource, string szWildCardPath, [Optional] IntPtr mszExpandedPathList, ref uint pcchPathListLength, PdhExpandFlags dwFlags);
/// <summary>Computes a displayable value for the given raw counter values.</summary>
/// <param name="dwCounterType">
/// <para>
/// Type of counter. Typically, you call PdhGetCounterInfo to retrieve the counter type at the time you call PdhGetRawCounterValue to
/// retrieve the raw counter value.
/// </para>
/// <para>
/// For a list of counter types, see the Counter Types section of the Windows Server 2003 Deployment Kit. (The constant values are
/// defined in Winperf.h.)
/// </para>
/// <para>Note that you cannot specify base types, for example, PERF_LARGE_RAW_BASE.</para>
/// </param>
/// <param name="dwFormat">
/// <para>Determines the data type of the calculated value. Specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_DOUBLE</term>
/// <term>Return the calculated value as a double-precision floating point real.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LARGE</term>
/// <term>Return the calculated value as a 64-bit integer.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LONG</term>
/// <term>Return the calculated value as a long integer.</term>
/// </item>
/// </list>
/// <para>You can use the bitwise inclusive OR operator (|) to combine the data type with one of the following scaling factors.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_NOSCALE</term>
/// <term>Do not apply the counter's scaling factor in the calculation.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_NOCAP100</term>
/// <term>
/// Counter values greater than 100 (for example, counter values measuring the processor load on multiprocessor computers) will not
/// be reset to 100. The default behavior is that counter values are capped at a value of 100.
/// </term>
/// </item>
/// <item>
/// <term>PDH_FMT_1000</term>
/// <term>Multiply the final value by 1,000.</term>
/// </item>
/// </list>
/// </param>
/// <param name="pTimeBase">
/// Pointer to the time base, if necessary for the format conversion. If time base information is not necessary for the format
/// conversion, the value of this parameter is ignored. To retrieve the time base of the counter, call PdhGetCounterTimeBase.
/// </param>
/// <param name="pRawValue1">Raw counter value used to compute the displayable counter value. For details, see PDH_RAW_COUNTER.</param>
/// <param name="pRawValue2">
/// Raw counter value used to compute the displayable counter value. For details, see PDH_RAW_COUNTER. Some counters, for example,
/// rate counters, require two raw values to calculate a displayable value. If the counter type does not require a second value, set
/// this parameter to <c>NULL</c>. This value must be the older of the two raw values.
/// </param>
/// <param name="pFmtValue">A PDH_FMT_COUNTERVALUE structure that receives the calculated counter value.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhformatfromrawvalue PDH_FUNCTION PdhFormatFromRawValue( DWORD
// dwCounterType, DWORD dwFormat, LONGLONG *pTimeBase, PPDH_RAW_COUNTER pRawValue1, PPDH_RAW_COUNTER pRawValue2,
// PPDH_FMT_COUNTERVALUE pFmtValue );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "13027af4-2e76-4c2f-88e8-a2554a16fae3")]
public static extern Win32Error PdhFormatFromRawValue(CounterType dwCounterType, PDH_FMT dwFormat, in FILETIME pTimeBase, in PDH_RAW_COUNTER pRawValue1, in PDH_RAW_COUNTER pRawValue2, out PDH_FMT_COUNTERVALUE pFmtValue);
/// <summary>Retrieves information about a counter, such as data size, counter type, path, and user-supplied data values.</summary>
/// <param name="hCounter">
/// Handle of the counter from which you want to retrieve information. The PdhAddCounter function returns this handle.
/// </param>
/// <param name="bRetrieveExplainText">
/// Determines whether explain text is retrieved. If you set this parameter to <c>TRUE</c>, the explain text for the counter is
/// retrieved. If you set this parameter to <c>FALSE</c>, the field in the returned buffer is <c>NULL</c>.
/// </param>
/// <param name="pdwBufferSize">
/// Size of the lpBuffer buffer, in bytes. If zero on input, the function returns PDH_MORE_DATA and sets this parameter to the
/// required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size of the
/// buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not rely on
/// the returned size to reallocate the buffer.
/// </param>
/// <param name="lpBuffer">
/// Caller-allocated buffer that receives a <see cref="PDH_COUNTER_INFO"/> structure. The structure is variable-length, because the
/// string data is appended to the end of the fixed-format portion of the structure. This is done so that all data is returned in a
/// single buffer allocated by the caller. Set to <c>NULL</c> if pdwBufferSize is zero.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid or is incorrectly formatted. For example, on some releases you could receive this error if the specified
/// size on input is greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The lpBuffer buffer is too small to hold the counter information. This return value is expected if pdwBufferSize is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set lpBuffer to <c>NULL</c> and
/// pdwBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetcounterinfoa PDH_FUNCTION PdhGetCounterInfoA( PDH_HCOUNTER
// hCounter, BOOLEAN bRetrieveExplainText, LPDWORD pdwBufferSize, PPDH_COUNTER_INFO_A lpBuffer );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "12e1a194-5418-4c2a-9853-ef2d2c666893")]
public static extern Win32Error PdhGetCounterInfo(PDH_HCOUNTER hCounter, [MarshalAs(UnmanagedType.U1)] bool bRetrieveExplainText, ref uint pdwBufferSize, IntPtr lpBuffer);
/// <summary>Returns the time base of the specified counter.</summary>
/// <param name="hCounter">Handle to the counter. The PdhAddCounter function returns this handle.</param>
/// <param name="pTimeBase">Time base that specifies the number of performance values a counter samples per second.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>The specified counter does not use a time base.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// If you use the PdhFormatFromRawValue function to calculate a displayable value instead of calling the
/// PdhCalculateCounterFromRawValue function, you must call the <c>PdhGetCounterTimeBase</c> function to retrieve the time base.
/// </para>
/// <para>
/// Each counter that returns time-based performance data has a time base defined for it. The time base of a counter is the number of
/// times a counter samples data per second.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetcountertimebase PDH_FUNCTION PdhGetCounterTimeBase(
// PDH_HCOUNTER hCounter, LONGLONG *pTimeBase );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "b034c00e-50f1-46af-aebc-0cb968c0b737")]
public static extern Win32Error PdhGetCounterTimeBase(PDH_HCOUNTER hCounter, out FILETIME pTimeBase);
/// <summary>
/// <para>
/// Determines the time range, number of entries and, if applicable, the size of the buffer containing the performance data from the
/// specified input source.
/// </para>
/// <para>To use handles to data sources, use the PdhGetDataSourceTimeRangeH function.</para>
/// </summary>
/// <param name="szDataSource">
/// Null-terminated string that specifies the name of a log file from which the time range information is retrieved.
/// </param>
/// <param name="pdwNumEntries">
/// Number of structures in the pInfo buffer. This function collects information for only one time range, so the value is typically
/// 1, or zero if an error occurred.
/// </param>
/// <param name="pInfo">A PDH_TIME_INFO structure that receives the time range.</param>
/// <param name="pdwBufferSize">Size of the PDH_TIME_INFO structure, in bytes.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>A parameter is not valid or is incorrectly formatted.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_DATA_SOURCE_IS_REAL_TIME</term>
/// <term>The current data source is a real-time data source.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetdatasourcetimerangea PDH_FUNCTION PdhGetDataSourceTimeRangeA(
// LPCSTR szDataSource, LPDWORD pdwNumEntries, PPDH_TIME_INFO pInfo, LPDWORD pdwBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "142ee829-7f1c-4b97-859c-670f7058dfa1")]
public static extern Win32Error PdhGetDataSourceTimeRange(string szDataSource, out uint pdwNumEntries, out PDH_TIME_INFO pInfo, ref uint pdwBufferSize);
/// <summary>
/// <para>
/// Determines the time range, number of entries and, if applicable, the size of the buffer containing the performance data from the
/// specified input source.
/// </para>
/// <para>
/// This function is identical to the PdhGetDataSourceTimeRange function, except that it supports the use of handles to data sources.
/// </para>
/// </summary>
/// <param name="hDataSource">Handle to a data source returned by the PdhBindInputDataSource function.</param>
/// <param name="pdwNumEntries">
/// Number of structures in the pInfo buffer. This function collects information for only one time range, so the value is typically
/// 1, or zero if an error occurred.
/// </param>
/// <param name="pInfo">A PDH_TIME_INFO structure that receives the time range. The information spans all bound log files.</param>
/// <param name="pdwBufferSize">Size of the PDH_TIME_INFO structure, in bytes.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>A parameter is not valid or is incorrectly formatted.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_DATA_SOURCE_IS_REAL_TIME</term>
/// <term>The current data source is a real-time data source.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetdatasourcetimerangeh PDH_FUNCTION PdhGetDataSourceTimeRangeH(
// PDH_HLOG hDataSource, LPDWORD pdwNumEntries, PPDH_TIME_INFO pInfo, LPDWORD pdwBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "55cfef46-999d-43fa-9b09-9d8916fbf755")]
public static extern Win32Error PdhGetDataSourceTimeRangeH(PDH_HLOG hDataSource, out uint pdwNumEntries, out PDH_TIME_INFO pInfo, ref uint pdwBufferSize);
/// <summary>
/// <para>
/// Retrieves the name of the default counter for the specified object. This name can be used to set the initial counter selection in
/// the Browse Counter dialog box.
/// </para>
/// <para>To use handles to data sources, use the PdhGetDefaultPerfCounterH function.</para>
/// </summary>
/// <param name="szDataSource">Should be <c>NULL</c>.</param>
/// <param name="szMachineName">
/// <c>Null</c>-terminated string that specifies the name of the computer used to verify the object name. If <c>NULL</c>, the local
/// computer is used to verify the object name.
/// </param>
/// <param name="szObjectName">
/// <c>Null</c>-terminated string that specifies the name of the object whose default counter name you want to retrieve.
/// </param>
/// <param name="szDefaultCounterName">
/// Caller-allocated buffer that receives the <c>null</c>-terminated default counter name. Set to <c>NULL</c> if pcchBufferSize is zero.
/// </param>
/// <param name="pcchBufferSize">
/// Size of the szDefaultCounterName buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The szDefaultCounterName buffer is too small to contain the counter name. This return value is expected if pcchBufferSize is zero
/// on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A required parameter is not valid. For example, on some releases you could receive this error if the specified size on input is
/// greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory in order to complete the function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTERNAME</term>
/// <term>The default counter name cannot be read or found.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified object could not be found.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTER</term>
/// <term>The object did not specify a default counter.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set szDefaultCounterName to <c>NULL</c> and
/// pcchBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetdefaultperfcountera PDH_FUNCTION PdhGetDefaultPerfCounterA(
// LPCSTR szDataSource, LPCSTR szMachineName, LPCSTR szObjectName, LPSTR szDefaultCounterName, LPDWORD pcchBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "0eb78071-3496-40e9-91b0-3c06547c88d5")]
public static extern Win32Error PdhGetDefaultPerfCounter([Optional] string szDataSource, [Optional] string szMachineName, string szObjectName, [Optional] StringBuilder szDefaultCounterName, ref uint pcchBufferSize);
/// <summary>
/// <para>
/// Retrieves the name of the default counter for the specified object. This name can be used to set the initial counter selection in
/// the Browse Counter dialog box.
/// </para>
/// <para>This function is identical to PdhGetDefaultPerfCounter, except that it supports the use of handles to data sources.</para>
/// </summary>
/// <param name="hDataSource">Should be <c>NULL</c>.</param>
/// <param name="szMachineName">
/// <c>Null</c>-terminated string that specifies the name of the computer used to verify the object name. If <c>NULL</c>, the local
/// computer is used to verify the name.
/// </param>
/// <param name="szObjectName">
/// <c>Null</c>-terminated string that specifies the name of the object whose default counter name you want to retrieve.
/// </param>
/// <param name="szDefaultCounterName">
/// Caller-allocated buffer that receives the <c>null</c>-terminated default counter name. Set to <c>NULL</c> if pcchBufferSize is zero.
/// </param>
/// <param name="pcchBufferSize">
/// Size of the szDefaultCounterName buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The szDefaultCounterName buffer is too small to contain the counter name. This return value is expected if pcchBufferSize is zero
/// on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A required parameter is not valid. For example, on some releases you could receive this error if the specified size on input is
/// greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory in order to complete the function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTERNAME</term>
/// <term>The default counter name cannot be read or found.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified object could not be found.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTER</term>
/// <term>The object did not specify a default counter.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set szDefaultCounterName to <c>NULL</c> and
/// pcchBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetdefaultperfcounterha PDH_FUNCTION PdhGetDefaultPerfCounterHA(
// PDH_HLOG hDataSource, LPCSTR szMachineName, LPCSTR szObjectName, LPSTR szDefaultCounterName, LPDWORD pcchBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "d1b3de9a-99ab-4339-8e9f-906f5a5d291d")]
public static extern Win32Error PdhGetDefaultPerfCounterH([Optional] PDH_HLOG hDataSource, [Optional] string szMachineName, string szObjectName, [Optional] StringBuilder szDefaultCounterName, ref uint pcchBufferSize);
/// <summary>
/// <para>
/// Retrieves the name of the default object. This name can be used to set the initial object selection in the Browse Counter dialog box.
/// </para>
/// <para>To use handles to data sources, use the PdhGetDefaultPerfObjectH function.</para>
/// </summary>
/// <param name="szDataSource">Should be <c>NULL</c>.</param>
/// <param name="szMachineName">
/// <c>Null</c>-terminated string that specifies the name of the computer used to verify the object name. If <c>NULL</c>, the local
/// computer is used to verify the name.
/// </param>
/// <param name="szDefaultObjectName">
/// <para>
/// Caller-allocated buffer that receives the <c>null</c>-terminated default object name. Set to <c>NULL</c> if the pcchBufferSize
/// parameter is zero.
/// </para>
/// <para>Note that PDH always returns Processor for the default object name.</para>
/// </param>
/// <param name="pcchBufferSize">
/// Size of the szDefaultObjectName buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The szDefaultObjectName buffer is too small to contain the object name. This return value is expected if pcchBufferSize is zero
/// on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A required parameter is not valid. For example, on some releases you could receive this error if the specified size on input is
/// greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory in order to complete the function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set szDefaultObjectName to <c>NULL</c> and
/// pcchBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetdefaultperfobjecta PDH_FUNCTION PdhGetDefaultPerfObjectA(
// LPCSTR szDataSource, LPCSTR szMachineName, LPSTR szDefaultObjectName, LPDWORD pcchBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "7c6d4d82-8b60-4422-8108-8ac10f254278")]
public static extern Win32Error PdhGetDefaultPerfObject([Optional] string szDataSource, [Optional] string szMachineName, [Optional] StringBuilder szDefaultObjectName, ref uint pcchBufferSize);
/// <summary>
/// <para>
/// Retrieves the name of the default object. This name can be used to set the initial object selection in the Browse Counter dialog box.
/// </para>
/// <para>
/// This function is identical to the PdhGetDefaultPerfObject function, except that it supports the use of handles to data sources.
/// </para>
/// </summary>
/// <param name="hDataSource">Should be <c>NULL</c>.</param>
/// <param name="szMachineName">
/// <c>Null</c>-terminated string that specifies the name of the computer used to verify the object name. If <c>NULL</c>, the local
/// computer is used to verify the name.
/// </param>
/// <param name="szDefaultObjectName">
/// <para>
/// Caller-allocated buffer that receives the <c>null</c>-terminated default object name. Set to <c>NULL</c> if pcchBufferSize is zero.
/// </para>
/// <para>Note that PDH always returns Processor for the default object name.</para>
/// </param>
/// <param name="pcchBufferSize">
/// Size of the szDefaultObjectName buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The szDefaultObjectName buffer is too small to contain the object name. This return value is expected if pcchBufferSize is zero
/// on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A required parameter is not valid. For example, on some releases you could receive this error if the specified size on input is
/// greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory in order to complete the function.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer is offline or unavailable.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTERNAME</term>
/// <term>The default object name cannot be read or found.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set szDefaultObjectName to <c>NULL</c> and
/// pcchBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetdefaultperfobjectha PDH_FUNCTION PdhGetDefaultPerfObjectHA(
// PDH_HLOG hDataSource, LPCSTR szMachineName, LPSTR szDefaultObjectName, LPDWORD pcchBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "4950d5b7-3a6f-410d-830f-7868aa84f6d5")]
public static extern Win32Error PdhGetDefaultPerfObjectH([Optional] PDH_HLOG hDataSource, [Optional] string szMachineName, [Optional] StringBuilder szDefaultObjectName, ref uint pcchBufferSize);
/// <summary>
/// <para>Returns the version of the currently installed Pdh.dll file.</para>
/// <para><c>Note</c> This function is obsolete and no longer supported.</para>
/// </summary>
/// <param name="lpdwVersion">
/// <para>Pointer to a variable that receives the version of Pdh.dll. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_CVERSION_WIN50</term>
/// <term>The file version is a legacy operating system.</term>
/// </item>
/// <item>
/// <term>PDH_VERSION</term>
/// <term>The file version is Windows XP.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// </returns>
/// <remarks>This function is used to help in determining the functionality that the currently installed version of Pdh.dll supports.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetdllversion PDH_FUNCTION PdhGetDllVersion( LPDWORD lpdwVersion );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "09c9ecf6-43e0-480c-b607-537632b56576")]
public static extern Win32Error PdhGetDllVersion(out uint lpdwVersion);
/// <summary>
/// Returns an array of formatted counter values. Use this function when you want to format the counter values of a counter that
/// contains a wildcard character for the instance name.
/// </summary>
/// <param name="hCounter">
/// Handle to the counter whose current value you want to format. The PdhAddCounter function returns this handle.
/// </param>
/// <param name="dwFormat">
/// <para>Determines the data type of the formatted value. Specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_DOUBLE</term>
/// <term>Return data as a double-precision floating point real.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LARGE</term>
/// <term>Return data as a 64-bit integer.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LONG</term>
/// <term>Return data as a long integer.</term>
/// </item>
/// </list>
/// <para>You can use the bitwise inclusive OR operator (|) to combine the data type with one of the following scaling factors.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_NOSCALE</term>
/// <term>Do not apply the counter's default scaling factor.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_NOCAP100</term>
/// <term>
/// Counter values greater than 100 (for example, counter values measuring the processor load on multiprocessor computers) will not
/// be reset to 100. The default behavior is that counter values are capped at a value of 100.
/// </term>
/// </item>
/// <item>
/// <term>PDH_FMT_1000</term>
/// <term>Multiply the actual value by 1,000.</term>
/// </item>
/// </list>
/// </param>
/// <param name="lpdwBufferSize">
/// Size of the ItemBuffer buffer, in bytes. If zero on input, the function returns PDH_MORE_DATA and sets this parameter to the
/// required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size of the
/// buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not rely on
/// the returned size to reallocate the buffer.
/// </param>
/// <param name="lpdwItemCount">Number of counter values in the ItemBuffer buffer.</param>
/// <param name="ItemBuffer">
/// Caller-allocated buffer that receives an array of PDH_FMT_COUNTERVALUE_ITEM structures; the structures contain the counter
/// values. Set to <c>NULL</c> if lpdwBufferSize is zero.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The ItemBuffer buffer is not large enough to contain the object name. This return value is expected if lpdwBufferSize is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid or is incorrectly formatted. For example, on some releases you could receive this error if the specified
/// size on input is greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set ItemBuffer to <c>NULL</c> and
/// lpdwBufferSize to 0), and the second time to get the data.
/// </para>
/// <para>
/// The data for the counter is locked for the duration of the call to <c>PdhGetFormattedCounterArray</c> to prevent any changes
/// during the processing of the call.
/// </para>
/// <para>Examples</para>
/// <para>The following example shows how to use this function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetformattedcounterarraya PDH_FUNCTION
// PdhGetFormattedCounterArrayA( PDH_HCOUNTER hCounter, DWORD dwFormat, LPDWORD lpdwBufferSize, LPDWORD lpdwItemCount,
// PPDH_FMT_COUNTERVALUE_ITEM_A ItemBuffer );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "0f388c7e-d0c8-461d-908c-48af92166996")]
public static extern Win32Error PdhGetFormattedCounterArray(PDH_HCOUNTER hCounter, PDH_FMT dwFormat, ref uint lpdwBufferSize, out uint lpdwItemCount, [Optional] IntPtr ItemBuffer);
/// <summary>Computes a displayable value for the specified counter.</summary>
/// <param name="hCounter">
/// Handle of the counter for which you want to compute a displayable value. The PdhAddCounter function returns this handle.
/// </param>
/// <param name="dwFormat">
/// <para>Determines the data type of the formatted value. Specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_DOUBLE</term>
/// <term>Return data as a double-precision floating point real.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LARGE</term>
/// <term>Return data as a 64-bit integer.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_LONG</term>
/// <term>Return data as a long integer.</term>
/// </item>
/// </list>
/// <para>You can use the bitwise inclusive OR operator (|) to combine the data type with one of the following scaling factors.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FMT_NOSCALE</term>
/// <term>Do not apply the counter's default scaling factor.</term>
/// </item>
/// <item>
/// <term>PDH_FMT_NOCAP100</term>
/// <term>
/// Counter values greater than 100 (for example, counter values measuring the processor load on multiprocessor computers) will not
/// be reset to 100. The default behavior is that counter values are capped at a value of 100.
/// </term>
/// </item>
/// <item>
/// <term>PDH_FMT_1000</term>
/// <term>Multiply the actual value by 1,000.</term>
/// </item>
/// </list>
/// </param>
/// <param name="lpdwType">
/// Receives the counter type. For a list of counter types, see the Counter Types section of the Windows Server 2003 Deployment Kit.
/// This parameter is optional.
/// </param>
/// <param name="pValue">A PDH_FMT_COUNTERVALUE structure that receives the counter value.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>A parameter is not valid or is incorrectly formatted.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_DATA</term>
/// <term>The specified counter does not contain valid data or a successful status code.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// The data for the counter is locked (protected) for the duration of the call to <c>PdhGetFormattedCounterValue</c> to prevent any
/// changes during the processing of the call. Reading the data (calling this function successfully) clears the data-changed flag for
/// the counter.
/// </para>
/// <para>
/// Some counters, such as rate counters, require two counter values in order to compute a displayable value. In this case you must
/// call PdhCollectQueryData twice before calling <c>PdhGetFormattedCounterValue</c>. For more information, see Collecting
/// Performance Data.
/// </para>
/// <para>
/// If the specified counter instance does not exist, the method will return PDH_INVALID_DATA and set the <c>CStatus</c> member of
/// the PDH_FMT_COUNTERVALUE structure to PDH_CSTATUS_NO_INSTANCE.
/// </para>
/// <para>
/// <c>Prior to Windows Server 2003:</c> The format call may fail for counters that require only a single value when the instance is
/// not found. Try calling the query and format calls again. If the format call fails the second time, the instance is not found. As
/// an alternative, you can call the PdhEnumObjects function with the refresh option set to <c>TRUE</c> to refresh the counter
/// instances before querying and formatting the counter data.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Browsing Performance Counters or Reading Performance Data from a Log File.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetformattedcountervalue PDH_FUNCTION
// PdhGetFormattedCounterValue( PDH_HCOUNTER hCounter, DWORD dwFormat, LPDWORD lpdwType, PPDH_FMT_COUNTERVALUE pValue );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "cd104b26-1498-4f95-a411-97d868b43836")]
public static extern Win32Error PdhGetFormattedCounterValue(PDH_HCOUNTER hCounter, PDH_FMT dwFormat, out CounterType lpdwType, out PDH_FMT_COUNTERVALUE pValue);
/// <summary>Returns the size of the specified log file.</summary>
/// <param name="hLog">Handle to the log file. The PdhOpenLog or PdhBindInputDataSource function returns this handle.</param>
/// <param name="llSize">Size of the log file, in bytes.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_LOG_FILE_OPEN_ERROR</term>
/// <term>An error occurred when trying to open the log file.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// If the log file handle points to multiple bound log files, the size is the sum of all the log files. If the log file is a SQL log
/// file, the llSize parameter is the number of records in the log file.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetlogfilesize PDH_FUNCTION PdhGetLogFileSize( PDH_HLOG hLog,
// LONGLONG *llSize );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "2bb94019-c664-4144-98b6-a0a545f7e4c1")]
public static extern Win32Error PdhGetLogFileSize(PDH_HLOG hLog, out long llSize);
/// <summary>
/// Returns an array of raw values from the specified counter. Use this function when you want to retrieve the raw counter values of
/// a counter that contains a wildcard character for the instance name.
/// </summary>
/// <param name="hCounter">
/// Handle of the counter for whose current raw instance values you want to retrieve. The PdhAddCounter function returns this handle.
/// </param>
/// <param name="lpdwBufferSize">
/// Size of the ItemBuffer buffer, in bytes. If zero on input, the function returns PDH_MORE_DATA and sets this parameter to the
/// required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size of the
/// buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not rely on
/// the returned size to reallocate the buffer.
/// </param>
/// <param name="lpdwItemCount">Number of raw counter values in the ItemBuffer buffer.</param>
/// <param name="ItemBuffer">
/// Caller-allocated buffer that receives the array of <see cref="PDH_RAW_COUNTER_ITEM"/> structures; the structures contain the raw
/// instance counter values. Set to <c>NULL</c> if lpdwBufferSize is zero.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The ItemBuffer buffer is not large enough to contain the object name. This return value is expected if lpdwBufferSize is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid or is incorrectly formatted. For example, on some releases you could receive this error if the specified
/// size on input is greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set ItemBuffer to <c>NULL</c> and
/// lpdwBufferSize to 0), and the second time to get the data.
/// </para>
/// <para>
/// The data for the counter is locked for the duration of the call to <c>PdhGetRawCounterArray</c> to prevent any changes during
/// processing of the call.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetrawcounterarraya PDH_FUNCTION PdhGetRawCounterArrayA(
// PDH_HCOUNTER hCounter, LPDWORD lpdwBufferSize, LPDWORD lpdwItemCount, PPDH_RAW_COUNTER_ITEM_A ItemBuffer );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "03b30d08-6901-45cd-bd6d-d2672eb0f914")]
public static extern Win32Error PdhGetRawCounterArray(PDH_HCOUNTER hCounter, ref uint lpdwBufferSize, out uint lpdwItemCount, IntPtr ItemBuffer);
/// <summary>Returns the current raw value of the counter.</summary>
/// <param name="hCounter">
/// Handle of the counter from which to retrieve the current raw value. The PdhAddCounter function returns this handle.
/// </param>
/// <param name="lpdwType">
/// Receives the counter type. For a list of counter types, see the Counter Types section of the Windows Server 2003 Deployment Kit.
/// This parameter is optional.
/// </param>
/// <param name="pValue">A PDH_RAW_COUNTER structure that receives the counter value.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>A parameter is not valid or is incorrectly formatted.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// The data for the counter is locked (protected) for the duration of the call to <c>PdhGetRawCounterValue</c> to prevent any
/// changes during processing of the call.
/// </para>
/// <para>
/// If the specified counter instance does not exist, this function will return ERROR_SUCCESS and the <c>CStatus</c> member of the
/// PDH_RAW_COUNTER structure will contain PDH_CSTATUS_NO_INSTANCE.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetrawcountervalue PDH_FUNCTION PdhGetRawCounterValue(
// PDH_HCOUNTER hCounter, LPDWORD lpdwType, PPDH_RAW_COUNTER pValue );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "bb246c82-8748-4e2f-9f44-a206199aff90")]
public static extern Win32Error PdhGetRawCounterValue(PDH_HCOUNTER hCounter, out CounterType lpdwType, out PDH_RAW_COUNTER pValue);
/// <summary>Determines if the specified query is a real-time query.</summary>
/// <param name="hQuery">Handle to the query. The PdhOpenQuery function returns this handle.</param>
/// <returns>
/// <para>If the query is a real-time query, the return value is <c>TRUE</c>.</para>
/// <para>If the query is not a real-time query, the return value is <c>FALSE</c>.</para>
/// </returns>
/// <remarks>
/// The term real-time as used in the description of this function does not imply the standard meaning of the term real-time.
/// Instead, it describes the collection of performance data from a source providing current information (for example, the registry
/// or a WMI provider) rather than from a log file.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhisrealtimequery BOOL PdhIsRealTimeQuery( PDH_HQUERY hQuery );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "4f6b2d8d-3a0f-4346-8b8e-a7aea11fbc40")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PdhIsRealTimeQuery(PDH_HQUERY hQuery);
/// <summary>Returns the counter index corresponding to the specified counter name.</summary>
/// <param name="szMachineName">
/// <c>Null</c>-terminated string that specifies the name of the computer where the specified counter is located. The computer name
/// can be specified by the DNS name or the IP address. If <c>NULL</c>, the function uses the local computer.
/// </param>
/// <param name="szNameBuffer"><c>Null</c>-terminated string that contains the counter name.</param>
/// <param name="pdwIndex">Index of the counter.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following is a possible value.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>A parameter is not valid or is incorrectly formatted.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhlookupperfindexbynamea PDH_FUNCTION PdhLookupPerfIndexByNameA(
// LPCSTR szMachineName, LPCSTR szNameBuffer, LPDWORD pdwIndex );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "b8530bf3-0a9b-49c2-9494-4dca14cd57ef")]
public static extern Win32Error PdhLookupPerfIndexByName([Optional] string szMachineName, string szNameBuffer, out uint pdwIndex);
/// <summary>Returns the performance object name or counter name corresponding to the specified index.</summary>
/// <param name="szMachineName">
/// <c>Null</c>-terminated string that specifies the name of the computer where the specified performance object or counter is
/// located. The computer name can be specified by the DNS name or the IP address. If <c>NULL</c>, the function uses the local computer.
/// </param>
/// <param name="dwNameIndex">Index of the performance object or counter.</param>
/// <param name="szNameBuffer">
/// Caller-allocated buffer that receives the <c>null</c>-terminated name of the performance object or counter. Set to <c>NULL</c> if
/// pcchNameBufferSize is zero.
/// </param>
/// <param name="pcchNameBufferSize">
/// Size of the szNameBuffer buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this parameter
/// to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size
/// of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not
/// rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The szNameBuffer buffer is not large enough to contain the counter name. This return value is expected if pcchNameBufferSize is
/// zero on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid or is incorrectly formatted. For example, on some releases you could receive this error if the specified
/// size on input is greater than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// You should call this function twice, the first time to get the required buffer size (set szNameBuffer to <c>NULL</c> and
/// pcchNameBufferSize to 0), and the second time to get the data.
/// </para>
/// <para>
/// <c>Windows XP:</c> You must specify a buffer and buffer size. The function sets pcchNameBufferSize to either the required size or
/// the size of the buffer that was used. If the buffer is too small, the function returns PDH_INSUFFICIENT_BUFFER instead of
/// PDH_MORE_DATA. The maximum string size in bytes is PDH_MAX_COUNTER_NAME * sizeof(TCHAR).
/// </para>
/// <para>
/// The index value that you specify must match one of the index values associated with the objects or counters that were loaded on
/// the computer. The index/name value pairs are stored in the <c>Counters</c> registry value in the following registry location.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhlookupperfnamebyindexa PDH_FUNCTION PdhLookupPerfNameByIndexA(
// LPCSTR szMachineName, DWORD dwNameIndex, LPSTR szNameBuffer, LPDWORD pcchNameBufferSize );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "6d5e1465-296b-4d8c-b0cb-aefdffb8539e")]
public static extern Win32Error PdhLookupPerfNameByIndex([Optional] string szMachineName, uint dwNameIndex, [Optional] StringBuilder szNameBuffer, ref uint pcchNameBufferSize);
/// <summary>Creates a full counter path using the members specified in the PDH_COUNTER_PATH_ELEMENTS structure.</summary>
/// <param name="pCounterPathElements">
/// <para>
/// A PDH_COUNTER_PATH_ELEMENTS structure that contains the members used to make up the path. Only the <c>szObjectName</c> and
/// <c>szCounterName</c> members are required, the others are optional.
/// </para>
/// <para>
/// If the instance name member is <c>NULL</c>, the path will not contain an instance reference and the <c>szParentInstance</c> and
/// <c>dwInstanceIndex</c> members will be ignored.
/// </para>
/// </param>
/// <param name="szFullPathBuffer">
/// Caller-allocated buffer that receives a <c>null</c>-terminated counter path. The maximum length of a counter path is
/// PDH_MAX_COUNTER_PATH. Set to <c>NULL</c> if pcchBufferSize is zero.
/// </param>
/// <param name="pcchBufferSize">
/// Size of the szFullPathBuffer buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <param name="dwFlags">
/// <para>Format of the input and output counter values. You can specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_PATH_WBEM_RESULT</term>
/// <term>Converts a PDH path to the WMI class and property name format.</term>
/// </item>
/// <item>
/// <term>PDH_PATH_WBEM_INPUT</term>
/// <term>Converts the WMI class and property name to a PDH path.</term>
/// </item>
/// <item>
/// <term>0</term>
/// <term>Returns the path in the PDH format, for example, \\computer\object(parent/instance#index)\counter.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The szFullPathBuffer buffer is too small to contain the counter name. This return value is expected if pcchBufferSize is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid or is incorrectly formatted. For example, on some releases you could receive this error if the specified
/// size on input is greater than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set szFullPathBuffer to <c>NULL</c> and
/// pcchBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhmakecounterpatha PDH_FUNCTION PdhMakeCounterPathA(
// PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements, LPSTR szFullPathBuffer, LPDWORD pcchBufferSize, DWORD dwFlags );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "f2dc5f77-9f9e-4290-95fa-ce2f1e81fc69")]
public static extern Win32Error PdhMakeCounterPath(in PDH_COUNTER_PATH_ELEMENTS pCounterPathElements, [Optional] StringBuilder szFullPathBuffer, ref uint pcchBufferSize, [Optional] PDH_PATH dwFlags);
/// <summary>Creates a full counter path using the members specified in the PDH_COUNTER_PATH_ELEMENTS structure.</summary>
/// <param name="pCounterPathElements">
/// <para>
/// A PDH_COUNTER_PATH_ELEMENTS structure that contains the members used to make up the path. Only the <c>szObjectName</c> and
/// <c>szCounterName</c> members are required, the others are optional.
/// </para>
/// <para>
/// If the instance name member is <c>NULL</c>, the path will not contain an instance reference and the <c>szParentInstance</c> and
/// <c>dwInstanceIndex</c> members will be ignored.
/// </para>
/// </param>
/// <param name="szFullPathBuffer">
/// Caller-allocated buffer that receives a <c>null</c>-terminated counter path. The maximum length of a counter path is
/// PDH_MAX_COUNTER_PATH. Set to <c>NULL</c> if pcchBufferSize is zero.
/// </param>
/// <param name="pcchBufferSize">
/// Size of the szFullPathBuffer buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this
/// parameter to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the
/// actual size of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you
/// should not rely on the returned size to reallocate the buffer.
/// </param>
/// <param name="dwFlags">
/// <para>Format of the input and output counter values. You can specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_PATH_WBEM_RESULT</term>
/// <term>Converts a PDH path to the WMI class and property name format.</term>
/// </item>
/// <item>
/// <term>PDH_PATH_WBEM_INPUT</term>
/// <term>Converts the WMI class and property name to a PDH path.</term>
/// </item>
/// <item>
/// <term>0</term>
/// <term>Returns the path in the PDH format, for example, \\computer\object(parent/instance#index)\counter.</term>
/// </item>
/// </list>
/// </param>
/// <param name="langId">The language identifier to be used in creating the path.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The szFullPathBuffer buffer is too small to contain the counter name. This return value is expected if pcchBufferSize is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid or is incorrectly formatted. For example, on some releases you could receive this error if the specified
/// size on input is greater than zero but less than the required size.
/// </term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set szFullPathBuffer to <c>NULL</c> and
/// pcchBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhmakecounterpatha PDH_FUNCTION PdhMakeCounterPathA(
// PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements, LPSTR szFullPathBuffer, LPDWORD pcchBufferSize, DWORD dwFlags );
[PInvokeData("pdh.h", MSDNShortId = "f2dc5f77-9f9e-4290-95fa-ce2f1e81fc69")]
public static Win32Error PdhMakeCounterPath(in PDH_COUNTER_PATH_ELEMENTS pCounterPathElements, [Optional] StringBuilder szFullPathBuffer, ref uint pcchBufferSize, PDH_PATH dwFlags, ushort langId) =>
PdhMakeCounterPath(pCounterPathElements, szFullPathBuffer, ref pcchBufferSize, PDH_PATH_LANG_FLAGS(langId, dwFlags));
/// <summary>Opens the specified log file for reading or writing.</summary>
/// <param name="szLogFileName">
/// <para>
/// <c>Null</c>-terminated string that specifies the name of the log file to open. The name can contain an absolute or relative path.
/// </para>
/// <para>
/// If the lpdwLogType parameter is <c>PDH_LOG_TYPE_SQL</c>, specify the name of the log file in the form, <c>SQL:</c> DataSourceName
/// <c>!</c> LogFileName.
/// </para>
/// </param>
/// <param name="dwAccessFlags">
/// <para>Type of access to use to open the log file. Specify one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_LOG_READ_ACCESS</term>
/// <term>Open the log file for reading.</term>
/// </item>
/// <item>
/// <term>PDH_LOG_WRITE_ACCESS</term>
/// <term>Open a new log file for writing.</term>
/// </item>
/// <item>
/// <term>PDH_LOG_UPDATE_ACCESS</term>
/// <term>Open an existing log file for writing.</term>
/// </item>
/// </list>
/// <para>
/// You can use the bitwise inclusive <c>OR</c> operator (|) to combine the access type with one or more of the following creation flags.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_LOG_CREATE_NEW</term>
/// <term>Creates a new log file with the specified name.</term>
/// </item>
/// <item>
/// <term>PDH_LOG_CREATE_ALWAYS</term>
/// <term>
/// Creates a new log file with the specified name. If the log file already exists, the function removes the existing log file before
/// creating the new file.
/// </term>
/// </item>
/// <item>
/// <term>PDH_LOG_OPEN_EXISTING</term>
/// <term>
/// Opens an existing log file with the specified name. If a log file with the specified name does not exist, this is equal to PDH_LOG_CREATE_NEW.
/// </term>
/// </item>
/// <item>
/// <term>PDH_LOG_OPEN_ALWAYS</term>
/// <term>Opens an existing log file with the specified name or creates a new log file with the specified name.</term>
/// </item>
/// <item>
/// <term>PDH_LOG_OPT_CIRCULAR</term>
/// <term>
/// Creates a circular log file with the specified name. When the file reaches the value of the dwMaxSize parameter, data wraps to
/// the beginning of the log file. You can specify this flag only if the lpdwLogType parameter is PDH_LOG_TYPE_BINARY.
/// </term>
/// </item>
/// <item>
/// <term>PDH_LOG_USER_STRING</term>
/// <term>
/// Used with PDH_LOG_TYPE_TSV to write the user caption or log file description indicated by the szUserString parameter of
/// PdhUpdateLog or PdhOpenLog. The user caption or log file description is written as the last column in the first line of the text log.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="lpdwLogType">
/// <para>Type of log file to open. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_LOG_TYPE_UNDEFINED</term>
/// <term>
/// Undefined log file format. If specified, PDH determines the log file type. You cannot specify this value if the dwAccessFlags
/// parameter is PDH_LOG_WRITE_ACCESS.
/// </term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_CSV</term>
/// <term>
/// Text file containing column headers in the first line, and individual data records in each subsequent line. The fields of each
/// data record are comma-delimited. The first line also contains information about the format of the file, the PDH version used to
/// create the log file, and the names and paths of each of the counters.
/// </term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_SQL</term>
/// <term>The data source of the log file is an SQL database.</term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_TSV</term>
/// <term>
/// Text file containing column headers in the first line, and individual data records in each subsequent line. The fields of each
/// data record are tab-delimited. The first line also contains information about the format of the file, the PDH version used to
/// create the log file, and the names and paths of each of the counters.
/// </term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_BINARY</term>
/// <term>Binary log file format.</term>
/// </item>
/// </list>
/// </param>
/// <param name="hQuery">
/// <para>Specify a query handle if you are writing query data to a log file. The PdhOpenQuery function returns this handle.</para>
/// <para>This parameter is ignored and should be <c>NULL</c> if you are reading from the log file.</para>
/// </param>
/// <param name="dwMaxSize">
/// <para>
/// Maximum size of the log file, in bytes. Specify the maximum size if you want to limit the file size or if dwAccessFlags specifies
/// <c>PDH_LOG_OPT_CIRCULAR</c>; otherwise, set to 0.
/// </para>
/// <para>
/// For circular log files, you must specify a value large enough to hold at least one sample. Sample size depends on data being
/// collected. However, specifying a value of at least one megabyte will cover most samples.
/// </para>
/// </param>
/// <param name="szUserCaption">
/// <c>Null</c>-terminated string that specifies the user-defined caption of the log file. A log file caption generally describes the
/// contents of the log file. When an existing log file is opened, the value of this parameter is ignored.
/// </param>
/// <param name="phLog">Handle to the opened log file.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// </returns>
/// <remarks>
/// <para>
/// To use this function to write performance data to a log file, you must open a query using PdhOpenQuery and add the desired
/// counters to it, before calling this function.
/// </para>
/// <para>
/// Newer operating systems can read log files that were generated on older operating systems; however, log files that were created
/// on Windows Vista and later operating systems cannot be read on earlier operating systems.
/// </para>
/// <para>The following rules apply to log files</para>
/// <list type="bullet">
/// <item>
/// <term/>
/// </item>
/// <item>
/// <term/>
/// </item>
/// <item>
/// <term/>
/// </item>
/// </list>
/// <para>Examples</para>
/// <para>For an example, see Writing Performance Data to a Log File.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhopenloga PDH_FUNCTION PdhOpenLogA( LPCSTR szLogFileName, DWORD
// dwAccessFlags, LPDWORD lpdwLogType, PDH_HQUERY hQuery, DWORD dwMaxSize, LPCSTR szUserCaption, PDH_HLOG *phLog );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "a8457959-af3a-497f-91ca-0876cbb552cc")]
public static extern Win32Error PdhOpenLog(string szLogFileName, PdhLogAccess dwAccessFlags, ref PDH_LOG_TYPE lpdwLogType, [Optional] PDH_HQUERY hQuery, [Optional] uint dwMaxSize, [Optional] string szUserCaption, out SafePDH_HLOG phLog);
/// <summary>
/// <para>Creates a new query that is used to manage the collection of performance data.</para>
/// <para>To use handles to data sources, use the PdhOpenQueryH function.</para>
/// </summary>
/// <param name="szDataSource">
/// <c>Null</c>-terminated string that specifies the name of the log file from which to retrieve performance data. If <c>NULL</c>,
/// performance data is collected from a real-time data source.
/// </param>
/// <param name="dwUserData">
/// User-defined value to associate with this query. To retrieve the user data later, call PdhGetCounterInfo and access the
/// <c>dwQueryUserData</c> member of PDH_COUNTER_INFO.
/// </param>
/// <param name="phQuery">Handle to the query. You use this handle in subsequent calls.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhopenquerya PDH_FUNCTION PdhOpenQueryA( LPCSTR szDataSource,
// DWORD_PTR dwUserData, PDH_HQUERY *phQuery );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "ec4e5353-c7f5-4957-b7f4-39df508846a0")]
public static extern Win32Error PdhOpenQuery([Optional] string szDataSource, [Optional] IntPtr dwUserData, out SafePDH_HQUERY phQuery);
/// <summary>
/// <para>Creates a new query that is used to manage the collection of performance data.</para>
/// <para>This function is identical to the PdhOpenQuery function, except that it supports the use of handles to data sources.</para>
/// </summary>
/// <param name="hDataSource">Handle to a data source returned by the PdhBindInputDataSource function.</param>
/// <param name="dwUserData">
/// User-defined value to associate with this query. To retrieve the user data later, call the PdhGetCounterInfo function and access
/// the <c>dwQueryUserData</c> member of PDH_COUNTER_INFO.
/// </param>
/// <param name="phQuery">Handle to the query. You use this handle in subsequent calls.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhopenqueryh PDH_FUNCTION PdhOpenQueryH( PDH_HLOG hDataSource,
// DWORD_PTR dwUserData, PDH_HQUERY *phQuery );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "068c55da-d7e0-4111-91c8-a2bbd676f99d")]
public static extern Win32Error PdhOpenQueryH([Optional] PDH_HLOG hDataSource, [Optional] IntPtr dwUserData, out SafePDH_HQUERY phQuery);
/// <summary>Parses the elements of the counter path and stores the results in the PDH_COUNTER_PATH_ELEMENTS structure.</summary>
/// <param name="szFullPathBuffer">
/// <c>Null</c>-terminated string that contains the counter path to parse. The maximum length of a counter path is PDH_MAX_COUNTER_PATH.
/// </param>
/// <param name="pCounterPathElements">
/// Caller-allocated buffer that receives a PDH_COUNTER_PATH_ELEMENTS structure. The structure contains pointers to the individual
/// string elements of the path referenced by the szFullPathBuffer parameter. The function appends the strings to the end of the
/// <c>PDH_COUNTER_PATH_ELEMENTS</c> structure. The allocated buffer should be large enough for the structure and the strings. Set to
/// <c>NULL</c> if pdwBufferSize is zero.
/// </param>
/// <param name="pdwBufferSize">
/// Size of the pCounterPathElements buffer, in bytes. If zero on input, the function returns PDH_MORE_DATA and sets this parameter
/// to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size
/// of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not
/// rely on the returned size to reallocate the buffer.
/// </param>
/// <param name="dwFlags">Reserved. Must be zero.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>A parameter is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The pCounterPathElements buffer is too small to contain the path elements. This return value is expected if pdwBufferSize is zero
/// on input. If the specified size on input is greater than zero but less than the required size, you should not rely on the
/// returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_PATH</term>
/// <term>
/// The path is not formatted correctly and cannot be parsed. For example, on some releases you could receive this error if the
/// specified size on input is greater than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory in order to complete the function.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set pCounterPathElements to <c>NULL</c> and
/// pdwBufferSize to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhparsecounterpatha PDH_FUNCTION PdhParseCounterPathA( LPCSTR
// szFullPathBuffer, PPDH_COUNTER_PATH_ELEMENTS_A pCounterPathElements, LPDWORD pdwBufferSize, DWORD dwFlags );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "760b94e9-88df-4f7d-92e9-333d682779f6")]
public static extern Win32Error PdhParseCounterPath(string szFullPathBuffer, [Optional] IntPtr pCounterPathElements, ref uint pdwBufferSize, uint dwFlags = 0);
/// <summary>Parses the elements of an instance string.</summary>
/// <param name="szInstanceString">
/// <para>
/// <c>Null</c>-terminated string that specifies the instance string to parse into individual components. This string can contain the
/// following formats, and is less than MAX_PATH characters in length:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>instance</term>
/// </item>
/// <item>
/// <term>instance#index</term>
/// </item>
/// <item>
/// <term>parent/instance</term>
/// </item>
/// <item>
/// <term>parent/instance#index</term>
/// </item>
/// </list>
/// </param>
/// <param name="szInstanceName">
/// Caller-allocated buffer that receives the <c>null</c>-terminated instance name. Set to <c>NULL</c> if pcchInstanceNameLength is zero.
/// </param>
/// <param name="pcchInstanceNameLength">
/// Size of the szInstanceName buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this parameter
/// to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size
/// of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not
/// rely on the returned size to reallocate the buffer.
/// </param>
/// <param name="szParentName">
/// Caller-allocated buffer that receives the <c>null</c>-terminated name of the parent instance, if one is specified. Set to
/// <c>NULL</c> if pcchParentNameLength is zero.
/// </param>
/// <param name="pcchParentNameLength">
/// Size of the szParentName buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this parameter
/// to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size
/// of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not
/// rely on the returned size to reallocate the buffer.
/// </param>
/// <param name="lpIndex">
/// Index value of the instance. If an index entry is not present in the string, then this value is zero. This parameter can be <c>NULL</c>.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// One or both of the string buffers are too small to contain the data. This return value is expected if the corresponding size
/// buffer is zero on input. If the specified size on input is greater than zero but less than the required size, you should not rely
/// on the returned size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_INVALID_INSTANCE</term>
/// <term>The instance string is incorrectly formatted, exceeds MAX_PATH characters in length, or cannot be parsed.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set the buffers to <c>NULL</c> and buffer
/// sizes to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhparseinstancenamea PDH_FUNCTION PdhParseInstanceNameA( LPCSTR
// szInstanceString, LPSTR szInstanceName, LPDWORD pcchInstanceNameLength, LPSTR szParentName, LPDWORD pcchParentNameLength, LPDWORD
// lpIndex );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "8304ecee-5141-450a-be11-838b9f52413b")]
public static extern Win32Error PdhParseInstanceName(string szInstanceString, [Optional] StringBuilder szInstanceName, ref uint pcchInstanceNameLength, [Optional] StringBuilder szParentName, ref uint pcchParentNameLength, out uint lpIndex);
/// <summary>Reads the information in the specified binary trace log file.</summary>
/// <param name="hLog">Handle to the log file. The PdhOpenLog or PdhBindInputDataSource function returns this handle.</param>
/// <param name="ftRecord">
/// Time stamp of the record to be read. If the time stamp does not match a record in the log file, the function returns the record
/// that has a time stamp closest to (but not greater than) the given time stamp.
/// </param>
/// <param name="pRawLogRecord">
/// Caller-allocated buffer that receives a <see cref="PDH_RAW_LOG_RECORD"/> structure; the structure contains the log file record
/// information. Set to <c>NULL</c> if pdwBufferLength is zero.
/// </param>
/// <param name="pdwBufferLength">
/// Size of the pRawLogRecord buffer, in <c>TCHARs</c>. If zero on input, the function returns PDH_MORE_DATA and sets this parameter
/// to the required buffer size. If the buffer is larger than the required size, the function sets this parameter to the actual size
/// of the buffer that was used. If the specified size on input is greater than zero but less than the required size, you should not
/// rely on the returned size to reallocate the buffer.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>
/// A parameter is not valid. For example, on some releases you could receive this error if the specified size on input is greater
/// than zero but less than the required size.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MORE_DATA</term>
/// <term>
/// The pRawLogRecord buffer is too small to contain the path elements. This return value is expected if pdwBufferLength is zero on
/// input. If the specified size on input is greater than zero but less than the required size, you should not rely on the returned
/// size to reallocate the buffer.
/// </term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>Unable to allocate memory in order to complete the function.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// You should call this function twice, the first time to get the required buffer size (set pRawLogRecord to <c>NULL</c> and
/// pdwBufferLength to 0), and the second time to get the data.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhreadrawlogrecord PDH_FUNCTION PdhReadRawLogRecord( PDH_HLOG hLog,
// FILETIME ftRecord, PPDH_RAW_LOG_RECORD pRawLogRecord, LPDWORD pdwBufferLength );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "fb93b6ea-ca31-4ff1-a553-b02388be8b72")]
public static extern Win32Error PdhReadRawLogRecord(PDH_HLOG hLog, FILETIME ftRecord, [Optional] IntPtr pRawLogRecord, ref uint pdwBufferLength);
/// <summary>Removes a counter from a query.</summary>
/// <param name="hCounter">Handle of the counter to remove from its query. The PdhAddCounter function returns this handle.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code.</para>
/// <para>The following is a possible value.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>Do not use the counter handle after removing the counter from the query.</para>
/// <para>The following shows the syntax if calling this function from Visual Basic.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhremovecounter PDH_FUNCTION PdhRemoveCounter( PDH_HCOUNTER
// hCounter );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "adf9c7bd-47d6-489a-88fc-954fdf127ce8")]
public static extern Win32Error PdhRemoveCounter(PDH_HCOUNTER hCounter);
/// <summary>Displays a dialog window that prompts the user to specify the source of the performance data.</summary>
/// <param name="hWndOwner">Owner of the dialog window. This can be <c>NULL</c> if there is no owner (the desktop becomes the owner).</param>
/// <param name="dwFlags">
/// <para>Dialog boxes that will be displayed to prompt for the data source. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_FLAGS_FILE_BROWSER_ONLY</term>
/// <term>Display the file browser only. Set this flag when you want to prompt for the name and location of a log file only.</term>
/// </item>
/// <item>
/// <term>0</term>
/// <term>
/// Display the data source selection dialog box. The dialog box lets the user select performance data from either a log file or a
/// real-time source. If the user specified that data is to be collected from a log file, a file browser is displayed for the user to
/// specify the name and location of the log file.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="szDataSource">
/// <para>
/// Caller-allocated buffer that receives a <c>null</c>-terminated string that contains the name of a log file that the user
/// selected. The log file name is truncated to the size of the buffer if the buffer is too small.
/// </para>
/// <para>If the user selected a real time source, the buffer is empty.</para>
/// </param>
/// <param name="pcchBufferLength">Maximum size of the szDataSource buffer, in <c>TCHARs</c>.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>The length of the buffer passed in the pcchBufferLength is not equal to the actual length of the szDataSource buffer.</term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>A zero-length buffer was passed in the szDataSource parameter.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhselectdatasourcea PDH_FUNCTION PdhSelectDataSourceA( HWND
// hWndOwner, DWORD dwFlags, LPSTR szDataSource, LPDWORD pcchBufferLength );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "211d4504-e1f9-48a0-8ddd-613f2f183c59")]
public static extern Win32Error PdhSelectDataSource([Optional] HWND hWndOwner, PdhSelectDataSourceFlags dwFlags, StringBuilder szDataSource, ref uint pcchBufferLength);
/// <summary>
/// Sets the scale factor that is applied to the calculated value of the specified counter when you request the formatted counter
/// value. If the PDH_FMT_NOSCALE flag is set, then this scale factor is ignored.
/// </summary>
/// <param name="hCounter">Handle of the counter to apply the scale factor to. The PdhAddCounter function returns this handle.</param>
/// <param name="lFactor">
/// Power of ten by which to multiply the calculated value before returning it. The minimum value of this parameter is PDH_MIN_SCALE
/// (–7), where the returned value is the actual value multiplied by 10⁷. The maximum value of this parameter is PDH_MAX_SCALE (+7),
/// where the returned value is the actual value multiplied by 10⁺⁷. A value of zero will set the scale to one, so that the actual
/// value is returned.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>The scale value is out of range.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The counter handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhsetcounterscalefactor PDH_FUNCTION PdhSetCounterScaleFactor(
// PDH_HCOUNTER hCounter, LONG lFactor );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "6db99e03-0b03-4c1c-b82a-2982b52746db")]
public static extern Win32Error PdhSetCounterScaleFactor(PDH_HCOUNTER hCounter, int lFactor);
/// <summary>Specifies the source of the real-time data.</summary>
/// <param name="dwDataSourceId">
/// <para>Source of the performance data. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>DATA_SOURCE_REGISTRY</term>
/// <term>The data source is the registry interface. This is the default.</term>
/// </item>
/// <item>
/// <term>DATA_SOURCE_WBEM</term>
/// <term>The data source is a WMI provider.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following is a possible value.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>The parameter is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// The term real-time as used in the description of this function does not imply the standard meaning of the term real-time.
/// Instead, it describes the collection of performance data from a source providing current information (for example, the registry
/// or a WMI provider) rather than from a log file.
/// </para>
/// <para>
/// If you want to query real-time data from WMI, you must call <c>PdhSetDefaultRealTimeDataSource</c> to set the default real-time
/// data source. You must call this function before calling any other PDH API function.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhsetdefaultrealtimedatasource PDH_FUNCTION
// PdhSetDefaultRealTimeDataSource( DWORD dwDataSourceId );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "5a46ac26-c1a1-40c1-a328-688e0b394e18")]
public static extern Win32Error PdhSetDefaultRealTimeDataSource(uint dwDataSourceId);
/// <summary>Limits the samples that you can read from a log file to those within the specified time range, inclusively.</summary>
/// <param name="hQuery">Handle to the query. The PdhOpenQuery function returns this handle.</param>
/// <param name="pInfo">
/// A PDH_TIME_INFO structure that specifies the time range. Specify the time as local file time. The end time must be greater than
/// the start time. You can specify 0 for the start time and the maximum 64-bit value for the end time if you want to read all records.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The query handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>The ending time range value must be greater than the starting time range value.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// When the end of the specified time range or the end of the log file is reached, the PdhCollectQueryData function will return PDH_NO_MORE_DATA.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhsetquerytimerange PDH_FUNCTION PdhSetQueryTimeRange( PDH_HQUERY
// hQuery, PPDH_TIME_INFO pInfo );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "ed0e100e-9f82-48c0-b4bb-72820c5eeaa8")]
public static extern Win32Error PdhSetQueryTimeRange(PDH_HQUERY hQuery, in PDH_TIME_INFO pInfo);
/// <summary>Collects counter data for the current query and writes the data to the log file.</summary>
/// <param name="hLog">Handle of a single log file to update. The PdhOpenLog function returns this handle.</param>
/// <param name="szUserString">
/// Null-terminated string that contains a user-defined comment to add to the data record. The string can not be empty.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The log file handle is not valid.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_ARGUMENT</term>
/// <term>An empty string was passed in the szUserString parameter.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>If you are updating a log file from another log file, the comments from the other log file do not migrate.</para>
/// <para>Examples</para>
/// <para>For an example, see Writing Performance Data to a Log File.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhupdateloga PDH_FUNCTION PdhUpdateLogA( PDH_HLOG hLog, LPCSTR
// szUserString );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "b2052275-6944-41f4-92ac-38967ed270f3")]
public static extern Win32Error PdhUpdateLog(PDH_HLOG hLog, string szUserString);
/// <summary>
/// <para>Synchronizes the information in the log file catalog with the performance data in the log file.</para>
/// <para><c>Note</c> This function is obsolete.</para>
/// </summary>
/// <param name="hLog">Handle to the log file containing the file catalog to update. The PdhOpenLog function.</param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_NOT_IMPLEMENTED</term>
/// <term>A handle to a CSV or TSV log file was specified. These log file types do not have catalogs.</term>
/// </item>
/// <item>
/// <term>PDH_UNKNOWN_LOG_FORMAT</term>
/// <term>A handle to a log file with an unknown format was specified.</term>
/// </item>
/// <item>
/// <term>PDH_INVALID_HANDLE</term>
/// <term>The handle is not valid.</term>
/// </item>
/// </list>
/// </returns>
/// <remarks>
/// <para>
/// The log file catalog serves as an index to the performance data records in the log file, providing for faster searches for
/// individual records in the file.
/// </para>
/// <para>
/// Catalogs should be updated when the data collection process is complete and the log file has been closed. The catalog can be
/// updated during data collection, but doing this may disrupt the process of logging the performance data because updating the
/// catalogs can be time consuming.
/// </para>
/// <para>
/// Perfmon, CSV, and TSV log files do not have catalogs. Specifying a handle to these log file types will result in a return value
/// of PDH_NOT_IMPLEMENTED.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhupdatelogfilecatalog PDH_FUNCTION PdhUpdateLogFileCatalog(
// PDH_HLOG hLog );
[DllImport(Lib.Pdh, SetLastError = false, ExactSpelling = true)]
[PInvokeData("pdh.h", MSDNShortId = "e8aa8462-48f1-4ccd-8c41-a7358975e056")]
public static extern Win32Error PdhUpdateLogFileCatalog(PDH_HLOG hLog);
/// <summary>Validates that the counter is present on the computer specified in the counter path.</summary>
/// <param name="szFullPathBuffer">
/// Null-terminated string that contains the counter path to validate. The maximum length of a counter path is PDH_MAX_COUNTER_PATH.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_CSTATUS_NO_INSTANCE</term>
/// <term>The specified instance of the performance object was not found.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTER</term>
/// <term>The specified counter was not found in the performance object.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified performance object was not found on the computer.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer could not be found or connected to.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_BAD_COUNTERNAME</term>
/// <term>The counter path string could not be parsed.</term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>The function is unable to allocate a required temporary buffer.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhvalidatepatha PDH_FUNCTION PdhValidatePathA( LPCSTR
// szFullPathBuffer );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "9248e63c-2672-466f-85f5-46f26e31dc75")]
public static extern Win32Error PdhValidatePath(string szFullPathBuffer);
/// <summary>Validates that the specified counter is present on the computer or in the log file.</summary>
/// <param name="hDataSource">
/// <para>Handle to the data source. The PdhOpenLog and PdhBindInputDataSource functions return this handle.</para>
/// <para>To validate that the counter is present on the local computer, specify <c>NULL</c> (this is the same as calling PdhValidatePath).</para>
/// </param>
/// <param name="szFullPathBuffer">
/// <c>Null</c>-terminated string that specifies the counter path to validate. The maximum length of a counter path is PDH_MAX_COUNTER_PATH.
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns ERROR_SUCCESS.</para>
/// <para>If the function fails, the return value is a system error code or a PDH error code. The following are possible values.</para>
/// <list type="table">
/// <listheader>
/// <term>Return code</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>PDH_CSTATUS_NO_INSTANCE</term>
/// <term>The specified instance of the performance object was not found.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_COUNTER</term>
/// <term>The specified counter was not found in the performance object.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_OBJECT</term>
/// <term>The specified performance object was not found on the computer or in the log file.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_NO_MACHINE</term>
/// <term>The specified computer could not be found or connected to.</term>
/// </item>
/// <item>
/// <term>PDH_CSTATUS_BAD_COUNTERNAME</term>
/// <term>The counter path string could not be parsed.</term>
/// </item>
/// <item>
/// <term>PDH_MEMORY_ALLOCATION_FAILURE</term>
/// <term>The function is unable to allocate a required temporary buffer.</term>
/// </item>
/// </list>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhvalidatepathexw PDH_FUNCTION PdhValidatePathExW( PDH_HLOG
// hDataSource, LPCWSTR szFullPathBuffer );
[DllImport(Lib.Pdh, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("pdh.h", MSDNShortId = "e6b52af7-7276-4565-aa61-73899796a13c")]
public static extern Win32Error PdhValidatePathExW(PDH_HLOG hDataSource, string szFullPathBuffer);
private static PDH_PATH PDH_PATH_LANG_FLAGS(ushort LangId, PDH_PATH Flags) => (PDH_PATH)(((LangId & 0x0000FFFF) << 16) | ((int)Flags & 0x0000FFFF));
/// <summary>
/// The <c>PDH_BROWSE_DLG_CONFIG</c> structure is used by the PdhBrowseCounters function to configure the <c>Browse Performance
/// Counters</c> dialog box.
/// </summary>
/// <remarks>
/// Each time the Add button is clicked, the <c>szReturnPathBuffer</c> buffer contains the selected counter and the <c>pCallBack</c>
/// callback function is called. The callback function should call the PdhAddCounter function for each counter in the buffer.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_browse_dlg_config_a typedef struct _BrowseDlgConfig_A { DWORD
// bIncludeInstanceIndex : 1; DWORD bSingleCounterPerAdd : 1; DWORD bSingleCounterPerDialog : 1; DWORD bLocalCountersOnly : 1; DWORD
// bWildCardInstances : 1; DWORD bHideDetailBox : 1; DWORD bInitializePath : 1; DWORD bDisableMachineSelection : 1; DWORD
// bIncludeCostlyObjects : 1; DWORD bShowObjectBrowser : 1; DWORD bReserved : 22; HWND hWndOwner; LPSTR szDataSource; LPSTR
// szReturnPathBuffer; DWORD cchReturnPathLength; CounterPathCallBack pCallBack; DWORD_PTR dwCallBackArg; PDH_STATUS CallBackStatus;
// DWORD dwDefaultDetailLevel; LPSTR szDialogBoxCaption; } PDH_BROWSE_DLG_CONFIG_A, *PPDH_BROWSE_DLG_CONFIG_A;
[PInvokeData("pdh.h", MSDNShortId = "8e045e0b-c157-4527-902c-6096c7922642")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct PDH_BROWSE_DLG_CONFIG
{
/// <summary/>
public BrowseFlag Flags;
/// <summary>Handle of the window to own the dialog. If <c>NULL</c>, the owner is the desktop.</summary>
public HWND hWndOwner;
/// <summary>
/// Pointer to a <c>null</c>-terminated string that specifies the name of the log file from which the list of counters is
/// retrieved. If <c>NULL</c>, the list of counters is retrieved from the local computer (or remote computer if specified).
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szDataSource;
/// <summary>
/// <para>Pointer to a MULTI_SZ that contains the selected counter paths.</para>
/// <para>
/// If <c>bInitializePath</c> is <c>TRUE</c>, you can use this member to specify a counter path whose components are used to
/// highlight entries in computer, object, counter, and instance lists when the dialog is first displayed.
/// </para>
/// </summary>
public IntPtr szReturnPathBuffer;
/// <summary>
/// Size of the <c>szReturnPathBuffer</c> buffer, in <c>TCHARs</c>. If the callback function reallocates a new buffer, it must
/// also update this value.
/// </summary>
public uint cchReturnPathLength;
/// <summary>Pointer to the callback function that processes the user's selection. For more information, see CounterPathCallBack.</summary>
public CounterPathCallBack pCallBack;
/// <summary>Caller-defined value that is passed to the callback function.</summary>
public IntPtr dwCallBackArg;
/// <summary>
/// <para>
/// On entry to the callback function, this member contains the status of the path buffer. On exit, the callback function sets
/// the status value resulting from processing.
/// </para>
/// <para>
/// If the buffer is too small to load the current selection, the dialog sets this value to PDH_MORE_DATA. If this value is
/// ERROR_SUCCESS, then the <c>szReturnPathBuffer</c> member contains a valid counter path or counter path list.
/// </para>
/// <para>
/// If the callback function reallocates a new buffer, it should set this member to PDH_RETRY so that the dialog will try to load
/// the buffer with the selected paths and call the callback function again.
/// </para>
/// <para>If some other error occurred, then the callback function should return the appropriate PDH error status value.</para>
/// </summary>
public Win32Error CallBackStatus;
/// <summary>
/// <para>
/// Default detail level to show in the <c>Detail level</c> list if <c>bHideDetailBox</c> is <c>FALSE</c>. If
/// <c>bHideDetailBox</c> is <c>TRUE</c>, the dialog uses this value to filter the displayed performance counters and objects.
/// You can specify one of the following values:
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Detail level</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PERF_DETAIL_NOVICE</term>
/// <term>A novice user can understand the counter data.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_ADVANCED</term>
/// <term>The counter data is provided for advanced users.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_EXPERT</term>
/// <term>The counter data is provided for expert users.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_WIZARD</term>
/// <term>The counter data is provided for system designers.</term>
/// </item>
/// </list>
/// </summary>
public PERF_DETAIL dwDefaultDetailLevel;
/// <summary>
/// Pointer to a <c>null</c>-terminated string that specifies the optional caption to display in the caption bar of the dialog
/// box. If this member is <c>NULL</c>, the caption will be <c>Browse Performance Counters</c>.
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szDialogBoxCaption;
/// <summary>On return, gets the selected counter paths.</summary>
public string[] CounterPaths => szReturnPathBuffer.ToStringEnum(CharSet.Auto, 0, cchReturnPathLength).ToArray();
}
/// <summary>
/// The <c>PDH_BROWSE_DLG_CONFIG_H</c> structure is used by the PdhBrowseCountersH function to configure the <c>Browse Performance
/// Counters</c> dialog box.
/// </summary>
/// <remarks>
/// Each time the Add button is clicked, the <c>szReturnPathBuffer</c> buffer contains the selected counter and the <c>pCallBack</c>
/// callback function is called. The callback function should call the PdhAddCounter function for each counter in the buffer.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_browse_dlg_config_ha typedef struct _BrowseDlgConfig_HA { DWORD
// bIncludeInstanceIndex : 1; DWORD bSingleCounterPerAdd : 1; DWORD bSingleCounterPerDialog : 1; DWORD bLocalCountersOnly : 1; DWORD
// bWildCardInstances : 1; DWORD bHideDetailBox : 1; DWORD bInitializePath : 1; DWORD bDisableMachineSelection : 1; DWORD
// bIncludeCostlyObjects : 1; DWORD bShowObjectBrowser : 1; DWORD bReserved : 22; HWND hWndOwner; PDH_HLOG hDataSource; LPSTR
// szReturnPathBuffer; DWORD cchReturnPathLength; CounterPathCallBack pCallBack; DWORD_PTR dwCallBackArg; PDH_STATUS CallBackStatus;
// DWORD dwDefaultDetailLevel; LPSTR szDialogBoxCaption; } PDH_BROWSE_DLG_CONFIG_HA, *PPDH_BROWSE_DLG_CONFIG_HA;
[PInvokeData("pdh.h", MSDNShortId = "db30ff94-3238-45a0-a78e-8b3cd00ec79c")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct PDH_BROWSE_DLG_CONFIG_H
{
/// <summary/>
public BrowseFlag Flags;
/// <summary>Handle of the window to own the dialog. If <c>NULL</c>, the owner is the desktop.</summary>
public HWND hWndOwner;
/// <summary>Handle to a data source returned by the PdhBindInputDataSource function.</summary>
public PDH_HLOG hDataSource;
/// <summary>
/// <para>Pointer to a MULTI_SZ that contains the selected counter paths.</para>
/// <para>
/// If <c>bInitializePath</c> is <c>TRUE</c>, you can use this member to specify a counter path whose components are used to
/// highlight entries in computer, object, counter, and instance lists when the dialog is first displayed.
/// </para>
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szReturnPathBuffer;
/// <summary>
/// Size of the <c>szReturnPathBuffer</c> buffer, in <c>TCHARs</c>. If the callback function reallocates a new buffer, it must
/// also update this value.
/// </summary>
public uint cchReturnPathLength;
/// <summary>Pointer to the callback function that processes the user's selection. For more information, see CounterPathCallBack.</summary>
public CounterPathCallBack pCallBack;
/// <summary>Caller-defined value that is passed to the callback function.</summary>
public IntPtr dwCallBackArg;
/// <summary>
/// <para>
/// On entry to the callback function, this member contains the status of the path buffer. On exit, the callback function sets
/// the status value resulting from processing.
/// </para>
/// <para>
/// If the buffer is too small to load the current selection, the dialog sets this value to PDH_MORE_DATA. If this value is
/// ERROR_SUCCESS, then the <c>szReturnPathBuffer</c> member contains a valid counter path or counter path list.
/// </para>
/// <para>
/// If the callback function reallocates a new buffer, it should set this member to PDH_RETRY so that the dialog will try to load
/// the buffer with the selected paths and call the callback function again.
/// </para>
/// <para>If some other error occurred, then the callback function should return the appropriate PDH error status value.</para>
/// </summary>
public Win32Error CallBackStatus;
/// <summary>
/// <para>
/// Default detail level to show in the <c>Detail level</c> list if <c>bHideDetailBox</c> is <c>FALSE</c>. If
/// <c>bHideDetailBox</c> is <c>TRUE</c>, the dialog uses this value to filter the displayed performance counters and objects.
/// You can specify one of the following values:
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Detail level</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PERF_DETAIL_NOVICE</term>
/// <term>A novice user can understand the counter data.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_ADVANCED</term>
/// <term>The counter data is provided for advanced users.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_EXPERT</term>
/// <term>The counter data is provided for expert users.</term>
/// </item>
/// <item>
/// <term>PERF_DETAIL_WIZARD</term>
/// <term>The counter data is provided for system designers.</term>
/// </item>
/// </list>
/// </summary>
public PERF_DETAIL dwDefaultDetailLevel;
/// <summary>
/// Pointer to a <c>null</c>-terminated string that specifies the optional caption to display in the caption bar of the dialog
/// box. If this member is <c>NULL</c>, the caption will be <c>Browse Performance Counters</c>.
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szDialogBoxCaption;
}
/// <summary>
/// The <c>PDH_COUNTER_INFO</c> structure contains information describing the properties of a counter. This information also includes
/// the counter path.
/// </summary>
/// <remarks>
/// When you allocate memory for this structure, allocate enough memory for the member strings, such as <c>szCounterName</c>, that
/// are appended to the end of this structure.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_counter_info_a typedef struct _PDH_COUNTER_INFO_A { DWORD
// dwLength; DWORD dwType; DWORD CVersion; DWORD CStatus; LONG lScale; LONG lDefaultScale; DWORD_PTR dwUserData; DWORD_PTR
// dwQueryUserData; LPSTR szFullPath; union { PDH_DATA_ITEM_PATH_ELEMENTS_A DataItemPath; PDH_COUNTER_PATH_ELEMENTS_A CounterPath;
// struct { LPSTR szMachineName; LPSTR szObjectName; LPSTR szInstanceName; LPSTR szParentInstance; DWORD dwInstanceIndex; LPSTR
// szCounterName; }; }; LPSTR szExplainText; DWORD DataBuffer[1]; } PDH_COUNTER_INFO_A, *PPDH_COUNTER_INFO_A;
[PInvokeData("pdh.h", MSDNShortId = "c9ede50e-85de-4a68-b539-54285c2599cb")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct PDH_COUNTER_INFO
{
/// <summary>Size of the structure, including the appended strings, in bytes.</summary>
public uint dwLength;
/// <summary>
/// Counter type. For a list of counter types, see the Counter Types section of the Windows Server 2003 Deployment Kit. The
/// counter type constants are defined in Winperf.h.
/// </summary>
public CounterType dwType;
/// <summary>Counter version information. Not used.</summary>
public uint CVersion;
/// <summary>
/// Counter status that indicates if the counter value is valid. For a list of possible values, see Checking PDH Interface Return Values.
/// </summary>
public uint CStatus;
/// <summary>
/// Scale factor to use when computing the displayable value of the counter. The scale factor is a power of ten. The valid range
/// of this parameter is PDH_MIN_SCALE (–7) (the returned value is the actual value times 10⁷) to PDH_MAX_SCALE (+7) (the
/// returned value is the actual value times 10⁺⁷). A value of zero will set the scale to one, so that the actual value is returned
/// </summary>
public long lScale;
/// <summary>Default scale factor as suggested by the counter's provider.</summary>
public long lDefaultScale;
/// <summary>The value passed in the dwUserData parameter when calling PdhAddCounter.</summary>
public IntPtr dwUserData;
/// <summary>The value passed in the dwUserData parameter when calling PdhOpenQuery.</summary>
public IntPtr dwQueryUserData;
/// <summary><c>Null</c>-terminated string that specifies the full counter path. The string follows this structure in memory.</summary>
public StrPtrAuto szFullPath;
/// <summary>
/// <c>Null</c>-terminated string that contains the name of the computer specified in the counter path. Is <c>NULL</c>, if the
/// path does not specify a computer. The string follows this structure in memory.
/// </summary>
public StrPtrAuto szMachineName;
/// <summary>
/// <c>Null</c>-terminated string that contains the name of the performance object specified in the counter path. The string
/// follows this structure in memory.
/// </summary>
public StrPtrAuto szObjectName;
/// <summary>
/// <c>Null</c>-terminated string that contains the name of the object instance specified in the counter path. Is <c>NULL</c>, if
/// the path does not specify an instance. The string follows this structure in memory.
/// </summary>
public StrPtrAuto szInstanceName;
/// <summary>
/// <c>Null</c>-terminated string that contains the name of the parent instance specified in the counter path. Is <c>NULL</c>, if
/// the path does not specify a parent instance. The string follows this structure in memory.
/// </summary>
public StrPtrAuto szParentInstance;
/// <summary>Instance index specified in the counter path. Is 0, if the path does not specify an instance index.</summary>
public uint dwInstanceIndex;
/// <summary><c>Null</c>-terminated string that contains the counter name. The string follows this structure in memory.</summary>
public StrPtrAuto szCounterName;
/// <summary>Help text that describes the counter. Is <c>NULL</c> if the source is a log file.</summary>
public StrPtrAuto szExplainText;
/// <summary>Start of the string data that is appended to the structure.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public uint[] DataBuffer;
}
/// <summary>The <c>PDH_COUNTER_PATH_ELEMENTS</c> structure contains the components of a counter path.</summary>
/// <remarks>
/// <para>This structure is used by PdhMakeCounterPath to create a counter path and by PdhParseCounterPath to parse a counter path.</para>
/// <para>
/// When you allocate memory for this structure, allocate enough memory for the member strings, such as <c>szCounterName</c>, that
/// are appended to the end of this structure.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_counter_path_elements_a typedef struct
// _PDH_COUNTER_PATH_ELEMENTS_A { LPSTR szMachineName; LPSTR szObjectName; LPSTR szInstanceName; LPSTR szParentInstance; DWORD
// dwInstanceIndex; LPSTR szCounterName; } PDH_COUNTER_PATH_ELEMENTS_A, *PPDH_COUNTER_PATH_ELEMENTS_A;
[PInvokeData("pdh.h", MSDNShortId = "ffa2a076-7267-406b-8eed-4a49504a7ad6")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct PDH_COUNTER_PATH_ELEMENTS
{
/// <summary>Pointer to a null-terminated string that specifies the computer name.</summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szMachineName;
/// <summary>Pointer to a null-terminated string that specifies the object name.</summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szObjectName;
/// <summary>Pointer to a null-terminated string that specifies the instance name. Can contain a wildcard character.</summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szInstanceName;
/// <summary>Pointer to a null-terminated string that specifies the parent instance name. Can contain a wildcard character.</summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szParentInstance;
/// <summary>Index used to uniquely identify duplicate instance names.</summary>
public uint dwInstanceIndex;
/// <summary>Pointer to a null-terminated string that specifies the counter name.</summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szCounterName;
}
/// <summary>The <c>PDH_DATA_ITEM_PATH_ELEMENTS</c> structure contains the path elements of a specific data item.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_data_item_path_elements_a typedef struct
// _PDH_DATA_ITEM_PATH_ELEMENTS_A { LPSTR szMachineName; GUID ObjectGUID; DWORD dwItemId; LPSTR szInstanceName; }
// PDH_DATA_ITEM_PATH_ELEMENTS_A, *PPDH_DATA_ITEM_PATH_ELEMENTS_A;
[PInvokeData("pdh.h", MSDNShortId = "7d80d9ac-0123-4743-93a2-fa9d609d81b2")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct PDH_DATA_ITEM_PATH_ELEMENTS
{
/// <summary>Pointer to a null-terminated string that specifies the name of the computer where the data item resides.</summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szMachineName;
/// <summary>GUID of the object where the data item resides.</summary>
public Guid ObjectGUID;
/// <summary>Identifier of the data item.</summary>
public uint dwItemId;
/// <summary>Pointer to a null-terminated string that specifies the name of the data item instance.</summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szInstanceName;
}
/// <summary>The <c>PDH_FMT_COUNTERVALUE</c> structure contains the computed value of the counter and its status.</summary>
/// <remarks>
/// You specify the data type of the computed counter value when you call PdhGetFormattedCounterValue or
/// PdhCalculateCounterFromRawValue to compute the counter's value.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_fmt_countervalue typedef struct _PDH_FMT_COUNTERVALUE { DWORD
// CStatus; union { LONG longValue; double doubleValue; LONGLONG largeValue; LPCSTR AnsiStringValue; LPCWSTR WideStringValue; }; }
// PDH_FMT_COUNTERVALUE, *PPDH_FMT_COUNTERVALUE;
[PInvokeData("pdh.h", MSDNShortId = "68ccd722-94d2-4610-ba64-f51318f5436e")]
[StructLayout(LayoutKind.Explicit, Size = 16)]
public struct PDH_FMT_COUNTERVALUE
{
/// <summary>
/// Counter status that indicates if the counter value is valid. Check this member before using the data in a calculation or
/// displaying its value. For a list of possible values, see Checking PDH Interface Return Values.
/// </summary>
[FieldOffset(0)]
public Win32Error CStatus;
/// <summary>The computed counter value as a <c>LONG</c>.</summary>
[FieldOffset(8)]
public int longValue;
/// <summary>The computed counter value as a <c>DOUBLE</c>.</summary>
[FieldOffset(8)]
public double doubleValue;
/// <summary>The computed counter value as a <c>LONGLONG</c>.</summary>
[FieldOffset(8)]
public long largeValue;
/// <summary>The computed counter value as a <c>LPCSTR</c>. Not supported.</summary>
[FieldOffset(8)]
public StrPtrAnsi AnsiStringValue;
/// <summary>The computed counter value as a <c>LPCWSTR</c>. Not supported.</summary>
[FieldOffset(8)]
public StrPtrUni WideStringValue;
}
/// <summary>The <c>PDH_FMT_COUNTERVALUE_ITEM</c> structure contains the instance name and formatted value of a counter.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_fmt_countervalue_item_a typedef struct
// _PDH_FMT_COUNTERVALUE_ITEM_A { LPSTR szName; PDH_FMT_COUNTERVALUE FmtValue; } PDH_FMT_COUNTERVALUE_ITEM_A, *PPDH_FMT_COUNTERVALUE_ITEM_A;
[PInvokeData("pdh.h", MSDNShortId = "d3bc6ad3-0cab-4843-ae1d-5f384948a1ea")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct PDH_FMT_COUNTERVALUE_ITEM
{
/// <summary>
/// Pointer to a null-terminated string that specifies the instance name of the counter. The string is appended to the end of
/// this structure.
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szName;
/// <summary>A PDH_FMT_COUNTERVALUE structure that contains the counter value of the instance.</summary>
public PDH_FMT_COUNTERVALUE FmtValue;
}
/// <summary>Provides a handle to a PDH counter.</summary>
[PInvokeData("pdh.h")]
[StructLayout(LayoutKind.Sequential)]
public struct PDH_HCOUNTER : IHandle
{
private readonly IntPtr handle;
/// <summary>Initializes a new instance of the <see cref="PDH_HCOUNTER"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public PDH_HCOUNTER(IntPtr preexistingHandle) => handle = preexistingHandle;
/// <summary>Returns an invalid handle by instantiating a <see cref="PDH_HCOUNTER"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static PDH_HCOUNTER NULL => new PDH_HCOUNTER(IntPtr.Zero);
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull => handle == IntPtr.Zero;
/// <summary>Performs an explicit conversion from <see cref="PDH_HCOUNTER"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr(PDH_HCOUNTER h) => h.handle;
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="PDH_HCOUNTER"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator PDH_HCOUNTER(IntPtr h) => new PDH_HCOUNTER(h);
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(PDH_HCOUNTER h1, PDH_HCOUNTER h2) => !(h1 == h2);
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(PDH_HCOUNTER h1, PDH_HCOUNTER h2) => h1.Equals(h2);
/// <inheritdoc/>
public override bool Equals(object obj) => obj is PDH_HCOUNTER h ? handle == h.handle : false;
/// <inheritdoc/>
public override int GetHashCode() => handle.GetHashCode();
/// <inheritdoc/>
public IntPtr DangerousGetHandle() => handle;
}
/// <summary>Provides a handle to a PDH log.</summary>
[PInvokeData("pdh.h")]
[StructLayout(LayoutKind.Sequential)]
public struct PDH_HLOG : IHandle
{
private readonly IntPtr handle;
/// <summary>Initializes a new instance of the <see cref="PDH_HLOG"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public PDH_HLOG(IntPtr preexistingHandle) => handle = preexistingHandle;
/// <summary>Returns an invalid handle by instantiating a <see cref="PDH_HLOG"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static PDH_HLOG NULL => new PDH_HLOG(IntPtr.Zero);
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull => handle == IntPtr.Zero;
/// <summary>Performs an explicit conversion from <see cref="PDH_HLOG"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr(PDH_HLOG h) => h.handle;
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="PDH_HLOG"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator PDH_HLOG(IntPtr h) => new PDH_HLOG(h);
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(PDH_HLOG h1, PDH_HLOG h2) => !(h1 == h2);
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(PDH_HLOG h1, PDH_HLOG h2) => h1.Equals(h2);
/// <inheritdoc/>
public override bool Equals(object obj) => obj is PDH_HLOG h ? handle == h.handle : false;
/// <inheritdoc/>
public override int GetHashCode() => handle.GetHashCode();
/// <inheritdoc/>
public IntPtr DangerousGetHandle() => handle;
}
/// <summary>Provides a handle to a PDH query.</summary>
[PInvokeData("pdh.h")]
[StructLayout(LayoutKind.Sequential)]
public struct PDH_HQUERY : IHandle
{
private readonly IntPtr handle;
/// <summary>Initializes a new instance of the <see cref="PDH_HQUERY"/> struct.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
public PDH_HQUERY(IntPtr preexistingHandle) => handle = preexistingHandle;
/// <summary>Returns an invalid handle by instantiating a <see cref="PDH_HQUERY"/> object with <see cref="IntPtr.Zero"/>.</summary>
public static PDH_HQUERY NULL => new PDH_HQUERY(IntPtr.Zero);
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
public bool IsNull => handle == IntPtr.Zero;
/// <summary>Performs an explicit conversion from <see cref="PDH_HQUERY"/> to <see cref="IntPtr"/>.</summary>
/// <param name="h">The handle.</param>
/// <returns>The result of the conversion.</returns>
public static explicit operator IntPtr(PDH_HQUERY h) => h.handle;
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="PDH_HQUERY"/>.</summary>
/// <param name="h">The pointer to a handle.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator PDH_HQUERY(IntPtr h) => new PDH_HQUERY(h);
/// <summary>Implements the operator !=.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator !=(PDH_HQUERY h1, PDH_HQUERY h2) => !(h1 == h2);
/// <summary>Implements the operator ==.</summary>
/// <param name="h1">The first handle.</param>
/// <param name="h2">The second handle.</param>
/// <returns>The result of the operator.</returns>
public static bool operator ==(PDH_HQUERY h1, PDH_HQUERY h2) => h1.Equals(h2);
/// <inheritdoc/>
public override bool Equals(object obj) => obj is PDH_HQUERY h ? handle == h.handle : false;
/// <inheritdoc/>
public override int GetHashCode() => handle.GetHashCode();
/// <inheritdoc/>
public IntPtr DangerousGetHandle() => handle;
}
/// <summary>
/// The <c>PDH_RAW_COUNTER</c> structure returns the data as it was collected from the counter provider. No translation, formatting,
/// or other interpretation is performed on the data.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_raw_counter typedef struct _PDH_RAW_COUNTER { DWORD CStatus;
// FILETIME TimeStamp; LONGLONG FirstValue; LONGLONG SecondValue; DWORD MultiCount; } PDH_RAW_COUNTER, *PPDH_RAW_COUNTER;
[PInvokeData("pdh.h", MSDNShortId = "237a3c82-0ab4-45cb-bd93-2f308178c573")]
[StructLayout(LayoutKind.Sequential)]
public struct PDH_RAW_COUNTER
{
/// <summary>
/// Counter status that indicates if the counter value is valid. Check this member before using the data in a calculation or
/// displaying its value. For a list of possible values, see Checking PDH Interface Return Values.
/// </summary>
public Win32Error CStatus;
/// <summary>Local time for when the data was collected, in FILETIME format.</summary>
public FILETIME TimeStamp;
/// <summary>First raw counter value.</summary>
public long FirstValue;
/// <summary>Second raw counter value. Rate counters require two values in order to compute a displayable value.</summary>
public long SecondValue;
/// <summary>
/// If the counter type contains the PERF_MULTI_COUNTER flag, this member contains the additional counter data used in the
/// calculation. For example, the PERF_100NSEC_MULTI_TIMER counter type contains the PERF_MULTI_COUNTER flag.
/// </summary>
public uint MultiCount;
}
/// <summary>The <c>PDH_RAW_COUNTER_ITEM</c> structure contains the instance name and raw value of a counter.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_raw_counter_item_a typedef struct _PDH_RAW_COUNTER_ITEM_A {
// LPSTR szName; PDH_RAW_COUNTER RawValue; } PDH_RAW_COUNTER_ITEM_A, *PPDH_RAW_COUNTER_ITEM_A;
[PInvokeData("pdh.h", MSDNShortId = "602e0d44-3551-4a26-a5b7-8f7015131f9a")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct PDH_RAW_COUNTER_ITEM
{
/// <summary>
/// Pointer to a null-terminated string that specifies the instance name of the counter. The string is appended to the end of
/// this structure.
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)] public string szName;
/// <summary>A PDH_RAW_COUNTER structure that contains the raw counter value of the instance.</summary>
public PDH_RAW_COUNTER RawValue;
}
/// <summary>The <c>PDH_RAW_LOG_RECORD</c> structure contains information about a binary trace log file record.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_raw_log_record typedef struct _PDH_RAW_LOG_RECORD { DWORD
// dwStructureSize; DWORD dwRecordType; DWORD dwItems; UCHAR RawBytes[1]; } PDH_RAW_LOG_RECORD, *PPDH_RAW_LOG_RECORD;
[PInvokeData("pdh.h", MSDNShortId = "ae96515f-ea3f-4578-a249-fb8f41cdfa69")]
[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<PDH_RAW_LOG_RECORD>), nameof(dwItems))]
[StructLayout(LayoutKind.Sequential)]
public struct PDH_RAW_LOG_RECORD
{
/// <summary>
/// Size of this structure, in bytes. The size includes this structure and the <c>RawBytes</c> appended to the end of this structure.
/// </summary>
public uint dwStructureSize;
/// <summary>
/// <para>Type of record. This member can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PDH_LOG_TYPE_BINARY</term>
/// <term>A binary trace format record</term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_CSV</term>
/// <term>A comma-separated-value format record</term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_PERFMON</term>
/// <term>A Perfmon format record</term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_SQL</term>
/// <term>A SQL format record</term>
/// </item>
/// <item>
/// <term>PDH_LOG_TYPE_TSV</term>
/// <term>A tab-separated-value format record</term>
/// </item>
/// </list>
/// </summary>
public PDH_LOG_TYPE dwRecordType;
/// <summary>Size of the <c>RawBytes</c> data.</summary>
public uint dwItems;
/// <summary>Binary record.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public byte[] RawBytes;
}
/// <summary>
/// The <c>PDH_STATISTICS</c> structure contains the minimum, maximum, and mean values for an array of raw counters values.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_statistics typedef struct _PDH_STATISTICS { DWORD dwFormat;
// DWORD count; PDH_FMT_COUNTERVALUE min; PDH_FMT_COUNTERVALUE max; PDH_FMT_COUNTERVALUE mean; } PDH_STATISTICS, *PPDH_STATISTICS;
[PInvokeData("pdh.h", MSDNShortId = "a1daedfd-55f6-418e-b71f-8334cb628d98")]
[StructLayout(LayoutKind.Sequential)]
public struct PDH_STATISTICS
{
/// <summary>Format of the data. The format is specified in the dwFormat when calling PdhComputeCounterStatistics.</summary>
public PDH_FMT dwFormat;
/// <summary>Number of values in the array.</summary>
public uint count;
/// <summary>Minimum of the values.</summary>
public PDH_FMT_COUNTERVALUE min;
/// <summary>Maximum of the values.</summary>
public PDH_FMT_COUNTERVALUE max;
/// <summary>Mean of the values.</summary>
public PDH_FMT_COUNTERVALUE mean;
}
/// <summary>
/// The <c>PDH_TIME_INFO</c> structure contains information on time intervals as applied to the sampling of performance data.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/pdh/ns-pdh-pdh_time_info typedef struct _PDH_TIME_INFO { LONGLONG StartTime;
// LONGLONG EndTime; DWORD SampleCount; } PDH_TIME_INFO, *PPDH_TIME_INFO;
[PInvokeData("pdh.h", MSDNShortId = "a747f288-8d6c-401c-a927-a61ffea3d423")]
[StructLayout(LayoutKind.Sequential, Size = 24)]
public struct PDH_TIME_INFO
{
/// <summary>Starting time of the sample interval, in local FILETIME format.</summary>
public FILETIME StartTime;
/// <summary>Ending time of the sample interval, in local FILETIME format.</summary>
public FILETIME EndTime;
/// <summary>Number of samples collected during the interval.</summary>
public uint SampleCount;
}
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="PDH_HCOUNTER"/> that is disposed using <see cref="PdhRemoveCounter"/>.</summary>
public class SafePDH_HCOUNTER : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafePDH_HCOUNTER"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafePDH_HCOUNTER(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
/// <summary>Initializes a new instance of the <see cref="SafePDH_HCOUNTER"/> class.</summary>
private SafePDH_HCOUNTER() : base() { }
/// <summary>Performs an implicit conversion from <see cref="SafePDH_HCOUNTER"/> to <see cref="PDH_HCOUNTER"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator PDH_HCOUNTER(SafePDH_HCOUNTER h) => h.handle;
/// <inheritdoc/>
protected override bool InternalReleaseHandle() => PdhRemoveCounter(handle).Succeeded;
}
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="PDH_HLOG"/> that is disposed using <see cref="PdhCloseLog"/>.</summary>
public class SafePDH_HLOG : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafePDH_HLOG"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafePDH_HLOG(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
/// <summary>Initializes a new instance of the <see cref="SafePDH_HLOG"/> class.</summary>
private SafePDH_HLOG() : base() { }
/// <summary>
/// Gets or sets a value indicating whether to close the query associated with the specified log file handle on disposal. See the
/// hQuery parameter of PdhOpenLog.
/// </summary>
public bool CloseAssocQueries { get; set; }
/// <summary>Performs an implicit conversion from <see cref="SafePDH_HLOG"/> to <see cref="PDH_HLOG"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator PDH_HLOG(SafePDH_HLOG h) => h.handle;
/// <inheritdoc/>
protected override bool InternalReleaseHandle() => PdhCloseLog(handle, CloseAssocQueries ? 1U : 0).Succeeded;
}
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="PDH_HQUERY"/> that is disposed using <see cref="PdhCloseQuery"/>.</summary>
public class SafePDH_HQUERY : SafeHANDLE
{
/// <summary>Initializes a new instance of the <see cref="SafePDH_HQUERY"/> class and assigns an existing handle.</summary>
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
/// <param name="ownsHandle">
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
/// </param>
public SafePDH_HQUERY(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
/// <summary>Initializes a new instance of the <see cref="SafePDH_HQUERY"/> class.</summary>
private SafePDH_HQUERY() : base() { }
/// <summary>Performs an implicit conversion from <see cref="SafePDH_HQUERY"/> to <see cref="PDH_HQUERY"/>.</summary>
/// <param name="h">The safe handle instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator PDH_HQUERY(SafePDH_HQUERY h) => h.handle;
/// <inheritdoc/>
protected override bool InternalReleaseHandle() => PdhCloseQuery(handle).Succeeded;
}
}
}
Reference in New Issue View Git Blame Copy Permalink