Sicheres Entfernen eines USB-Sticks

    • C#

    Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von RodFromGermany.

      Sicheres Entfernen eines USB-Sticks

      Moin Leute,
      bei Codeproject fand ich den Artikel How to Prepare a USB Drive for Safe Removal.
      Dabei waren die Quellen eines entsprechenden C-Projekts.

      In Ermangelung anderer Aufgaben habe ich mich rangesetzt und diesen Code nach C# überttragen.
      Mit freundlicher Zustimmung des Autors Uwe Sieber uwe-sieber.de
      möchte ich Euch an dem Projekt teilhaben lassen.
      Ich habe es unter Win10 mit x86 und x64 getestet, es dürfte also unter AnyCPU laufen.
      Ich habe die Kommentare etwas präzisiert, fragt aber bitte nicht, wie das ganze funktioniert, das weiß ich auch nicht so richtig.
      In der Vorlage wurden einige Rückgabewerte ignoriert, die teste ich ab, was zum Übertragen nach C# erforderlich war.
      Aus einigen der Strukturen habe ich Klassen gemacht. Dies war erforderlich, weil es Aufrufe mit null als Parameter gab.

      Das ganze ist hier als Console-Anwendung geschrieben, die eigentliche(n) Prozedur(en) ist aber separiert, so dass sie in jedes Projekt eingefügt werden können.

      Program.cs

      C#-Quellcode

      1. //#define TEST_FIXED_LETTER // Defaultwert zum einfachen Testen
      3. // Ursprüngliche C-Vorlage
      4. // https://www.codeproject.com/Articles/13839/How-to-Prepare-a-USB-Drive-for-Safe-Removal
      6. // System-Error-Codes vom Betriebssystem
      7. // https://docs.microsoft.com/en-us/windows/desktop/debug/system-error-codes--0-499-
      9. using System;
      10. using System.IO;
      11. using System.Runtime.InteropServices;
      12. using System.Runtime.Serialization;
      13. using System.Runtime.Serialization.Formatters.Binary;
      14. using System.Text;
      16. namespace RemoveDriveByLetter
      17. {
      18. using HANDLE = IntPtr;
      19. internal class Program
      20. {
      21. private static void Main(string[] args)
      22. {
      23. char driveLetter;
      24. #if TEST_FIXED_LETTER
      25. Console.WriteLine("################################################");
      26. driveLetter = 'F';
      27. Console.WriteLine("Fixed Letter '{0}'", driveLetter);
      28. Console.WriteLine("################################################");
      29. #else
      30. if (args.Length == 0)
      31. {
      32. Console.WriteLine("RemoveDriveByLetter X");
      33. Console.WriteLine("Press any key to exit");
      34. Console.ReadKey();
      35. return;
      36. }
      38. driveLetter = args[0][0];
      39. #endif
      40. Console.WriteLine("System: {0}", Environment.Is64BitProcess ? "x64" : "x86");
      41. Console.WriteLine();
      42. Program.Eject(driveLetter);
      43. Console.WriteLine("Press any key to exit");
      44. Console.ReadKey();
      45. }
      47. /// <summary>
      48. /// Stand Alone-Methode zum Auswerfen eines USB-Sticks mit dem Laufwerksbuchstaben
      49. /// </summary>
      50. /// <param name="driveLetter">der Laufwerksbuchstabe</param>
      51. /// <returns>Success</returns>
      52. private static bool Eject(char driveLetter)
      53. {
      54. driveLetter = char.ToUpper(driveLetter);
      55. if (driveLetter < 'A' || driveLetter > 'Z')
      56. {
      57. Console.WriteLine("Argument is not a Drive Letter");
      58. return false;
      59. }
      61. // "\\.\X:" -> to open the volume
      62. string szVolumeAccessPath = string.Format(@"\\.\{0}:", driveLetter);
      64. int deviceNumber = -1;
      66. // open the storage volume
      67. HANDLE hVolume = NativeMethods.CreateFile(szVolumeAccessPath, 0, System.IO.FileShare.Read | System.IO.FileShare.Write, IntPtr.Zero, System.IO.FileMode.Open, 0, IntPtr.Zero);
      68. if (hVolume == NativeMethods.INVALID_HANDLE_VALUE)
      69. {
      70. Console.WriteLine("Device not available");
      71. return false;
      72. }
      74. // get the volume's device number
      75. NativeMethods.STORAGE_DEVICE_NUMBER sdn = default(NativeMethods.STORAGE_DEVICE_NUMBER);
      76. uint dwBytesReturned = 0;
      77. bool res = NativeMethods.DeviceIoControl(hVolume, NativeMethods.IOCTL_STORAGE_GET_DEVICE_NUMBER, IntPtr.Zero, 0, ref sdn, Marshal.SizeOf(sdn), ref dwBytesReturned, IntPtr.Zero);
      78. if (res)
      79. {
      80. deviceNumber = sdn.DeviceNumber;
      81. }
      83. NativeMethods.CloseHandle(hVolume);
      85. if (deviceNumber == -1)
      86. {
      87. Console.WriteLine("Invalid Device Number");
      88. return false;
      89. }
      91. string szDevicePath = driveLetter + ":";
      92. System.IO.DriveInfo di = new System.IO.DriveInfo(szDevicePath);
      94. StringBuilder lpTargetPath = new StringBuilder(NativeMethods.MAX_PATH);
      95. // get the dos device name (like \device\floppy0) to decide if it's a floppy or not - who knows a better way?
      96. res = NativeMethods.QueryDosDevice(szDevicePath, lpTargetPath, NativeMethods.MAX_PATH);
      97. if (!res)
      98. {
      99. Console.WriteLine("Invalid Device");
      100. return false;
      101. }
      103. // get the device instance handle of the storage volume by means of a SetupDi enum and matching the device number
      104. int devInst = Program.GetDrivesDevInstByDeviceNumber(deviceNumber, di.DriveType, lpTargetPath.ToString());
      106. if (devInst == 0)
      107. {
      108. return false;
      109. }
      111. NativeMethods.PNP_VETO_TYPE VetoType = NativeMethods.PNP_VETO_TYPE.PNP_VetoTypeUnknown;
      112. char[] VetoNameW = new char[NativeMethods.MAX_PATH];
      113. VetoNameW[0] = '\0';
      114. bool bSuccess = false;
      116. // get drives's parent, e.g. the USB bridge, the SATA port, an IDE channel with two drives!
      117. uint DevInstParent = 0;
      118. uint res2 = NativeMethods.CM_Get_Parent(out DevInstParent, devInst, 0);
      119. // res2 = 0 !
      120. for (int tries = 1; tries <= 3; tries++)
      121. {
      122. // sometimes we need some tries...
      123. VetoNameW[0] = '\0';
      125. res2 = NativeMethods.CM_Request_Device_Eject(DevInstParent, out VetoType, VetoNameW, NativeMethods.MAX_PATH, 0);
      127. bSuccess = (res2 == 0 && VetoType == NativeMethods.PNP_VETO_TYPE.PNP_VetoTypeUnknown);
      128. if (bSuccess)
      129. {
      130. break;
      131. }
      133. System.Threading.Thread.Sleep(500); // required to give the next tries a chance!
      134. }
      136. if (bSuccess)
      137. {
      138. Console.WriteLine("Success\n\n");
      139. }
      140. else
      141. {
      142. Console.WriteLine("failed\n");
      143. Console.WriteLine(string.Format("Result = {0}\n", res));
      145. if (VetoNameW[0] != '\0')
      146. {
      147. Console.WriteLine("VetoName = {0]", VetoNameW);
      148. }
      149. }
      151. return true;
      152. }
      154. private static int GetDrivesDevInstByDeviceNumber(int DeviceNumber, System.IO.DriveType driveType, string szDosDeviceName)
      155. {
      156. bool isFloppy = szDosDeviceName.Contains("\\Floppy"); // who knows a better way?
      157. Guid guid;
      158. // ReSharper disable once SwitchStatementMissingSomeCases
      159. switch (driveType)
      160. {
      161. case System.IO.DriveType.Removable:
      162. if (isFloppy)
      163. {
      164. guid = new Guid(0x53f56311, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
      165. }
      166. else
      167. {
      168. guid = new Guid(0x53f56307, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
      169. }
      170. break;
      171. case System.IO.DriveType.Fixed:
      172. guid = new Guid(0x53f56307, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
      173. break;
      174. case System.IO.DriveType.CDRom:
      175. guid = new Guid(0x53f56308, 0xb6bf, 0x11d0, 0x94, 0xf2, 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
      176. break;
      177. default:
      178. return 0;
      179. }
      181. // Get device interface info set handle for all devices attached to system
      182. HANDLE hDevInfo = NativeMethods.SetupDiGetClassDevs(ref guid, IntPtr.Zero, IntPtr.Zero, NativeMethods.DIGCF_PRESENT | NativeMethods.DIGCF_DEVICEINTERFACE);
      184. if (hDevInfo == NativeMethods.INVALID_HANDLE_VALUE)
      185. {
      186. return 0;
      187. }
      189. // Retrieve a context structure for a device interface of a device information set
      190. uint dwIndex = 0;
      191. bool res;
      193. // class
      194. NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA pspdidd = new NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA();
      195. // struct
      196. NativeMethods.SP_DEVICE_INTERFACE_DATA spdid = default(NativeMethods.SP_DEVICE_INTERFACE_DATA);
      197. // class
      198. NativeMethods.SP_DEVINFO_DATA spdd = new NativeMethods.SP_DEVINFO_DATA();
      199. spdid.cbSize = Marshal.SizeOf(spdid); // 28
      201. uint dwSize;
      203. while (true)
      204. {
      205. res = NativeMethods.SetupDiEnumDeviceInterfaces(hDevInfo, IntPtr.Zero, ref guid, dwIndex, ref spdid);
      206. if (!res)
      207. {
      208. break;
      209. }
      211. // check the buffer size
      212. dwSize = 0;
      213. res = NativeMethods.SetupDiGetDeviceInterfaceDetail(hDevInfo, ref spdid, IntPtr.Zero, 0, out dwSize, null);
      214. // dieser Rückgabewert wurde in der C-Vorlage einfach ignoriert.
      215. if (!res)
      216. {
      217. int error = Marshal.GetLastWin32Error();
      218. int error2 = 122; // steht im www
      219. if (Environment.Is64BitProcess)
      220. {
      221. // x64 error = 1008, in der C-Vorlage ausprobiert
      222. error2 = 1008;
      223. }
      225. // das muss so sein!
      226. if (error != error2)
      227. {
      228. Console.WriteLine("Error = {0}", error);
      229. }
      230. }
      232. if (dwSize != 0 && dwSize <= pspdidd.DevicePath.Length)
      233. {
      234. spdd.Clear();
      235. spdd.cbSize = Marshal.SizeOf(spdd);
      237. // Bestimmung der realen Größe der pspdidd-Instanz
      238. int objectSize = Program.GetObjectSize(pspdidd);
      240. // unmanaged Speicher bereitstellen
      241. IntPtr p1 = Marshal.AllocHGlobal(objectSize);
      243. // Länge der nativen Struktur reinschreiben, Werte aus der C-Vorlage übernommen
      244. if (Environment.Is64BitProcess)
      245. {
      246. Marshal.WriteInt32(p1, 8);
      247. }
      248. else
      249. {
      250. Marshal.WriteInt32(p1, 5);
      251. }
      253. res = NativeMethods.SetupDiGetDeviceInterfaceDetail(hDevInfo, ref spdid, p1, dwSize, out dwSize, spdd);
      255. if (!res)
      256. {
      257. int error = Marshal.GetLastWin32Error();
      258. Console.WriteLine("Error = {0}", error);
      260. // Speicher wieder freigeben
      261. Marshal.FreeHGlobal(p1);
      262. }
      263. else
      264. {
      265. // Index 4 geht irgendwie nicht richtig
      266. Marshal.Copy(p1, pspdidd.DevicePath, 0, pspdidd.DevicePath.Length - 4);
      267. // Speicher wieder freigeben
      268. Marshal.FreeHGlobal(p1);
      270. string fileName = pspdidd.GetFileName((int)dwSize);
      271. // Ausgabe des System-Pfades zur Kontrolle
      272. Console.WriteLine(fileName);
      274. // open the disk or cdrom or floppy
      275. HANDLE hDrive = NativeMethods.CreateFile(fileName, 0, System.IO.FileShare.Read | System.IO.FileShare.Write, IntPtr.Zero, System.IO.FileMode.Open, 0, IntPtr.Zero);
      276. if (hDrive != NativeMethods.INVALID_HANDLE_VALUE)
      277. {
      278. // get its device number
      279. NativeMethods.STORAGE_DEVICE_NUMBER sdn = default(NativeMethods.STORAGE_DEVICE_NUMBER);
      280. uint dwBytesReturned = 0;
      281. res = NativeMethods.DeviceIoControl(hDrive, NativeMethods.IOCTL_STORAGE_GET_DEVICE_NUMBER, IntPtr.Zero, 0, ref sdn, Marshal.SizeOf(sdn), ref dwBytesReturned, IntPtr.Zero);
      282. if (res)
      283. {
      284. if (DeviceNumber == sdn.DeviceNumber)
      285. {
      286. // match the given device number with the one of the current device
      287. NativeMethods.CloseHandle(hDrive);
      288. NativeMethods.SetupDiDestroyDeviceInfoList(hDevInfo);
      289. return spdd.DevInst;
      290. }
      291. }
      293. NativeMethods.CloseHandle(hDrive);
      294. }
      295. }
      296. }
      298. dwIndex++;
      299. }
      301. NativeMethods.SetupDiDestroyDeviceInfoList(hDevInfo);
      303. return 0;
      304. }
      306. /// <summary>
      307. /// Bestimmen der Größe der SP_DEVICE_INTERFACE_DETAIL_DATA-Instanz
      308. /// </summary>
      309. /// <param name="pspdidd">die Instant</param>
      310. /// <returns>deren Größe</returns>
      311. private static int GetObjectSize(NativeMethods.SP_DEVICE_INTERFACE_DETAIL_DATA pspdidd)
      312. {
      313. int objectSize;
      314. using (MemoryStream stream = new MemoryStream())
      315. {
      316. IFormatter formatter = new BinaryFormatter();
      317. formatter.Serialize(stream, pspdidd);
      318. objectSize = (int)stream.Position;
      319. }
      321. return objectSize;
      322. }
      323. }
      324. }
      NativeMethods.cs

      C#-Quellcode

      1. using System;
      2. using System.Runtime.InteropServices;
      3. using System.Text;
      5. namespace RemoveDriveByLetter
      6. {
      7. internal static class NativeMethods
      8. {
      9. #region Enum
      11. /// <summary>
      12. /// Enum für CM_Request_Device_Eject
      13. /// </summary>
      14. internal enum PNP_VETO_TYPE
      15. {
      16. PNP_VetoTypeUnknown, // Name is unspecified
      17. PNP_VetoLegacyDevice, // Name is an Instance Path
      18. PNP_VetoPendingClose, // Name is an Instance Path
      19. PNP_VetoWindowsApp, // Name is a Module
      20. PNP_VetoWindowsService, // Name is a Service
      21. PNP_VetoOutstandingOpen, // Name is an Instance Path
      22. PNP_VetoDevice, // Name is an Instance Path
      23. PNP_VetoDriver, // Name is a Driver Service Name
      24. PNP_VetoIllegalDeviceRequest, // Name is an Instance Path
      25. PNP_VetoInsufficientPower, // Name is unspecified
      26. PNP_VetoNonDisableable, // Name is an Instance Path
      27. PNP_VetoLegacyDriver, // Name is a Service
      28. PNP_VetoInsufficientRights // Name is unspecified
      29. }
      31. #endregion Enum
      33. #region Classes
      35. [Serializable]
      36. [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
      37. internal class SP_DEVICE_INTERFACE_DETAIL_DATA
      38. {
      39. /// <summary>Größe der Struktur</summary>
      40. public int cbSize;
      41. /// <summary>Speicher für den Pfad</summary>
      42. public byte[] DevicePath;
      44. public SP_DEVICE_INTERFACE_DETAIL_DATA()
      45. {
      46. this.DevicePath = new byte[1024];
      47. }
      49. /// <summary>
      50. /// Auslesen des File-Namens
      51. /// </summary>
      52. /// <param name="size">C-String-Länge inklusive '\0'</param>
      53. /// <returns>.NET-File-Name</returns>
      54. public string GetFileName(int size)
      55. {
      56. string fileName = System.Text.Encoding.UTF8.GetString(this.DevicePath, 4, size);
      57. // String am 0-Terminierer abschneiden
      58. fileName = fileName.Split(new[] { '\0' }, 2)[0];
      59. return fileName;
      60. }
      61. }
      63. [StructLayout(LayoutKind.Sequential)]
      64. internal class SP_DEVINFO_DATA
      65. {
      66. public int cbSize;
      67. public Guid ClassGuid;
      68. public int DevInst; // DEVINST handle
      69. public IntPtr Reserved;
      71. public void Clear()
      72. {
      73. this.cbSize = 0;
      74. this.ClassGuid = Guid.Empty;
      75. this.DevInst = 0;
      76. this.Reserved = IntPtr.Zero;
      77. }
      78. }
      80. #endregion Classes
      82. #region Structs
      84. [StructLayout(LayoutKind.Sequential)]
      85. internal struct SP_DEVICE_INTERFACE_DATA
      86. {
      87. public int cbSize;
      88. public Guid InterfaceClassGuid;
      89. public uint Flags;
      90. public IntPtr Reserved;
      91. }
      93. [StructLayout(LayoutKind.Sequential)]
      94. internal struct STORAGE_DEVICE_NUMBER
      95. {
      96. /// <summary>The FILE_DEVICE_XXX type for this device.</summary>
      97. public int DeviceType;
      98. /// <summary>The number of this device</summary>
      99. public int DeviceNumber;
      100. /// <summary>
      101. /// If the device is partitionable, the partition number of the device.
      102. /// Otherwise -1
      103. /// </summary>
      104. public int PartitionNumber;
      105. }
      107. #endregion Structs
      109. #region Statics, Consts
      111. internal static IntPtr INVALID_HANDLE_VALUE = (IntPtr)(-1);
      113. internal const int MAX_PATH = 260;
      115. internal const int DIGCF_PRESENT = 0x02;
      116. internal const int DIGCF_DEVICEINTERFACE = 0x10;
      118. internal const uint METHOD_BUFFERED = 0;
      119. //internal const uint METHOD_IN_DIRECT = 1;
      120. //internal const uint METHOD_OUT_DIRECT = 2;
      121. //internal const uint METHOD_NEITHER = 3;
      123. private const int FILE_ANY_ACCESS = 0;
      124. //private const int FILE_READ_ACCESS = 1;
      125. //private const int FILE_WRITE_ACCESS = 2;
      126. //private const int OPEN_EXISTING = 3;
      128. // Device type in the "User Defined" range.
      129. private const uint IOCTL_STORAGE_BASE = 0x0000002d;
      131. #endregion Statics, Consts
      133. #region Kernel32.dll
      135. [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
      136. internal static extern IntPtr CreateFile(
      137. string fileName,
      138. uint fileAccess,
      139. [MarshalAs(UnmanagedType.U4)] System.IO.FileShare fileShare,
      140. IntPtr securityAttributes,
      141. [MarshalAs(UnmanagedType.U4)] System.IO.FileMode creationDisposition,
      142. int flags,
      143. IntPtr template);
      145. [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
      146. [return: MarshalAs(UnmanagedType.Bool)]
      147. internal static extern bool DeviceIoControl(
      148. IntPtr hDevice, // Microsoft.Win32.SafeHandles.SafeFileHandle hDevice,
      149. uint dwIoControlCode, // EIOControlCode IoControlCode,
      150. IntPtr InBuffer, // [MarshalAs(UnmanagedType.AsAny)] [In] object InBuffer,
      151. int nInBufferSize, // Size in Byte of Data in InBuffer
      152. //IntPtr OutBuffer, // [MarshalAs(UnmanagedType.AsAny)] [Out] object OutBuffer,
      153. [MarshalAs(UnmanagedType.Struct)] ref STORAGE_DEVICE_NUMBER lpSystemInfo,
      154. int nOutBufferSize, // Size in Byte of Data in OutBuffer
      155. ref uint nBytesReturned, // Number of Bytes pushed in OutBuffer (<= nOutBufferSize)
      156. IntPtr lpOverlapped); // [In] ref System.Threading.NativeOverlapped Overlapped
      158. [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
      159. [return: MarshalAs(UnmanagedType.Bool)]
      160. internal static extern bool QueryDosDevice(string lpDeviceName, StringBuilder lpTargetPath, int ucchMax);
      162. [DllImport("kernel32.dll", SetLastError = true)]
      163. [return: MarshalAs(UnmanagedType.Bool)]
      164. internal static extern bool CloseHandle(IntPtr hObject);
      166. #endregion Kernel32.dll
      168. #region SetupApi.dll
      170. [DllImport("setupapi.dll", SetLastError = true)]
      171. internal static extern IntPtr SetupDiGetClassDevs(ref Guid classGuid, IntPtr enumerator, IntPtr hwndParent, UInt32 flags);
      173. [DllImport("setupapi.dll", SetLastError = true)]
      174. [return: MarshalAs(UnmanagedType.Bool)]
      175. internal static extern bool SetupDiEnumDeviceInterfaces(IntPtr hDevInfo, IntPtr devInfo, ref Guid interfaceClassGuid, UInt32 memberIndex, ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData);
      177. [DllImport("setupapi.dll", SetLastError = true)]
      178. [return: MarshalAs(UnmanagedType.Bool)]
      179. internal static extern bool SetupDiGetDeviceInterfaceDetail(
      180. IntPtr hDevInfo,
      181. ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData,
      182. //SP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData,
      183. IntPtr deviceInterfaceDetailData,
      184. uint deviceInterfaceDetailDataSize,
      185. out uint requiredSize,
      186. SP_DEVINFO_DATA deviceInfoData);
      188. [DllImport("setupapi.dll", SetLastError = true)]
      189. [return: MarshalAs(UnmanagedType.Bool)]
      190. internal static extern bool SetupDiDestroyDeviceInfoList(IntPtr hDevInfo);
      192. [DllImport("setupapi.dll")]
      193. internal static extern uint CM_Get_Parent(out UInt32 pdnDevInst, int dnDevInst, int ulFlags);
      195. [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
      196. internal static extern uint CM_Request_Device_Eject(UInt32 devinst, out PNP_VETO_TYPE pVetoType, char[] pszVetoName, int ulNameLength, int ulFlags);
      198. #endregion SetupApi.dll
      200. #region Properties
      202. internal static uint IOCTL_STORAGE_GET_DEVICE_NUMBER
      203. {
      204. get { return NativeMethods.CTL_CODE(NativeMethods.IOCTL_STORAGE_BASE, 0x0420, NativeMethods.METHOD_BUFFERED, NativeMethods.FILE_ANY_ACCESS); }
      205. }
      207. #endregion Properties
      209. #region Private Stuff
      211. /// <summary>
      212. /// from WinIoCtl.h
      213. /// Macro definition for defining IOCTL and FSCTL function control codes.
      214. /// Note that function codes 0-2047 are reserved for Microsoft Corporation,
      215. /// and 2048-4095 are reserved for customers.
      216. /// </summary>
      217. /// <returns>Control Code</returns>
      218. private static uint CTL_CODE(uint deviceType, uint function, uint method, uint access)
      219. {
      220. return (((deviceType) << 16) | ((access) << 14) | ((function) << 2) | (method));
      221. }
      223. #endregion Private Stuff
      224. }
      225. }
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „RodFromGermany“ () aus folgendem Grund: Ausgabe der Prozessbreite (x64 / x86)

      Unter Win7-32 als auch Win7-64 läuft das ganze mit AnyCPU.
      ====
      Einen kleinen Effekt gibt es beim Win7-32, das läuft als VM unter Ubuntu.
      Das Windows weiß danach zwar nix mehr von dem entfernten Laufwerk, allerdings wird es im Ubuntu-Menü Geräte=>USB immer noch mit einem Haken als aktiv angezeigt.
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

    Facebook
    Telefonspende