PDH_RAW_COUNTER_ITEM_W

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FILETIME
{
    public uint dwLowDateTime;
    public uint dwHighDateTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PDH_RAW_COUNTER
{
    public uint CStatus;
    public FILETIME TimeStamp;
    public long FirstValue;
    public long SecondValue;
    public uint MultiCount;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PDH_RAW_COUNTER_ITEM_W
{
    public IntPtr szName;
    public PDH_RAW_COUNTER RawValue;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FILETIME
    Public dwLowDateTime As UInteger
    Public dwHighDateTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PDH_RAW_COUNTER
    Public CStatus As UInteger
    Public TimeStamp As FILETIME
    Public FirstValue As Long
    Public SecondValue As Long
    Public MultiCount As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PDH_RAW_COUNTER_ITEM_W
    Public szName As IntPtr
    Public RawValue As PDH_RAW_COUNTER
End Structure

import ctypes
from ctypes import wintypes

class FILETIME(ctypes.Structure):
    _fields_ = [
        ("dwLowDateTime", wintypes.DWORD),
        ("dwHighDateTime", wintypes.DWORD),
    ]

class PDH_RAW_COUNTER(ctypes.Structure):
    _fields_ = [
        ("CStatus", wintypes.DWORD),
        ("TimeStamp", FILETIME),
        ("FirstValue", ctypes.c_longlong),
        ("SecondValue", ctypes.c_longlong),
        ("MultiCount", wintypes.DWORD),
    ]

class PDH_RAW_COUNTER_ITEM_W(ctypes.Structure):
    _fields_ = [
        ("szName", ctypes.c_void_p),
        ("RawValue", PDH_RAW_COUNTER),
    ]

#[repr(C)]
pub struct FILETIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

#[repr(C)]
pub struct PDH_RAW_COUNTER {
    pub CStatus: u32,
    pub TimeStamp: FILETIME,
    pub FirstValue: i64,
    pub SecondValue: i64,
    pub MultiCount: u32,
}

#[repr(C)]
pub struct PDH_RAW_COUNTER_ITEM_W {
    pub szName: *mut core::ffi::c_void,
    pub RawValue: PDH_RAW_COUNTER,
}

import "golang.org/x/sys/windows"

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type PDH_RAW_COUNTER struct {
	CStatus uint32
	TimeStamp FILETIME
	FirstValue int64
	SecondValue int64
	MultiCount uint32
}

type PDH_RAW_COUNTER_ITEM_W struct {
	szName uintptr
	RawValue PDH_RAW_COUNTER
}

type
  FILETIME = record
    dwLowDateTime: DWORD;
    dwHighDateTime: DWORD;
  end;

  PDH_RAW_COUNTER = record
    CStatus: DWORD;
    TimeStamp: FILETIME;
    FirstValue: Int64;
    SecondValue: Int64;
    MultiCount: DWORD;
  end;

  PDH_RAW_COUNTER_ITEM_W = record
    szName: Pointer;
    RawValue: PDH_RAW_COUNTER;
  end;

const FILETIME = extern struct {
    dwLowDateTime: u32,
    dwHighDateTime: u32,
};

const PDH_RAW_COUNTER = extern struct {
    CStatus: u32,
    TimeStamp: FILETIME,
    FirstValue: i64,
    SecondValue: i64,
    MultiCount: u32,
};

const PDH_RAW_COUNTER_ITEM_W = extern struct {
    szName: ?*anyopaque,
    RawValue: PDH_RAW_COUNTER,
};

type
  FILETIME {.bycopy.} = object
    dwLowDateTime: uint32
    dwHighDateTime: uint32

  PDH_RAW_COUNTER {.bycopy.} = object
    CStatus: uint32
    TimeStamp: FILETIME
    FirstValue: int64
    SecondValue: int64
    MultiCount: uint32

  PDH_RAW_COUNTER_ITEM_W {.bycopy.} = object
    szName: pointer
    RawValue: PDH_RAW_COUNTER

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct PDH_RAW_COUNTER
{
    uint CStatus;
    FILETIME TimeStamp;
    long FirstValue;
    long SecondValue;
    uint MultiCount;
}

struct PDH_RAW_COUNTER_ITEM_W
{
    void* szName;
    PDH_RAW_COUNTER RawValue;
}