.Net Core 2.1获取USB存储设备序列号

Question

如何在.Net Core 2.1中获取USB存储设备的序列号？

我找到了不同的解决方案，但遗憾的是，由于 .Net Core 中缺少 Windows 注册表和 WMI 支持，它们无法正常工作。

在 Powershell 中它非常简单，但我无法在 Powershell Core 中找到实现。

PS C:\> Get-Disk | Select-Object SerialNumber

SerialNumber
------------
0008_0D02_0021_9852.

我更喜欢对客户端没有额外安装要求的解决方案（Win、Linux、Mac）。

Answer 1

不确定这是否正是您要查找的内容，但这是我过去使用过的一些代码。

using System.Management;

public class USBDeviceInfo
{
    public string Availability { get; set; }
    public string Caption { get; set; }
    public string ClassCode { get; set; }
    public uint ConfigManagerErrorCode { get; set; }
    public bool ConfigManagerUserConfig { get; set; }
    public string CreationClassName { get; set; }
    public string CurrentAlternateSettings { get; set; }
    public string CurrentConfigValue { get; set; }
    public string Description { get; set; }
    public string DeviceID { get; set; }
    public string ErrorCleared { get; set; }
    public string ErrorDescription { get; set; }
    public string GangSwitched { get; set; }
    public string InstallDate { get; set; }
    public string LastErrorCode { get; set; }
    public string Name { get; set; }
    public string NumberOfConfigs { get; set; }
    public string NumberOfPorts { get; set; }
    public string PNPDeviceID { get; set; }
    public string PowerManagementCapabilities { get; set; }
    public string PowerManagementSupported { get; set; }
    public string ProtocolCode { get; set; }
    public string Status { get; set; }
    public string StatusInfo { get; set; }
    public string SubclassCode { get; set; }
    public string SystemCreationClassName { get; set; }
    public string SystemName { get; set; }
    public string USBVersion { get; set; }
}

public static List<USBDeviceInfo> GetUSBDevices()
{
    ManagementObjectSearcher searcher = new ManagementObjectSearcher(@"Select * From Win32_USBHub");
    ManagementObjectCollection collection = searcher.Get();

    List<USBDeviceInfo> devices = new List<USBDeviceInfo>();
    foreach (var device in collection)
    {
        USBDeviceInfo deviceInfo = new USBDeviceInfo();
        deviceInfo.Availability = (string)device.GetPropertyValue("Availability");
        deviceInfo.Caption = (string)device.GetPropertyValue("Caption");
        deviceInfo.ClassCode = (string)device.GetPropertyValue("ClassCode");
        deviceInfo.ConfigManagerErrorCode = (uint)device.GetPropertyValue("ConfigManagerErrorCode");
        deviceInfo.ConfigManagerUserConfig = (bool)device.GetPropertyValue("ConfigManagerUserConfig");
        deviceInfo.CreationClassName = (string)device.GetPropertyValue("CreationClassName");
        deviceInfo.CurrentAlternateSettings = (string)device.GetPropertyValue("CurrentAlternateSettings");
        deviceInfo.CurrentConfigValue = (string)device.GetPropertyValue("CurrentConfigValue");
        deviceInfo.Description = (string)device.GetPropertyValue("Description");
        deviceInfo.DeviceID = (string)device.GetPropertyValue("DeviceID");
        deviceInfo.ErrorCleared = (string)device.GetPropertyValue("ErrorCleared");
        deviceInfo.ErrorDescription = (string)device.GetPropertyValue("ErrorDescription");
        deviceInfo.GangSwitched = (string)device.GetPropertyValue("GangSwitched");
        deviceInfo.InstallDate = (string)device.GetPropertyValue("InstallDate");
        deviceInfo.LastErrorCode = (string)device.GetPropertyValue("LastErrorCode");
        deviceInfo.Name = (string)device.GetPropertyValue("Name");
        deviceInfo.NumberOfConfigs = (string)device.GetPropertyValue("NumberOfConfigs");
        deviceInfo.NumberOfPorts = (string)device.GetPropertyValue("NumberOfPorts");
        deviceInfo.PNPDeviceID = (string)device.GetPropertyValue("PNPDeviceID");
        deviceInfo.PowerManagementCapabilities = (string)device.GetPropertyValue("PowerManagementCapabilities");
        deviceInfo.PowerManagementSupported = (string)device.GetPropertyValue("PowerManagementSupported");
        deviceInfo.ProtocolCode = (string)device.GetPropertyValue("ProtocolCode");
        deviceInfo.Status = (string)device.GetPropertyValue("Status");
        deviceInfo.StatusInfo = (string)device.GetPropertyValue("StatusInfo");
        deviceInfo.SubclassCode = (string)device.GetPropertyValue("SubclassCode");
        deviceInfo.SystemCreationClassName = (string)device.GetPropertyValue("SystemCreationClassName");
        deviceInfo.SystemName = (string)device.GetPropertyValue("SystemName");
        deviceInfo.USBVersion = (string)device.GetPropertyValue("USBVersion");
        devices.Add(deviceInfo);
    }

    collection.Dispose();
    searcher.Dispose();
    return devices;
}

