C# – How to identify what device was plugged into the USB slot

cplug-and-playusbwmi

I want to detect when the user plugs in or removes a USB sound card. I've managed to actually catch the event when this happens, but I can't tell what just got plugged in.

I tried an approach based on this question:

string query =
    "SELECT * FROM __InstanceCreationEvent " +
    "WITHIN 2 "
  + "WHERE TargetInstance ISA 'Win32_PnPEntity'";
var watcher = new ManagementEventWatcher(query);
watcher.EventArrived += new EventArrivedEventHandler(watcher_EventArrived);
watcher.Start();

While I get the notifications via the EventArrived event, I have no idea how to determine the actual name of the device that just got plugged in. I've gone through every property and couldn't make heads or tails out of it.

I also tried a different query:

var query = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent where EventType = 1 or EventType = 2");
var watcher = new ManagementEventWatcher(query);
watcher.EventArrived += watcher_EventArrived;
watcher.Stopped += watcher_Stopped;
watcher.Query = query;
watcher.Start();

but also to no avail. Is there a way to find the name of the device that got plugged in or removed.

The bottom line is that I'd like to know when a USB sound card is plugged in or removed from the system. It should work on Windows 7 and Vista (though I will settle for Win7 only).

EDIT: Based on the suggestions by the winning submitter, I've created a full solution that wraps all the functionality.

Best Answer

If I use your first code, I can define my event like this:

    // define USB class guid (from devguid.h)
    static readonly Guid GUID_DEVCLASS_USB = new Guid("{36fc9e60-c465-11cf-8056-444553540000}");

    static void watcher_EventArrived(object sender, EventArrivedEventArgs e)
    {
        ManagementBaseObject instance = (ManagementBaseObject )e.NewEvent["TargetInstance"];
        if (new Guid((string)instance["ClassGuid"]) == GUID_DEVCLASS_USB)
        {
            // we're only interested by USB devices, dump all props
            foreach (var property in instance.Properties)
            {
                Console.WriteLine(property.Name + " = " + property.Value);
            }
        }
    }

And this will dump something like this:

Availability =
Caption = USB Mass Storage Device
ClassGuid = {36fc9e60-c465-11cf-8056-444553540000}
CompatibleID = System.String[]
ConfigManagerErrorCode = 0
ConfigManagerUserConfig = False
CreationClassName = Win32_PnPEntity
Description = USB Mass Storage Device
DeviceID = USB\VID_18A5&PID_0243\07072BE66DD78609
ErrorCleared =
ErrorDescription =
HardwareID = System.String[]
InstallDate =
LastErrorCode =
Manufacturer = Compatible USB storage device
Name = USB Mass Storage Device
PNPDeviceID = USB\VID_18A5&PID_0243\07072BE66DD78609
PowerManagementCapabilities =
PowerManagementSupported =
Service = USBSTOR
Status = OK
StatusInfo =
SystemCreationClassName = Win32_ComputerSystem
SystemName = KILROY_WAS_HERE

This should contain everything you need, including the device ID that you can get with something like instance["DeviceID"].

Related Solutions

.net – Detect serial port insertion/removal

I ended up using WMI and @Hans' advice to check what serial ports are new/missing.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics.Contracts;
using System.IO.Ports;
using System.Management;

public static class SerialPortService
{
    private static SerialPort _serialPort;

    private static string[] _serialPorts;

    private static ManagementEventWatcher arrival;

    private static ManagementEventWatcher removal;

    static SerialPortService()
    {
        _serialPorts = GetAvailableSerialPorts();
        MonitorDeviceChanges();
    }

