1
public class HidDriver : IDisposable
2
{
3
    private SafeFileHandle _handle;
4
    private CancellationTokenSource _cts = new();
5
    private readonly byte _reportId = 0x00;
6
    private readonly int _reportLength;
7

8
    public event EventHandler<ReportEventArgs> DataReceived;
9
    public event EventHandler DeviceRemoved;
10

11
    public HidDriver(int reportLength = 64)
12
    {
13
        _reportLength = reportLength;
14
    }
15

16
    public bool Open(ushort vid, ushort pid) { /* 使用上一篇完整枚举 + CreateFile 逻辑 */ }
17

18
    public async Task StartAsyncReadAsync()
19
    {
20
        while (!_cts.Token.IsCancellationRequested)
21
        {
22
            var buffer = new byte[_reportLength];
23
            var overlapped = new NativeOverlapped { EventHandle = CreateEvent(IntPtr.Zero, true, false, null).DangerousGetHandle() };
24

25
            if (ReadFile(_handle.DangerousGetHandle(), buffer, (uint)_reportLength, out _, ref overlapped))
26
            {
27
                // 同步完成
28
                ProcessReceivedData(buffer);
29
            }
30
            else if (Marshal.GetLastWin32Error() == ERROR_IO_PENDING)
31
            {
32
                // 异步等待
33
                await Task.Run(() => WaitForSingleObject(overlapped.EventHandle, INFINITE));
34
                ProcessReceivedData(buffer);
35
            }
36
            CloseHandle(overlapped.EventHandle);
37
        }
38
    }
39

40
    private void ProcessReceivedData(byte[] buffer)
41
    {
42
        if (buffer[0] == _reportId)
43
            DataReceived?.Invoke(this, new ReportEventArgs(buffer.Skip(1).ToArray()));
44
    }
45

46
    // Write 同理使用 WriteFile + Overlapped
47
}

1
public class HidInterface
2
{
3
    private readonly HidDriver _driver = new();
4
    private readonly Timer _reconnectTimer;
5
    private bool _autoReconnect = true;
6
    private ushort _vid, _pid;
7

8
    public event EventHandler<bool> StatusChanged;
9
    public event EventHandler<byte[]> DataReceived;
10

11
    public HidInterface()
12
    {
13
        _driver.DataReceived += (s, e) => DataReceived?.Invoke(this, e.Payload);
14
        _driver.DeviceRemoved += (s, e) => OnDeviceRemoved();
15
        _reconnectTimer = new Timer(ReconnectCallback, null, Timeout.Infinite, 500);
16
    }
17

18
    public void AutoConnect(ushort vid, ushort pid)
19
    {
20
        _vid = vid; _pid = pid;
21
        _reconnectTimer.Change(0, 500);
22
    }
23

24
    private void ReconnectCallback(object state)
25
    {
26
        if (!_driver.IsOpen && _autoReconnect)
27
        {
28
            if (_driver.Open(_vid, _pid))
29
            {
30
                _ = _driver.StartAsyncReadAsync();
31
                StatusChanged?.Invoke(this, true);
32
            }
33
        }
34
    }
35

36
    private void OnDeviceRemoved()
37
    {
38
        StatusChanged?.Invoke(this, false);
39
        // 定时器已开启自动重连
40
    }
41

42
    public bool Send(byte[] data)
43
    {
44
        var report = new byte[data.Length + 1];
45
        report[0] = 0x00; // Report ID
46
        Array.Copy(data, 0, report, 1, data.Length);
47
        return _driver.Write(report);
48
    }
49

50
    public void Dispose() => _driver.Dispose();
51
}

1
private HidInterface _hid = new();
2

3
private void InitHid()
4
{
5
    _hid.StatusChanged += (s, connected) => Dispatcher.Invoke(() => txtStatus.Text = connected ? "已连接" : "已断开");
6
    _hid.DataReceived += (s, data) => Dispatcher.Invoke(() => ProcessSensorData(data));
7

8
    _hid.AutoConnect(0x04D8, 0x003F);  // 你的 VID/PID
9
}
10

11
private void BtnSend_Click(object sender, RoutedEventArgs e)
12
{
13
    byte[] cmd = { 0x01, 0x02, 0x03 };
14
    _hid.Send(cmd);
15
}