Answer 2

此 Class 在 WMI Win32_DiskDrive class and its associators: Win32_DiskDriveToDiskPartition and CIM_LogicalDiskBasedOnPartition 上执行一系列查询，以检索有关系统（本地或远程）上活动 USB 驱动器的信息。

这似乎是多余的（可能是因为它是多余的），因为您刚刚询问了 USB 驱动器序列号。但是，您永远不知道接下来需要什么，它可能对其他人有用。

.Net Core 2.1（NuGet 包）需要 Microsoft .Net System.Management 4.5
可以使用 Visual Studio NuGet Package Manager.
轻松找到并安装关于 Linux 支持，请阅读此处：
Windows Management Instrumentation Now A Formal Bus With Linux 4.13

此外，请留意 Windows Compatibility Pack for .NET Core。
不断添加和更新新的跨平台程序集。

主要 class 实现了所有必需的功能，并且结构非常简单。
WMI 查询使用 Associator 语法，这是一种关联 WMI class 对象的方法。
Class 属性含义不言自明。

可以这样实例化：
SystemUSBDrives systemUSBDrives = new SystemUSBDrives("[Computer Name]");

当 [Computer Name] 为 null 或空时，它使用本地计算机名称。

要获取 USB 设备列表及其属性，请调用 GetUSBDrivesInfo() 方法：

var USBDrivesEnum = systemUSBDrives.GetUSBDrivesInfo([UserName], [Password], [Domain]);

[UserName], [Password], [Domain] 用于连接到 NT 域。
如果不需要，这些参数可以为 null 或空字符串。

示例 class 实例化和函数调用 (Local Machine, no authentication):

SystemUSBDrives systemUSBDrives = new SystemUSBDrives(null);
var USBDrivesEnum = systemUSBDrives.GetUSBDrivesInfo(null, null, null);

测试于：
Visual Studio Pro 15.7.6 - 15.9.35
.Net Core 2.1 / .Net Framework 4.8
C# 6.0 -> 7.3
.Net System.Management 4.5

using System.Management;

public class SystemUSBDrives
{
    string m_ComputerName = string.Empty;
    public SystemUSBDrives(string ComputerName) {
        this.m_ComputerName = string.IsNullOrEmpty(ComputerName)
                            ? Environment.MachineName
                            : ComputerName;
    }

    private static EnumerationOptions GetEnumerationOptions(bool DeepScan)
    {
        var mOptions = new EnumerationOptions()
        {
            Rewindable = false,        //Forward only query => no caching
            ReturnImmediately = true,  //Pseudo-async result
            DirectRead = true,
            EnumerateDeep = DeepScan
        };
        return mOptions;
    }

    private static ConnectionOptions GetConnectionOptions() => GetConnectionOptions("", "", "");