    /// <summary>
    /// If this method isn't called, an InvalidComObjectException will be thrown (like below):
    /// System.Runtime.InteropServices.InvalidComObjectException was unhandled
    ///Message=COM object that has been separated from its underlying RCW cannot be used.
    ///Source=mscorlib
    ///StackTrace:
    ///     at System.StubHelpers.StubHelpers.StubRegisterRCW(Object pThis, IntPtr pThread)
    ///     at System.Management.IWbemServices.CancelAsyncCall_(IWbemObjectSink pSink)
    ///     at System.Management.SinkForEventQuery.Cancel()
    ///     at System.Management.ManagementEventWatcher.Stop()
    ///     at System.Management.ManagementEventWatcher.Finalize()
    ///InnerException: 
    /// </summary>
    public static void CleanUp()
    {
        arrival.Stop();
        removal.Stop();
    }

    public static event EventHandler<PortsChangedArgs> PortsChanged;

    private static void MonitorDeviceChanges()
    {
        try
        {
            var deviceArrivalQuery = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent WHERE EventType = 2");
            var deviceRemovalQuery = new WqlEventQuery("SELECT * FROM Win32_DeviceChangeEvent WHERE EventType = 3");

            arrival = new ManagementEventWatcher(deviceArrivalQuery);
            removal = new ManagementEventWatcher(deviceRemovalQuery);

            arrival.EventArrived += (o, args) => RaisePortsChangedIfNecessary(EventType.Insertion);
            removal.EventArrived += (sender, eventArgs) => RaisePortsChangedIfNecessary(EventType.Removal);

            // Start listening for events
            arrival.Start();
            removal.Start();
        }
        catch (ManagementException err)
        {

        }
    }

    private static void RaisePortsChangedIfNecessary(EventType eventType)
    {
        lock (_serialPorts)
        {
            var availableSerialPorts = GetAvailableSerialPorts();
            if (!_serialPorts.SequenceEqual(availableSerialPorts))
            {
                _serialPorts = availableSerialPorts;
                PortsChanged.Raise(null, new PortsChangedArgs(eventType, _serialPorts));
            }
        }
    }

    public static string[] GetAvailableSerialPorts()
    {
        return SerialPort.GetPortNames();
    }
}

public enum EventType
{
    Insertion,
    Removal,
}

public class PortsChangedArgs : EventArgs
{
    private readonly EventType _eventType;

    private readonly string[] _serialPorts;

    public PortsChangedArgs(EventType eventType, string[] serialPorts)
    {
        _eventType = eventType;
        _serialPorts = serialPorts;
    }

    public string[] SerialPorts
    {
        get
        {
            return _serialPorts;
        }
    }

    public EventType EventType
    {
        get
        {
            return _eventType;
        }
    }
}

The MonitorDeviceChanges method actually sees all device changes (like Device Manager), but checking the serial ports allows us to only raise an event when those have changed.

To use the code, simply subscribe to the PortsChanged event, e.g. SerialPortService.PortsChanged += (sender1, changedArgs) => DoSomethingSerial(changedArgs.SerialPorts);

Oh, and the .Raise method is just an extension method I picked up somewhere:

/// <summary>
/// Tell subscribers, if any, that this event has been raised.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="handler">The generic event handler</param>
/// <param name="sender">this or null, usually</param>
/// <param name="args">Whatever you want sent</param>
public static void Raise<T>(this EventHandler<T> handler, object sender, T args) where T : EventArgs
{
    // Copy to temp var to be thread-safe (taken from C# 3.0 Cookbook - don't know if it's true)
    EventHandler<T> copy = handler;
    if (copy != null)
    {
        copy(sender, args);
    }
}

Using the SysInfo control in VB6 to detect when a USB device has been plugged/unplugged

Use the SysInfo_DeviceArrival event to detect insertion of a USB drive. SysInfo_DeviceRemoveComplete fires when it's removed.

There are a lot of events for the SysInfo control, so I wrote a test program to see what events happen. I do this often when working with a control that I haven't used before. The program that exercises the SysInfoControl is included below.

I made this by using the dropdown lists at the top of the VB6 code editing window: Select the SysInfo control in the left one, the select each of the events displayed in the right one. Add a Debug.Print statement to each, run the project, and plug in your USB device.

