USB设备的插入和弹出的监听以及软弹出可移动媒体（如Windows的移除USB设备） .

一、监听USB设备的插入和弹出

当USB设备插入或者弹出时，Windows会产生一条全局消息：WM_DEVICECHANGE

我们需要做的是，获得这条消息的wParam参数，如果为DBT_DEVICEARRIVAL则表示有设备插入并可用，

如果是DBT_DEVICEREMOVECOMPLETE则表示有设备已经移除。再查看lParam参数为DBT_DEVTYP_VOLUME时，

就可以取出DEV_BROADCAST_VOLUME结构的卷号dbcv_unitmask，就知道是哪个卷被插入或者弹出。

代码片段如下：

using System;
using System.Runtime.InteropServices;
/// <summary>
/// 监听设备的插入和拔出
/// </summary>
public class DriveDetector
{
/// <summary>
/// 设备插入事件
/// </summary>
public event EventHandler<DriveDectctorEventArgs> DeviceArrived = null;
/// <summary>
/// 设备拔出事件
/// </summary>
public event EventHandler<DriveDectctorEventArgs> DeviceRemoved = null;
/// <summary>
/// 消息处理(HwndSourceHook委托的签名)
/// </summary>
/// <param name="hwnd"></param>
/// <param name="msg"></param>
/// <param name="wParam"></param>
/// <param name="lParam"></param>
/// <param name="handled"></param>
/// <returns></returns>
public IntPtr WndProc(
IntPtr hwnd,
int msg,
IntPtr wParam,
IntPtr lParam,
ref bool handled)
{
if (msg == NativeConstants.WM_DEVICECHANGE)
{
#warning USB设备检测目前只支持32位系统)
switch (wParam.ToInt32())
{
case NativeConstants.DBT_DEVICEARRIVAL:
{
var devType = Marshal.ReadInt32(lParam, 4);
if (devType == NativeConstants.DBT_DEVTYP_VOLUME)
{
var drive = GetDrive(lParam);
if (DeviceArrived != null)
{
var args = new DriveDectctorEventArgs(drive);
DeviceArrived(this, args); //触发设备插入事件
}
}
}
break;
case NativeConstants.DBT_DEVICEREMOVECOMPLETE:
{
var devType = Marshal.ReadInt32(lParam, 4);
if (devType == NativeConstants.DBT_DEVTYP_VOLUME)
{
var drive = GetDrive(lParam);
if (DeviceRemoved != null)
{
var args = new DriveDectctorEventArgs(drive);
DeviceRemoved(this, args);
}
}
}
break;
}
}
return IntPtr.Zero;
}
private static string GetDrive(IntPtr lParam)
{
var volume = (DEV_BROADCAST_VOLUME)Marshal.PtrToStructure(lParam, typeof(DEV_BROADCAST_VOLUME));
var letter = GetLetter(volume.dbcv_unitmask);
return string.Format("{0}://", letter);
}
/// <summary>
/// 获得盘符
/// </summary>
/// <param name="dbcvUnitmask">
/// 1 = A
/// 2 = B
/// 4 = C...
/// </param>
/// <returns>结果是A~Z的任意一个字符或者为'?'</returns>
private static char GetLetter(uint dbcvUnitmask)
{
const char nona = '?';
const string drives = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if (dbcvUnitmask == 0) return nona;
var i = 0;
var pom = dbcvUnitmask >> 1;
while (pom != 0)
{
pom = pom >> 1;
i++;
}
if (i < drives.Length)
return drives[i];
return nona;
}
/*
private static void GetLetterTest()
{
for (int i = 0; i < 67108864; i++)
{
Console.WriteLine("{0} - {1}", i, GetLetter((uint)i));
i = i << 1;
}
//0 - ?
//1 - A
//3 - B
//7 - C
//15 - D
//31 - E
//63 - F
//127 - G
//255 - H
//511 - I
//1023 - J
//2047 - K
//4095 - L
//8191 - M
//16383 - N
//32767 - O
//65535 - P
//131071 - Q
//262143 - R
//524287 - S
//1048575 - T
//2097151 - U
//4194303 - V
//8388607 - W
//16777215 - X
//33554431 - Y
//67108863 - Z
}*/
/// <summary>
/// 设备插入或拔出事件
/// </summary>
public class DriveDectctorEventArgs : EventArgs
{
/// <summary>
/// 获得设备卷标
/// </summary>
public string Drive { get; private set; }
public DriveDectctorEventArgs(string drive)
{
Drive = drive ?? string.Empty;
}
}
#region Win32 API
public partial class NativeConstants
{
/// WM_DEVICECHANGE -> 0x0219
public const int WM_DEVICECHANGE = 537;
/// BROADCAST_QUERY_DENY -> 0x424D5144
//public const int BROADCAST_QUERY_DENY = 1112363332;
//public const int DBT_DEVTYP_DEVICEINTERFACE = 5;
//public const int DBT_DEVTYP_HANDLE = 6;
public const int DBT_DEVICEARRIVAL = 0x8000; // system detected a new device
//public const int DBT_DEVICEQUERYREMOVE = 0x8001; // Preparing to remove (any program can disable the removal)
public const int DBT_DEVICEREMOVECOMPLETE = 0x8004; // removed
public const int DBT_DEVTYP_VOLUME = 0x00000002; // drive type is logical volume
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct DEV_BROADCAST_VOLUME
{
/// DWORD->unsigned int
public uint dbcv_size;
/// DWORD->unsigned int
public uint dbcv_devicetype;
/// DWORD->unsigned int
public uint dbcv_reserved;
/// DWORD->unsigned int
public uint dbcv_unitmask;
/// WORD->unsigned short
public ushort dbcv_flags;
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct OVERLAPPED
{
/// ULONG_PTR->unsigned int
public uint Internal;
/// ULONG_PTR->unsigned int
public uint InternalHigh;
/// Anonymous_7416d31a_1ce9_4e50_b1e1_0f2ad25c0196
public Anonymous_7416d31a_1ce9_4e50_b1e1_0f2ad25c0196 Union1;
/// HANDLE->void*
public System.IntPtr hEvent;
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Explicit)]
public struct Anonymous_7416d31a_1ce9_4e50_b1e1_0f2ad25c0196
{
/// Anonymous_ac6e4301_4438_458f_96dd_e86faeeca2a6
[System.Runtime.InteropServices.FieldOffsetAttribute(0)]
public Anonymous_ac6e4301_4438_458f_96dd_e86faeeca2a6 Struct1;
/// PVOID->void*
[System.Runtime.InteropServices.FieldOffsetAttribute(0)]
public System.IntPtr Pointer;
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct Anonymous_ac6e4301_4438_458f_96dd_e86faeeca2a6
{
/// DWORD->unsigned int
public uint Offset;
/// DWORD->unsigned int
public uint OffsetHigh;
}
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct SECURITY_ATTRIBUTES
{
/// DWORD->unsigned int
public uint nLength;
/// LPVOID->void*
public System.IntPtr lpSecurityDescriptor;
/// BOOL->int
[System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.Bool)]
public bool bInheritHandle;
}
#endregion
}

现在，你可以在你的UI线程上创建一个DriveDetector对象，监听DeviceArrived和DeviceRemoved事件。

然后通过该对象WndProc方法，传递UI线程上的消息。WPF程序可以直接用HwndSource对象AddHook，此方法的签名

与HwndSourceHook委托相同。WinForm程序也没关系，override窗口的void WndProc(ref Message m)方法，按

DriveDetector对象的WndProc签名格式，将m数据传入，或者干脆自己写个WinForm版本的。

我的演示代码效果图如下：（注，上述代码未提供显示代码，请自己编写）

另外，关于磁盘容量的监视可以使用FileSystemWatcher对象。

请参考：http://msdn.microsoft.com/zh-cn/library/cc437966.aspx

摘取代码如下：

using System;
using System.IO;
using System.Security.Permissions;
public class Watcher
{
public static void Main()
{
Run();
}
[PermissionSet(SecurityAction.Demand, Name="FullTrust")]
public static void Run()
{
string[] args = System.Environment.GetCommandLineArgs();
// If a directory is not specified, exit program.
if(args.Length != 2)
{
// Display the proper way to call the program.
Console.WriteLine("Usage: Watcher.exe (directory)");
return;
}
// Create a new FileSystemWatcher and set its properties.
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = args[1];
/* Watch for changes in LastAccess and LastWrite times, and
the renaming of files or directories. */
watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName | NotifyFilters.DirectoryName;
// Only watch text files.
//watcher.Filter = "*.txt";
watcher.IncludeSubdirectories=true;
// Add event handlers.
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.Created += new FileSystemEventHandler(OnChanged);
watcher.Deleted += new FileSystemEventHandler(OnChanged);
watcher.Renamed += new RenamedEventHandler(OnRenamed);
// Begin watching.
watcher.EnableRaisingEvents = true;
// Wait for the user to quit the program.
Console.WriteLine("Press /'q/' to quit the sample.");
while(Console.Read()!='q');
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
// Specify what is done when a file is changed, created, or deleted.
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
}
private static void OnRenamed(object source, RenamedEventArgs e)
{
// Specify what is done when a file is renamed.
Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
}
}

二、软件弹出可移动媒体

网上有一部分关于这方法的代码，我的代码是从MSDN获取的VC++版本，需要调用多个API函数，转换为C#代码如下：

参考：http://support.microsoft.com/kb/165721

using System;
using System.Runtime.InteropServices;
using System.Threading;
/// <summary>
/// 弹出可移动媒体
/// </summary>
/// <see cref="http://support.microsoft.com/kb/165721"/>
public static class Eject
{
private static void ReportError(string szMsg)
{
const string szErrorFormat = "Error {0}: {1}";
var error = string.Format(szErrorFormat, GetLastError(), szMsg);
Console.Error.WriteLine(error);
}
private static IntPtr OpenVolume(char driveLetter)
{
const string volumeFormat = "////.//{0}:";
const string rootFormat = "{0}://";
int accessFlags;
var rootName = string.Format(rootFormat, driveLetter);
var driveType = GetDriveTypeW(rootName);
switch (driveType)
{
case DRIVE_REMOVABLE:
accessFlags = GENERIC_READ | GENERIC_WRITE;
break;
case DRIVE_CDROM:
accessFlags = GENERIC_READ;
break;
default:
Console.Error.WriteLine("Cannot eject. Drive type is incorrect.");
return new IntPtr(INVALID_HANDLE_VALUE);
}
var volumeName = string.Format(volumeFormat, driveLetter);
var hVolume = CreateFileW(
volumeName,
accessFlags,
FILE_SHARE_READ | FILE_SHARE_WRITE,
IntPtr.Zero,
OPEN_EXISTING,
0,
IntPtr.Zero);
if (hVolume == new IntPtr(INVALID_HANDLE_VALUE))
ReportError("CreateFile");
return hVolume;
}
private static bool CloseVolume(IntPtr hVolume)
{
return CloseHandle(hVolume);
}
private static bool LockVolume(IntPtr hVolume)
{
const int LOCK_TIMEOUT = 10000; //10 Seconds
const int LOCK_RETRIES = 20;
var sleepAmount = LOCK_TIMEOUT / LOCK_RETRIES;
//Do this in a loop until a timeout period has expired
for (int tryCount = 0; tryCount < LOCK_RETRIES; tryCount++)
{
int dwBytesReturned;
if (DeviceIoControl(
hVolume,
FSCTL_LOCK_VOLUME,
IntPtr.Zero, 0,
IntPtr.Zero, 0,
out dwBytesReturned,
IntPtr.Zero))
return true; //return
Thread.Sleep(sleepAmount);
}
return false;
}
private static bool DismountVolume(IntPtr hVolume)
{
int dwBytesReturned;
return DeviceIoControl(
hVolume,
FSCTL_DISMOUNT_VOLUME,
IntPtr.Zero, 0,
IntPtr.Zero, 0,
out dwBytesReturned,
IntPtr.Zero);
}
private static bool PresentRemovalOfVolume(IntPtr hVolume,bool preventRemoval)
{
PREVENT_MEDIA_REMOVAL pmrBuffer;
pmrBuffer.PreventMediaRemoval = preventRemoval;
var size = Marshal.SizeOf(pmrBuffer);
IntPtr ptr = Marshal.AllocHGlobal(size);
try
{
Marshal.StructureToPtr(pmrBuffer, ptr, false);
int dwBytesReturned;
return DeviceIoControl(
hVolume,
IOCTL_STORAGE_MEDIA_REMOVAL,
ptr, (uint) size,
IntPtr.Zero, 0,
out dwBytesReturned,
IntPtr.Zero
);
}
finally
{
Marshal.DestroyStructure(ptr, pmrBuffer.GetType());
}
}
private static bool AutoEjectVolume(IntPtr hVolume)
{
int dwBytesReturned;
return DeviceIoControl(
hVolume,
IOCTL_STORAGE_EJECT_MEDIA,
IntPtr.Zero, 0,
IntPtr.Zero, 0,
out dwBytesReturned,
IntPtr.Zero);
}
private static bool RemoveVolumeDefinition(string deviceName)
{
return DefineDosDeviceW(DDD_REMOVE_DEFINITION, deviceName, null);
}
public static bool EjectVolume(char driveLetter, bool removeVolumeDefinition)
{
var removeSafely = false;
var autoEject = false;
//Open the volume.
var hVolume = OpenVolume(driveLetter);
if (hVolume == new IntPtr(INVALID_HANDLE_VALUE))
return false;
//Lock and dismount the volume.
if(LockVolume(hVolume)&&DismountVolume(hVolume))
{
removeSafely = true;
//Set prevent removal to false and eject the volume.
if (PresentRemovalOfVolume(hVolume, false) && AutoEjectVolume(hVolume))
autoEject = true;
}
//Close the volume so other processes can use the drive.
if (!CloseVolume(hVolume))
return false;
if(autoEject)
{
Console.Out.WriteLine("Media in Drive {0} has been ejected safely.",driveLetter);
}
else
{
if (removeSafely)
{
Console.Out.WriteLine("Media in Drive {0} can be safely removed.", driveLetter);
}
else
{
Console.Error.WriteLine("Media in Drive {0} is working, and can't be safely removed.", driveLetter);
return false;
}
}
if(removeVolumeDefinition) RemoveVolumeDefinition(string.Format("{0}:", driveLetter));
return true;
}
public static void Usage()
{
Console.Out.WriteLine("Usage: Eject <drive letter>");
Console.Out.WriteLine();
}
static void Main(string[] args)
{
if(args.Length != 1)
{
Usage();
return;
}
if(!EjectVolume(args[0][0], true))
{
Console.Error.WriteLine("Failure ejecting drive {0}.",args[0][0]);
}
}
#region WIN32 API
/// Return Type: DWORD->unsigned int
[System.Runtime.InteropServices.DllImportAttribute("kernel32.dll", EntryPoint = "GetLastError")]
public static extern uint GetLastError();
/// Return Type: UINT->unsigned int
///lpRootPathName: LPCWSTR->WCHAR*
[System.Runtime.InteropServices.DllImportAttribute("kernel32.dll", EntryPoint = "GetDriveTypeW")]
public static extern uint GetDriveTypeW([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPWStr)] string lpRootPathName);
/// Return Type: HANDLE->void*
///lpFileName: LPCWSTR->WCHAR*
///dwDesiredAccess: DWORD->unsigned int
///dwShareMode: DWORD->unsigned int
///lpSecurityAttributes: LPSECURITY_ATTRIBUTES->_SECURITY_ATTRIBUTES*
///dwCreationDisposition: DWORD->unsigned int
///dwFlagsAndAttributes: DWORD->unsigned int
///hTemplateFile: HANDLE->void*
[System.Runtime.InteropServices.DllImportAttribute("kernel32.dll", EntryPoint = "CreateFileW")]
public static extern System.IntPtr CreateFileW([System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPWStr)] string lpFileName, int dwDesiredAccess, uint dwShareMode, [System.Runtime.InteropServices.InAttribute()] System.IntPtr lpSecurityAttributes, uint dwCreationDisposition, uint dwFlagsAndAttributes, [System.Runtime.InteropServices.InAttribute()] System.IntPtr hTemplateFile);
/// Return Type: BOOL->int
///hObject: HANDLE->void*
[System.Runtime.InteropServices.DllImportAttribute("kernel32.dll", EntryPoint = "CloseHandle")]
[return: System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.Bool)]
public static extern bool CloseHandle([System.Runtime.InteropServices.InAttribute()] System.IntPtr hObject);
/// Return Type: BOOL->int
///hDevice: HANDLE->void*
///dwIoControlCode: DWORD->unsigned int
///lpInBuffer: LPVOID->void*
///nInBufferSize: DWORD->unsigned int
///lpOutBuffer: LPVOID->void*
///nOutBufferSize: DWORD->unsigned int
///lpBytesReturned: LPDWORD->DWORD*
///lpOverlapped: LPOVERLAPPED->_OVERLAPPED*
[System.Runtime.InteropServices.DllImportAttribute("kernel32.dll", EntryPoint = "DeviceIoControl")]
[return: System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.Bool)]
public static extern bool DeviceIoControl([System.Runtime.InteropServices.InAttribute()] System.IntPtr hDevice, uint dwIoControlCode, [System.Runtime.InteropServices.InAttribute()] System.IntPtr lpInBuffer, uint nInBufferSize, System.IntPtr lpOutBuffer, uint nOutBufferSize, out int lpBytesReturned, System.IntPtr lpOverlapped);
/// DRIVE_REMOVABLE -> 2
public const int DRIVE_REMOVABLE = 2;
/// DRIVE_CDROM -> 5
public const int DRIVE_CDROM = 5;
/// INVALID_HANDLE_VALUE -> -1
public const int INVALID_HANDLE_VALUE = -1;
/// GENERIC_READ -> (0x80000000L)
public const int GENERIC_READ = -2147483648;
/// GENERIC_WRITE -> (0x40000000L)
public const int GENERIC_WRITE = 1073741824;
/// FILE_SHARE_READ -> 0x00000001
public const int FILE_SHARE_READ = 1;
/// FILE_SHARE_WRITE -> 0x00000002
public const int FILE_SHARE_WRITE = 2;
/// OPEN_EXISTING -> 3
public const int OPEN_EXISTING = 3;
//WinIoCtl.h
//
//#define CTL_CODE( DeviceType, Function, Method, Access ) ( /
// ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) /
//)
private const int FILE_DEVICE_FILE_SYSTEM = 0x00000009;
private const int METHOD_BUFFERED = 0;
private const int FILE_ANY_ACCESS = 0;
//#define FSCTL_LOCK_VOLUME CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 6, METHOD_BUFFERED, FILE_ANY_ACCESS)
public const int FSCTL_LOCK_VOLUME = ((FILE_DEVICE_FILE_SYSTEM) << 16) | ((FILE_ANY_ACCESS) << 14) | ((6) << 2) | (METHOD_BUFFERED);
public const int FSCTL_UNLOCK_VOLUME = ((FILE_DEVICE_FILE_SYSTEM) << 16) | ((FILE_ANY_ACCESS) << 14) | ((7) << 2) | (METHOD_BUFFERED);
public const int FSCTL_DISMOUNT_VOLUME = ((FILE_DEVICE_FILE_SYSTEM) << 16) | ((FILE_ANY_ACCESS) << 14) | ((8) << 2) | (METHOD_BUFFERED);
//#define IOCTL_STORAGE_BASE FILE_DEVICE_MASS_STORAGE
private const int FILE_DEVICE_MASS_STORAGE = 0x0000002d;
private const int IOCTL_STORAGE_BASE = FILE_DEVICE_MASS_STORAGE;
//#define FILE_READ_ACCESS ( 0x0001 ) // file & pipe
private const int FILE_READ_ACCESS = 0x0001;
//#define IOCTL_STORAGE_MEDIA_REMOVAL CTL_CODE(IOCTL_STORAGE_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
public const int IOCTL_STORAGE_MEDIA_REMOVAL =
((IOCTL_STORAGE_BASE) << 16) | ((FILE_READ_ACCESS) << 14) | ((0x0201) << 2) | (METHOD_BUFFERED);
//#define IOCTL_STORAGE_EJECT_MEDIA CTL_CODE(IOCTL_STORAGE_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)
public const int IOCTL_STORAGE_EJECT_MEDIA =
((IOCTL_STORAGE_BASE) << 16) | ((FILE_READ_ACCESS) << 14) | ((0x0202) << 2) | (METHOD_BUFFERED);
[System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public struct PREVENT_MEDIA_REMOVAL
{
/// BOOLEAN->BYTE->unsigned char
[MarshalAs(UnmanagedType.I1)]
public bool PreventMediaRemoval;
}
#region Remove Volume Definition
/// DDD_REMOVE_DEFINITION -> 0x00000002
public const int DDD_REMOVE_DEFINITION = 2;
/// Return Type: BOOL->int
///dwFlags: DWORD->unsigned int
///lpDeviceName: LPCWSTR->WCHAR*
///lpTargetPath: LPCWSTR->WCHAR*
[System.Runtime.InteropServices.DllImportAttribute("kernel32.dll", EntryPoint="DefineDosDeviceW")]
[return: System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.Bool)]
public static extern bool DefineDosDeviceW(uint dwFlags, [System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPWStr)] string lpDeviceName, [System.Runtime.InteropServices.InAttribute()] [System.Runtime.InteropServices.MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.LPWStr)] string lpTargetPath) ;
#endregion
#endregion
}

预览：（注，弹出可移动磁盘，并不会删除驱动器号，但设备已经被弹出，如图中的h盘）

注：已改进，安全弹出后，通过DDD_REMOVE_DEFINITION移除h盘。