    private static ConnectionOptions GetConnectionOptions(string userName, string password, string domain)
    {
        var connOptions = new ConnectionOptions()
        {
            EnablePrivileges = true,
            Timeout = ManagementOptions.InfiniteTimeout,
            Authentication = AuthenticationLevel.PacketPrivacy,
            Impersonation = ImpersonationLevel.Impersonate,
            Username = userName,
            Password = password,
            Authority = !string.IsNullOrEmpty(Domain) ? $"NTLMDOMAIN:{domain}" : string.Empty  //Authority = "NTLMDOMAIN:[domain]"
        };
        return connOptions;
    }

    public List<USBDriveInfo> GetUSBDrivesInfo(string userName, string password, string domain)
    {
        var wmiQueryResult = new List<USBDriveInfo>();
        ConnectionOptions connOptions = GetConnectionOptions(userName, password, domain);
        EnumerationOptions mOptions = GetEnumerationOptions(false);
        var mScope = new ManagementScope($@"\{this.m_ComputerName}\root\CIMV2", connOptions);
        var selQuery = new SelectQuery("SELECT * FROM Win32_DiskDrive WHERE InterfaceType='USB'");
        mScope.Connect();

        using (var moSearcher = new ManagementObjectSearcher(mScope, selQuery, mOptions)) {
            foreach (ManagementObject moDiskDrive in moSearcher.Get()) {
                var usbInfo = new USBDriveInfo();
                usbInfo.GetDiskDriveInfo(moDiskDrive);

                var relQuery = new RelatedObjectQuery(
                    $"Associators of {{Win32_DiskDrive.DeviceID='{moDiskDrive.Properties["DeviceID"].Value}'}} " +
                    $"WHERE AssocClass = Win32_DiskDriveToDiskPartition");
                using (var moAssocPart = new ManagementObjectSearcher(mScope, relQuery, mOptions)) {
                    foreach (ManagementObject moAssocPartition in moAssocPart.Get()) {

                        usbInfo.GetDiskPartitionInfo(moAssocPartition);
                        relQuery = new RelatedObjectQuery(
                            $"Associators of {{Win32_DiskPartition.DeviceID='{moAssocPartition.Properties["DeviceID"].Value}'}} " +
                            $"WHERE AssocClass = CIM_LogicalDiskBasedOnPartition");

                        using (var moLogDisk = new ManagementObjectSearcher(mScope, relQuery, mOptions)) {
                            foreach (ManagementObject moLogDiskEnu in moLogDisk.Get()) {
                                usbInfo.GetLogicalDiskInfo(moLogDiskEnu);
                                moLogDiskEnu.Dispose();
                            }
                        }
                        moAssocPartition.Dispose();
                    }
                    wmiQueryResult.Add(usbInfo);
                }
                moDiskDrive.Dispose();
            }
            return wmiQueryResult;
        }
    }   //GetUSBDrivesInfo()

    public class USBDriveInfo
    {
        private int m_PartionsCount = 0;
        public USBDriveInfo() => this.Partitions = new List<Partition>(1);
        public string Caption { get; private set; }
        public string DeviceID { get; private set; }
        public string FirmwareRevision { get; private set; }
        public ulong FreeSpace { get; private set; }
        public string InterfaceType { get; private set; }
        public bool MediaLoaded { get; private set; }
        public string MediaType { get; private set; }
        public string Model { get; private set; }
        public uint NumberOfPartitions { get; private set; }
        public List<Partition> Partitions { get; private set; }
        public string PNPDeviceID { get; private set; }
        public string SerialNumber { get; private set; }
        public ulong Size { get; private set; }
        public string Status { get; private set; }
        public ulong TotalCylinders { get; private set; }
        public uint TotalHeads { get; private set; }
        public ulong TotalSectors { get; private set; }
        public ulong TotalTracks { get; private set; }
        public uint TracksPerCylinder { get; private set; }

        public class Partition
        {
            public Partition() => this.LogicalDisks = new List<LogicalDisk>();
            public bool Bootable { get; internal set; }
            public bool BootPartition { get; internal set; }
            public uint DiskIndex { get; internal set; }
            public List<LogicalDisk> LogicalDisks { get; internal set; }
            public ulong PartitionBlockSize { get; internal set; }
            public ulong PartitionNumberOfBlocks { get; internal set; }
            public ulong PartitionStartingOffset { get; internal set; }
            public bool PrimaryPartition { get; internal set; }
        }

