pinvoke.net: Edit: kernel32.ReadFile

@msdn=http://search.microsoft.com/search/results.aspx?qu=$$$
@pinvoke=http://pinvoke.net/$$$.htm

Summary: The ReadFile API

!!!!C# Signature:

//1
 [DllImport("kernel32.dll", SetLastError = true)]
 static extern bool ReadFile(IntPtr hFile, [Out] byte[] lpBuffer,
   uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, IntPtr lpOverlapped);

//2
 [DllImport("kernel32.dll", SetLastError=true)]
 static extern unsafe int ReadFile(IntPtr handle, IntPtr bytes, uint numBytesToRead, 
  IntPtr numBytesRead, NativeOverlapped* overlapped);

//3
 [DllImport("kernel32.dll", SetLastError=true)]
 static extern bool ReadFile(IntPtr hFile, [Out] byte[] lpBuffer, uint nNumberOfBytesToRead, 
   out uint lpNumberOfBytesRead, [In] ref System.Threading.NativeOverlapped lpOverlapped);

//4
 [DllImport(@"kernel32.dll", SetLastError = true)]
 static extern unsafe bool ReadFile(
 	SafeFileHandle hFile,      // handle to file
 	byte* pBuffer,            // data buffer, should be fixed
 	int NumberOfBytesToRead,  // number of bytes to read
 	IntPtr pNumberOfBytesRead,  // number of bytes read, provide IntPtr.Zero here
 	NativeOverlapped *lpOverlapped // should be fixed, if not IntPtr.Zero
 );

!!!!VB Signature:
 <DllImport("kernel32.dll", SetlastError:=True)> _
  Private Shared Function ReadFile(ByVal hFile As IntPtr, ByVal Buffer As IntPtr, _
    ByVal nNumberOfBytesToRead As Integer, ByRef lpNumberOfBytesRead As Integer, _
    ByRef lpOverlapped As OVERLAPPED) As Integer
  End Function

<DllImport("kernel32.dll")> Friend Shared Function ReadFile( _
    ByVal File As SafeFileHandle, _
    ByVal Buffer As System.Text.StringBuilder, _
    ByVal NumberOfBytesToRead As Integer, _
    ByRef NumberOfBytesRead As Integer, _
    ByRef Overlapped As System.Threading.NativeOverlapped) As SafeFileHandle
 End Function

!!!!User-Defined Types:
None.

!!!!Notes:
The documentation states that if using unbuffered IO, the memory must be "storage aligned" (aligned to the sector size of the storage device).  Either this is not enforced, or managed allocations (specifically byte arrays) are automatically storage aligned because there seems to be no problem using it.  Note that storage aligned and page aligned are not the same, and managed allocations are not in general page aligned (required for ReadFileScatter).

For more information on unbuffered IO in .NET see:
http://arxiv.org/abs/cs.PF/0502012

!!!!Notes:
Regarding the above note, my experience shows that failing to provide a storage-aligned buffer causes ReadFile to perform all IO synchronously.  I.e. it always blocks until the operation is complete and never returns ERROR_IO_PENDING.

Warning! GetOverlappedResult writes to the address of the buffer specified in the ORIGINAL OPERATION (ie/ ReadFile or WriteFile). .NET may move the address of the buffer before GetOverlappedResult returns, resulting in a buffer overflow. Use AllocHGlobal and FreeHGlobal or otherwise ensure the buffer is pinned between the two calls. The same applies to the overlapped structure.

!!!!Tips & Tricks:
NET 2.0 use SafeFileHandle instead of IntPtr

Warning: using IntPtr to pass in a zero leaks memory. Use the NativeOverlapped versions and pass in a null.

!!!!Sample Code:
  Public Function Read() As stArcnetPacket
    Dim dwErrorCode As FarcConstants
    Dim erg As stArcnetPacket
    Dim dwBytesReceived As Int32
    Dim ip As IntPtr = Marshal.AllocHGlobal(Marshal.SizeOf(erg))
    If ReadFile(hDriver, ip, Marshal.SizeOf(erg), dwBytesReceived, Nothing) Then
      erg = Marshal.PtrToStructure(ip, erg.GetType)
      ReDim Preserve erg.Data(dwBytesReceived - 6)
      Marshal.FreeHGlobal(ip)
    Else
      dwErrorCode = Marshal.GetLastWin32Error
      Marshal.FreeHGlobal(ip)
      Throw New System.IO.IOException("Read fails. Errorcode: " & _
        dwErrorCode.ToString, New System.ComponentModel.Win32Exception(dwErrorCode))
    End If
    Return erg
  End Function

USED W/ SIGNATURE #4

// This is taken from the USBSharp.cs class
		public unsafe byte[] CT_ReadFile(int InputReportByteLength)
		{
			int BytesRead =0;
			byte[] BufBytes = new byte[InputReportByteLength];
			if (ReadFile(HidHandle, BufBytes, InputReportByteLength, ref BytesRead, null))
			{
				byte[] OutBytes = new byte[BytesRead];
				Array.Copy(BufBytes, OutBytes, BytesRead);
				return OutBytes;
			}
			else
			{
				return null;
			}
		}

!!!!Alternative Managed API:
System.IO.FileStream

!!!!See Also
WriteFile, WriteFileGather, ReadFileScatter

Documentation: ReadFile@msdn on MSDN