Also, if you select the SysInfo control in the form designer, then press F1, the MSDN library help should display which includes descriptions of all of the events and how to interpret their parameters. At least, it does on my machine. (I hate it when people say that, but it applies here because the MSDN docs have to be separately installed.)

If that doesn't work, I found the docs online here.

Option Explicit

Private Sub SysInfo_ConfigChangeCancelled()
    Debug.Print Now() & ": " & "SysInfo_ConfigChangeCancelled"
End Sub

Private Sub SysInfo_ConfigChanged(ByVal OldConfigNum As Long, ByVal NewConfigNum As Long)
    Debug.Print Now() & ": " & "SysInfo_ConfigChanged"
End Sub

Private Sub SysInfo_DeviceArrival(ByVal DeviceType As Long, ByVal DeviceID As Long, ByVal DeviceName As String, ByVal DeviceData As Long)
    Debug.Print Now() & ": " & "SysInfo_DeviceArrival"
End Sub

Private Sub SysInfo_DeviceOtherEvent(ByVal DeviceType As Long, ByVal EventName As String, ByVal DataPointer As Long)
    Debug.Print Now() & ": " & "SysInfo_DeviceOtherEvent"
End Sub

Private Sub SysInfo_DeviceQueryRemove(ByVal DeviceType As Long, ByVal DeviceID As Long, ByVal DeviceName As String, ByVal DeviceData As Long, Cancel As Boolean)
    Debug.Print Now() & ": " & "SysInfo_DeviceQueryRemove"
End Sub

Private Sub SysInfo_DeviceQueryRemoveFailed(ByVal DeviceType As Long, ByVal DeviceID As Long, ByVal DeviceName As String, ByVal DeviceData As Long)
    Debug.Print Now() & ": " & "SysInfo_DeviceQueryRemoveFailed"
End Sub

Private Sub SysInfo_DeviceRemoveComplete(ByVal DeviceType As Long, ByVal DeviceID As Long, ByVal DeviceName As String, ByVal DeviceData As Long)
    Debug.Print Now() & ": " & "SysInfo_DeviceRemoveComplete"
End Sub

Private Sub SysInfo_DeviceRemovePending(ByVal DeviceType As Long, ByVal DeviceID As Long, ByVal DeviceName As String, ByVal DeviceData As Long)
    Debug.Print Now() & ": " & "SysInfo_DeviceRemovePending"
End Sub

Private Sub SysInfo_DevModeChanged()
    Debug.Print Now() & ": " & "SysInfo_DevModeChanged"
End Sub

Private Sub SysInfo_DisplayChanged()
    Debug.Print Now() & ": " & "SysInfo_DisplayChanged"
End Sub

Private Sub SysInfo_PowerQuerySuspend(Cancel As Boolean)
    Debug.Print Now() & ": " & "SysInfo_PowerQuerySuspend"
End Sub

Private Sub SysInfo_PowerResume()
    Debug.Print Now() & ": " & "SysInfo_PowerResume"
End Sub

Private Sub SysInfo_PowerStatusChanged()
    Debug.Print Now() & ": " & "SysInfo_PowerStatusChanged"
End Sub

Private Sub SysInfo_PowerSuspend()
    Debug.Print Now() & ": " & "SysInfo_PowerSuspend"
End Sub

Private Sub SysInfo_QueryChangeConfig(Cancel As Boolean)
    Debug.Print Now() & ": " & "SysInfo_QueryChangeConfig"
End Sub

Private Sub SysInfo_SettingChanged(ByVal Item As Integer)
    Debug.Print Now() & ": " & "SysInfo_SettingChanged"
End Sub

Private Sub SysInfo_SysColorsChanged()
    Debug.Print Now() & ": " & "SysInfo_SysColorsChanged"
End Sub

Private Sub SysInfo_TimeChanged()
    Debug.Print Now() & ": " & "SysInfo_TimeChanged"
End Sub

Best Answer

Related Solutions

.net – Detect serial port insertion/removal

Using the SysInfo control in VB6 to detect when a USB device has been plugged/unplugged

Related Topic