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盘。