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

Question

How can I get the serial number of USB storage devices in .Net Core 2.1?

I found different solutions, but sadly they don't work due the lack of Windows registry and WMI support in .Net Core.

In Powershell it's really simple, but I wasn't able to find an implementation in Powershell Core.

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

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

I prefer a solution with no extra installation requirements on the clients (Win, Linux, Mac).

Answer 1

This Class performs a series of queries on the WMI Win32_DiskDrive class and its associators: Win32_DiskDriveToDiskPartition and CIM_LogicalDiskBasedOnPartition, to retrieve informations on the active USB Drives on a System (local or remote).

It might seem redundant (probably because it is), since you just asked for the USB Drives Serial Number. But, you never know what you will need next, and it could be useful to someone else.

It requires Microsoft .Net System.Management 4.5 for .Net Core 2.1 (NuGet Package)
Can be easily found and installed using the Visual Studio NuGet Package Manager.
About Linux support, read here:
Windows Management Instrumentation Now A Formal Bus With Linux 4.13

Also, keep an eye out for Windows Compatibility Pack for .NET Core.
New cross-platform assemblies are constantly added and updated.

The main class implements all the required functionalities and it has quite a simple structure.
The WMI queries use the Associator syntax, a method to correlate WMI class objects related to each other.
The Class properties meaning is self-explanatory.

Can be instantiated this way:
SystemUSBDrives systemUSBDrives = new SystemUSBDrives("[Computer Name]");

When [Computer Name] is null or empty, it uses the Local Machine name.

To get the List of USB Devices and their properties, call the GetUSBDrivesInfo() method:

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

[UserName], [Password], [Domain] are used to connect to a NT Domain.
These parameters, if not needed, can be null or an empty string.

Sample class instantiation and function call (Local Machine, no authentication):

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

---

Tested on:
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

Answer 2

Not sure if this is exactly what you're looking for, but here's some code I've used in the past.

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;
}