        public class LogicalDisk
        {
            public ulong FreeSpace { get; internal set; }
            public string FileSystem { get; internal set; }
            public string LogicalDiskVolume { get; internal set; }
            public bool SupportsDiskQuotas { get; internal set; }
            public string VolumeName { get; internal set; }
            public string VolumeSerialNumber { get; internal set; }
        }

        internal void GetDiskDriveInfo(ManagementObject DiskDrive)
        {
            this.Caption = DiskDrive.GetPropertyValue("Caption")?.ToString();
            this.DeviceID = DiskDrive["DeviceID"]?.ToString();
            this.FirmwareRevision = DiskDrive["FirmwareRevision"]?.ToString();
            this.InterfaceType = DiskDrive["InterfaceType"]?.ToString();
            this.MediaLoaded = (bool?)DiskDrive["MediaLoaded"] ?? false;
            this.MediaType = DiskDrive["MediaType"]?.ToString();
            this.Model = DiskDrive["Model"]?.ToString();
            this.NumberOfPartitions = (uint?)DiskDrive["Partitions"] ?? 0;
            this.PNPDeviceID = DiskDrive["PNPDeviceID"]?.ToString();
            this.SerialNumber = DiskDrive["SerialNumber"]?.ToString();
            this.Size = (ulong?)DiskDrive["Size"] ?? 0L;
            this.Status = DiskDrive["Status"]?.ToString();
            this.TotalCylinders = (ulong?)DiskDrive["TotalCylinders"] ?? 0;
            this.TotalHeads = (uint?)DiskDrive["TotalHeads"] ?? 0U;
            this.TotalSectors = (ulong?)DiskDrive["TotalSectors"] ?? 0;
            this.TotalTracks = (ulong?)DiskDrive["TotalTracks"] ?? 0;
            this.TracksPerCylinder = (uint?)DiskDrive["TracksPerCylinder"] ?? 0;
        }

        internal void GetDiskPartitionInfo(ManagementObject Partitions)
        {
            m_PartionsCount += 1;
            this.Partitions.Add(new Partition()
            {
                DiskIndex = (uint?)Partitions["DiskIndex"] ?? 0,
                PartitionBlockSize = (ulong?)Partitions["BlockSize"] ?? 0,
                Bootable = (bool?)Partitions["Bootable"] ?? false,
                BootPartition = (bool?)Partitions["BootPartition"] ?? false,
                PartitionNumberOfBlocks = (ulong?)Partitions["NumberOfBlocks"] ?? 0,
                PrimaryPartition = (bool?)Partitions["PrimaryPartition"] ?? false,
                PartitionStartingOffset = (ulong?)Partitions["StartingOffset"] ?? 0
            });
        }

        internal void GetLogicalDiskInfo(ManagementObject LogicalDisk)
        {
            if (m_PartionsCount == 0) return;
            this.Partitions[m_PartionsCount - 1].LogicalDisks.Add(new LogicalDisk()
            {
                FileSystem = LogicalDisk["FileSystem"]?.ToString(),
                FreeSpace = (ulong?)LogicalDisk["FreeSpace"] ?? 0,
                LogicalDiskVolume = LogicalDisk["DeviceID"]?.ToString(),
                SupportsDiskQuotas = (bool?)LogicalDisk["SupportsDiskQuotas"] ?? false,
                VolumeName = LogicalDisk["VolumeName"]?.ToString(),
                VolumeSerialNumber = LogicalDisk["VolumeSerialNumber"]?.ToString()
            });
            //Linq's Sum() does not sum ulong(s)
            foreach(Partition p in this.Partitions)
            {
                foreach (LogicalDisk ld in p.LogicalDisks) {
                    this.FreeSpace += ld.FreeSpace;
                }
            }
        }
    }
} // SystemUSBDrives

.Net Core 2.1获取USB存储设备序列号

Get the serial number of USB storage devices in .Net Core 2.1

c#

.net-core

wmi

usb-drive

.net-core-2.1