[C#] Direkt Zugriff auf Datenträger

Es gibt 2 Antworten in diesem Thema. Der letzte Beitrag () ist von AliveDevil.

    [C#] Direkt Zugriff auf Datenträger

    Hi,

    ich habe ein "kleines" Problem mit einer 1zu1 Kopie von einer DVD zu einem USB-Stick.
    Was ich konkret machen will:
    DVD byteweise auslesen und auf den USB-Stick kopieren.
    Ich habe es mit
    dieser API

    Quellcode

    1. using System;
    2. using System.Runtime.InteropServices;
    3. using System.IO;
    4. using Microsoft.Win32.SafeHandles;
    6. namespace ReadFromDevice
    7. {
    8. public class DeviceStream : Stream, IDisposable
    9. {
    10. public const short FILE_ATTRIBUTE_NORMAL = 0x80;
    11. public const short INVALID_HANDLE_VALUE = -1;
    12. public const uint GENERIC_READ = 0x80000000;
    13. public const uint GENERIC_WRITE = 0x40000000;
    14. public const uint CREATE_NEW = 1;
    15. public const uint CREATE_ALWAYS = 2;
    16. public const uint OPEN_EXISTING = 3;
    18. // Use interop to call the CreateFile function.
    19. // For more information about CreateFile,
    20. // see the unmanaged MSDN reference library.
    21. [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    22. private static extern IntPtr CreateFile(string lpFileName, uint dwDesiredAccess,
    23. uint dwShareMode, IntPtr lpSecurityAttributes, uint dwCreationDisposition,
    24. uint dwFlagsAndAttributes, IntPtr hTemplateFile);
    26. [DllImport("kernel32.dll", SetLastError = true)]
    27. private static extern bool ReadFile(
    28. IntPtr hFile, // handle to file
    29. byte[] lpBuffer, // data buffer
    30. int nNumberOfBytesToRead, // number of bytes to read
    31. ref int lpNumberOfBytesRead, // number of bytes read
    32. IntPtr lpOverlapped
    33. //
    34. // ref OVERLAPPED lpOverlapped // overlapped buffer
    35. );
    37. private SafeFileHandle handleValue = null;
    38. private FileStream _fs = null;
    40. public DeviceStream(string device)
    41. {
    42. Load(device);
    43. }
    45. private void Load(string Path)
    46. {
    47. if (string.IsNullOrEmpty(Path))
    48. {
    49. throw new ArgumentNullException("Path");
    50. }
    52. // Try to open the file.
    53. IntPtr ptr = CreateFile(Path, GENERIC_READ, 0, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
    55. handleValue = new SafeFileHandle(ptr, true);
    56. _fs = new FileStream(handleValue, FileAccess.Read);
    58. // If the handle is invalid,
    59. // get the last Win32 error
    60. // and throw a Win32Exception.
    61. if (handleValue.IsInvalid)
    62. {
    63. Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
    64. }
    65. }
    67. public override bool CanRead
    68. {
    69. get { return true; }
    70. }
    72. public override bool CanSeek
    73. {
    74. get { return false; }
    75. }
    77. public override bool CanWrite
    78. {
    79. get { return false; }
    80. }
    82. public override void Flush()
    83. {
    84. return;
    85. }
    87. public override long Length
    88. {
    89. get { return -1; }
    90. }
    92. public override long Position
    93. {
    94. get
    95. {
    96. throw new NotImplementedException();
    97. }
    98. set
    99. {
    100. throw new NotImplementedException();
    101. }
    102. }
    103. /// <summary>
    104. /// </summary>
    105. /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and
    106. /// (offset + count - 1) replaced by the bytes read from the current source. </param>
    107. /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream. </param>
    108. /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
    109. /// <returns></returns>
    110. public override int Read(byte[] buffer, int offset, int count)
    111. {
    112. int BytesRead = 0;
    113. var BufBytes = new byte[count];
    114. if (!ReadFile(handleValue.DangerousGetHandle(), BufBytes, count, ref BytesRead, IntPtr.Zero))
    115. {
    116. Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
    117. }
    118. for (int i = 0; i < BytesRead; i++)
    119. {
    120. buffer[offset + i] = BufBytes[i];
    121. }
    122. return BytesRead;
    123. }
    124. public override int ReadByte()
    125. {
    126. int BytesRead = 0;
    127. var lpBuffer = new byte[1];
    128. if (!ReadFile(
    129. handleValue.DangerousGetHandle(), // handle to file
    130. lpBuffer, // data buffer
    131. 1, // number of bytes to read
    132. ref BytesRead, // number of bytes read
    133. IntPtr.Zero
    134. ))
    135. { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); ;}
    136. return lpBuffer[0];
    137. }
    139. public override long Seek(long offset, SeekOrigin origin)
    140. {
    141. throw new NotImplementedException();
    142. }
    144. public override void SetLength(long value)
    145. {
    146. throw new NotImplementedException();
    147. }
    149. public override void Write(byte[] buffer, int offset, int count)
    150. {
    151. throw new NotImplementedException();
    152. }
    154. public override void Close()
    155. {
    156. handleValue.Close();
    157. handleValue.Dispose();
    158. handleValue = null;
    159. base.Close();
    160. }
    161. private bool disposed = false;
    163. new void Dispose()
    164. {
    165. Dispose(true);
    166. base.Dispose();
    167. GC.SuppressFinalize(this);
    168. }
    170. private new void Dispose(bool disposing)
    171. {
    172. // Check to see if Dispose has already been called.
    173. if (!this.disposed)
    174. {
    175. if (disposing)
    176. {
    177. if (handleValue != null)
    178. {
    179. _fs.Dispose();
    180. handleValue.Close();
    181. handleValue.Dispose();
    182. handleValue = null;
    183. }
    184. }
    185. // Note disposing has been done.
    186. disposed = true;
    188. }
    189. }
    191. }
    192. }

    versucht.
    das Problem dabei ist, dass ich

    Quellcode

    1. DeviceStream test = new DeviceStream(@"\\.\CdRom0");
    2. DeviceStream test = new DeviceStream(@"\\.\CdRom0\");

    über den ersten Code Zugriff drauf erhalte, aber ich nichts darauf machen kann.
    der zweite Code sollte eigentlich Zugriff auf das ganze Dateisystem geben, aber die einzige Fehlermeldung die ich bekomme ist

    Quellcode

    1. Ungültiges Handle.
    2. Parametername: handle

    Hoffe jemand kann mir helfen.

    und ja, ich möchte das CDFS auf dem Stick haben.