C#实现USB读写操作的示例代码

using system;
using system.runtime.interopservices;

class program
{
    [dllimport("user32.dll", charset = charset.auto)]
    static extern int messagebox(int hwnd, string text, string caption, uint type);

    static void main()
    {
        messagebox(0, "hello world!", "sample message box", 0);
    }
}

// 引入所需的命名空间
using microsoft梧桐雨-setupapi;
using system;

public class usbdeviceenumerator
{
    public static void enumerateusbdevices()
    {
        // 创建设备信息集合
        sp_devinfo_data deviceinfodata = new sp_devinfo_data();
        deviceinfodata.cbsize = marshal.sizeof(deviceinfodata);
        guid classguid = guid.empty;

        // 打开设备信息集
        intptr deviceinfoset = setupdigetclassdevs(ref classguid, intptr.zero, intptr.zero, digcf_present | digcf_deviceinterface);
        if (deviceinfoset == new intptr(-1))
        {
            console.writeline("无法获取设备信息集。");
            return;
        }

        try
        {
            // 循环获取所有设备
            for (int memberindex = 0; setupdienumdeviceinfo(deviceinfoset, memberindex, ref deviceinfodata); memberindex++)
            {
                // 获取设备接口详情
                sp_device_interface_data deviceinterfacedata = new sp_device_interface_data();
                deviceinterfacedata.cbsize = marshal.sizeof(deviceinterfacedata);

                if (setupdienumdeviceinterfaces(deviceinfoset, ref deviceinfodata, ref classguid, memberindex, ref deviceinterfacedata))
                {
                    // 获取设备接口数据
                    int requiredsize;
                    setupdigetdeviceinterfacedetail(deviceinfoset, ref deviceinterfacedata, intptr.zero, 0, ref requiredsize, null);
                    intptr pdevinterfacedetaildata = marshal.allochglobal(requiredsize);
                    sp_device_interface_detail_data devinterfacedetaildata = new sp_device_interface_detail_data();
                    devinterfacedetaildata.cbsize = marshal.sizeof(devinterfacedetaildata);

                    if (setupdigetdeviceinterfacedetail(deviceinfoset, ref deviceinterfacedata, ref devinterfacedetaildata, requiredsize, ref requiredsize, ref deviceinfodata))
                    {
                        // todo: 在这里可以添加对设备的进一步处理
                    }
                }
            }
        }
        finally
        {
            // 清理设备信息集
            setupdidestroydeviceinfolist(deviceinfoset);
        }
    }
}

// 继续上一个方法的实现
// ...

sp_devinfo_data deviceinfodata = new sp_devinfo_data();
deviceinfodata.cbsize = marshal.sizeof(deviceinfodata);
guid classguid = guid.empty;
intptr deviceinfoset = setupdigetclassdevs(ref classguid, intptr.zero, intptr.zero, digcf_present | digcf_deviceinterface);

if (deviceinfoset == new intptr(-1))
{
    console.writeline("无法获取设备信息集。");
    return;
}

try
{
    // 假设我们已经有一个有效的设备接口句柄
    intptr deviceinterfacehandle = intptr.zero; // 这里需要获取到设备接口句柄

    // 获取设备接口详情
    sp_device_interface_data deviceinterfacedata = new sp_device_interface_data();
    deviceinterfacedata.cbsize = marshal.sizeof(deviceinterfacedata);

    if (setupdienumdeviceinterfaces(deviceinfoset, ref deviceinfodata, ref classguid, 0, ref deviceinterfacedata))
    {
        // 获取设备接口数据所需的内存大小
        int requiredsize;
        setupdigetdeviceinterfacedetail(deviceinfoset, ref deviceinterfacedata, intptr.zero, 0, ref requiredsize, null);

        // 分配内存
        intptr pdevinterfacedetaildata = marshal.allochglobal(requiredsize);
        sp_device_interface_detail_data devinterfacedetaildata = new sp_device_interface_detail_data();
        devinterfacedetaildata.cbsize = marshal.sizeof(devinterfacedetaildata);

        // 获取设备接口数据
        if (setupdigetdeviceinterfacedetail(deviceinfoset, ref deviceinterfacedata, ref devinterfacedetaildata, requiredsize, ref requiredsize, ref deviceinfodata))
        {
            // 使用devinterfacedetaildata提供的内存地址和大小
            // 这里可以读取设备接口的详细信息
        }
    }
}
finally
{
    setupdidestroydeviceinfolist(deviceinfoset);
}

intptr createfile(
    string lpfilename,
    uint dwdesiredaccess,
    uint dwsharemode,
    intptr lpsecurityattributes,
    uint dwcreationdisposition,
    uint dwflagsandattributes,
    intptr htemplatefile
);

using system;
using system.io;
using system.runtime.interopservices;

class program
{
    [dllimport("kernel32.dll", setlasterror = true)]
    static extern intptr createfile(
        string lpfilename,
        uint dwdesiredaccess,
        uint dwsharemode,
        intptr lpsecurityattributes,
        uint dwcreationdisposition,
        uint dwflagsandattributes,
        intptr htemplatefile);

    const uint generic_read = 0x80000000;
    const uint generic_write = 0x40000000;
    const uint file_share_read = 0x00000001;
    const uint file_share_write = 0x00000002;
    const uint open_existing = 3;
    const uint file_attribute_normal = 0x80;

    static void main(string[] args)
    {
        string devicepath = "\\\\.\\usb#vid_1234&pid_5678#0001#{e6f07b5f-ee97-4a90-b076-33f57bf4eaa7}";
        intptr handle = createfile(devicepath, generic_read | generic_write, file_share_read | file_share_write, intptr.zero, open_existing, file_attribute_normal, intptr.zero);
        if (handle == invalid_handle_value)
        {
            int error = marshal.getlastwin32error();
            console.writeline($"failed to open device. error: {error}");
        }
        else
        {
            console.writeline("device handle opened successfully.");
        }
    }
}

using (var handle = createfile(devicepath, generic_read | generic_write, file_share_read | file_share_write, intptr.zero, open_existing, file_attribute_normal, intptr.zero))
{
    if (handle != invalid_handle_value)
    {
        // perform your device operations here
    }
}
// handle will be automatically closed here

bool deviceiocontrol(
  [in]          handle       hdevice,
  [in]          dword        dwiocontrolcode,
  [in, optional] lpvoid       lpinbuffer,
  [in]          dword        ninbuffersize,
  [out, optional] lpvoid      lpoutbuffer,
  [in]          dword        noutbuffersize,
  [out, optional] lpdword     lpbytesreturned,
  [in, out, optional] lpoverlapped lpoverlapped
);

var controlcode = (dword)0x20000; // 这里的值是示例，实际应根据文档使用

const int devicesize = sizeof(int);
int devicelength = 0;
var bytesreturned = (uint)0;
var success = deviceiocontrol(
    devicehandle, // hdevice
    controlcode,  // dwiocontrolcode
    intptr.zero,  // lpinbuffer
    0,            // ninbuffersize
    out devicelength, // lpoutbuffer
    devicesize,  // noutbuffersize
    out bytesreturned, // lpbytesreturned
    intptr.zero  // lpoverlapped
);

if (!success)
{
    // 处理错误
}

// 假设已经有一个设备句柄 devicehandle
var overlapped = new overlapped();
var success = readfile(
    devicehandle, // hfile
    buffer,       // lpbuffer
    buffer.length,// nnumberofbytestoread
    out bytesread,// lpnumberofbytesread
    ref overlapped// lpoverlapped
);

if (!success)
{
    // 处理错误
}

// 使用 overlapped 结构中的内嵌 eventhandle 属性等待事件
var eventhandle = overlapped.hevent;
waitforsingleobject(eventhandle, infinite);

// 检查读取的数据，或者如果读操作失败，进行错误处理
if (bytesread > 0)
{
    // 处理成功读取的数据
}
else
{
    // 读操作失败，检查调用 readfile 时的最后一个参数 overlapped 的 internal 和 internalhigh 属性
    // 这些值可以提供更多关于失败原因的信息
}

if (!success)
{
    var errorcode = getlasterror();
    switch (errorcode)
    {
        case error_io_pending:
            // io操作未完成
            break;
        case error_noaccess:
            // 没有访问权限
            break;
        default:
            // 其他错误代码处理
            break;
    }
}

#include <windows.h>
// 使用createfile打开设备句柄
handle openusbdevice(const char* devicepath) {
    return createfile(
        devicepath,
        generic_read | generic_write,
        0,
        null,
        open_existing,
        file_attribute_normal,
        null);
}
// 执行usb读写操作
bool readwriteusb(handle hdevice, char* buffer, dword size, dword& bytesread) {
    bool result = deviceiocontrol(
        hdevice,
        ioctl_usb_read,
        buffer,
        size,
        buffer,
        size,
        &bytesread,
        null);
    return result;
}

using system;
using system.io;
using system.runtime.interopservices;

class usbreadwrite
{
    // p/invoke声明
    [dllimport("kernel32.dll", setlasterror = true)]
    static extern intptr createfile(
        string lpfilename,
        uint dwdesiredaccess,
        uint dwsharemode,
        intptr lpsecurityattributes,
        uint dwcreationdisposition,
        uint dwflagsandattributes,
        intptr htemplatefile);

    [dllimport("setupapi.dll", setlasterror = true)]
    static extern bool setupdigetclassdevs(
        ref guid classguid,
        intptr enumerator,
        intptr hwndparent,
        uint flags);

    // 使用createfile打开usb设备
    public static intptr openusbdevice(string devicepath)
    {
        return createfile(
            devicepath,
            win32consts.generic_read | win32consts.generic_write,
            win32consts.file_share_read | win32consts.file_share_write,
            intptr.zero,
            win32consts.open_existing,
            win32consts.file_attribute_normal,
            intptr.zero);
    }

    // 执行usb读操作
    public static bool readusb(intptr devicehandle, byte[] buffer, int size, out int bytesread)
    {
        uint bytesread32 = 0;
        bool result = readfile(devicehandle, buffer, size, out bytesread32, intptr.zero);
        bytesread = (int)bytesread32;
        return result;
    }
}