' HandleRef.vb

Imports System
Imports System.IO
Imports System.Text
Imports System.Runtime.InteropServices
Imports System.Security.Permissions

'typedef struct _OVERLAPPED { 
'    ULONG_PTR  Internal; 
'    ULONG_PTR  InternalHigh; 
'    DWORD  Offset; 
'    DWORD  OffsetHigh; 
'    HANDLE hEvent; 
'} OVERLAPPED; 

' declared as structure
<StructLayout(LayoutKind.Sequential)> _
Public Structure Overlapped
    Private intrnal As IntPtr
    Private internalHigh As IntPtr
    Private offset As Integer
    Private offsetHigh As Integer
    Private hEvent As IntPtr
End Structure 'Overlapped

' declared as class
<StructLayout(LayoutKind.Sequential)> _
Public Class Overlapped2
    Private intrnal As IntPtr
    Private internalHigh As IntPtr
    Private offset As Integer
    Private offsetHigh As Integer
    Private hEvent As IntPtr
End Class 'Overlapped2


Public Class LibWrap

    ' to prevent FileStream to be GC-ed before call ends, 
    ' its handle should be wrapped in HandleRef

    ' BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
    '                LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);    

    Overloads Declare Unicode Function ReadFile Lib "Kernel32.dll" ( _
     ByVal hndRef As HandleRef, _
     ByVal buffer As StringBuilder, _
     ByVal numberOfBytesToRead As Integer, _
     ByRef numberOfBytesRead As Integer, _
     ByRef flag As Overlapped) _
    As Boolean

    ' since Overlapped is struct, Nothing can't be passed instead, 
    ' we must declare overload method if we will use this

    Overloads Declare Unicode Function ReadFile Lib "Kernel32.dll" ( _
     ByVal hndRef As HandleRef, _
     ByVal buffer As StringBuilder, _
     ByVal numberOfBytesToRead As Integer, _
     ByRef numberOfBytesRead As Integer, _
     ByVal flag As Integer) _
    As Boolean  ' int instead of structure reference

    ' since Overlapped2 is class, we can pass Nothing as parameter  
    ' no overload is needed        

    Declare Unicode Function ReadFile2 Lib "Kernel32.dll" Alias "ReadFile" ( _
     ByVal hndRef As HandleRef, _
     ByVal buffer As StringBuilder, _
     ByVal numberOfBytesToRead As Integer, _
     ByRef numberOfBytesRead As Integer, _
     <[In](), Out()> ByVal flag As Overlapped2) _
    As Boolean

End Class 'LibWrap

Public Class App
    Public Shared Sub Main()
    
    Run()
    
    End Sub 'Main

    <SecurityPermissionAttribute(SecurityAction.Demand, Flags:=SecurityPermissionFlag.UnmanagedCode)> _
    Public Shared Sub Run()


        Dim fs As New FileStream("HandleRef.txt", FileMode.Open)
        Dim hr As New HandleRef(fs, fs.SafeFileHandle.DangerousGetHandle())
        Dim buffer As New StringBuilder(5)
        Dim read As Integer = 0

        ' platform invoke will hold reference to HandleRef until call ends

        LibWrap.ReadFile(hr, buffer, 5, read, 0)
        Console.WriteLine("Read with struct parameter: {0}", buffer)
        LibWrap.ReadFile2(hr, buffer, 5, read, Nothing)
        Console.WriteLine("Read with class parameter: {0}", buffer)

    End Sub 'Run
End Class 'App

// HandleRef.cs

using System;
using System.IO;
using System.Text;
using System.Runtime.InteropServices;
using System.Security.Permissions;

/*
typedef struct _OVERLAPPED { 
    ULONG_PTR  Internal; 
    ULONG_PTR  InternalHigh; 
    DWORD  Offset; 
    DWORD  OffsetHigh; 
    HANDLE hEvent; 
} OVERLAPPED; 
*/

// declared as structure
[StructLayout(LayoutKind.Sequential)]
public struct Overlapped
{
    IntPtr intrnal;
    IntPtr internalHigh;
    int offset;
    int offsetHigh;
    IntPtr hEvent;
}

// declared as class
[StructLayout(LayoutKind.Sequential)]
public class Overlapped2
{
    IntPtr intrnal;
    IntPtr internalHigh;
    int offset;
    int offsetHigh;
    IntPtr hEvent;
}

public class LibWrap
{
    // to prevent FileStream to be GC-ed before call ends, 
    // its handle should be wrapped in HandleRef

    //BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
    //                LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);    

    [DllImport("Kernel32.dll", CharSet=CharSet.Unicode)]
    public static extern bool ReadFile(
        HandleRef hndRef,
        StringBuilder buffer,
        int numberOfBytesToRead,
        out int numberOfBytesRead,
        ref Overlapped flag);

    // since Overlapped is struct, null can't be passed instead, 
    // we must declare overload method if we will use this 

    [DllImport("Kernel32.dll", CharSet=CharSet.Unicode)]
    public static extern bool ReadFile(
        HandleRef hndRef,
        StringBuilder buffer,
        int numberOfBytesToRead,
        out int numberOfBytesRead,
        int flag);    // int instead of structure reference

    // since Overlapped2 is class, we can pass null as parameter,
    // no overload is needed    

    [DllImport("Kernel32.dll", CharSet=CharSet.Unicode, EntryPoint = "ReadFile")]
    public static extern bool ReadFile2(
        HandleRef hndRef,
        StringBuilder buffer,
        int numberOfBytesToRead,
        out int numberOfBytesRead,
        Overlapped2 flag);
}

public class App
{
    public static void Main()
    {
    Run();
    }

    [SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.UnmanagedCode)]
    public static void Run()
    {
        FileStream fs = new FileStream("HandleRef.txt", FileMode.Open);
        HandleRef hr = new HandleRef(fs, fs.SafeFileHandle.DangerousGetHandle());
        StringBuilder buffer = new StringBuilder(5);
        int read = 0;

        // platform invoke will hold reference to HandleRef until call ends

        LibWrap.ReadFile(hr, buffer, 5, out read, 0);
        Console.WriteLine("Read with struct parameter: {0}", buffer);
        LibWrap.ReadFile2(hr, buffer, 5, out read, null);
        Console.WriteLine("Read with class parameter: {0}", buffer);

    }
}

// HandleRef.cs
using namespace System::Runtime::InteropServices;
using namespace System;
using namespace System::IO;
using namespace System::Text;
using namespace System::Runtime::InteropServices;

/*
typedef struct _OVERLAPPED { 
ULONG_PTR  Internal; 
ULONG_PTR  InternalHigh; 
DWORD  Offset; 
DWORD  OffsetHigh; 
HANDLE hEvent; 
} OVERLAPPED; 
*/

// declared as structure
[StructLayout(LayoutKind::Sequential)]
public value struct Overlapped
{
private:
   IntPtr intrnal;
   IntPtr internalHigh;
   int offset;
   int offsetHigh;
   IntPtr hEvent;
};

// declared as class
[StructLayout(LayoutKind::Sequential)]
public ref class Overlapped2
{
private:
   IntPtr intrnal;
   IntPtr internalHigh;
   int offset;
   int offsetHigh;
   IntPtr hEvent;
};

public ref class LibWrap
{
public:
   // to prevent FileStream to be GC-ed before call ends, 
   // its handle should be wrapped in HandleRef
   //BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
   //    LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);    

   [DllImport("Kernel32.dll", CharSet=CharSet::Unicode)]
   static bool ReadFile( HandleRef hndRef, StringBuilder^ buffer, int numberOfBytesToRead, [Out]int * numberOfBytesRead, Overlapped ** flag );

   // since Overlapped is struct, null can't be passed instead, 
   // we must declare overload method if we will use this 

   [DllImport("Kernel32.dll", CharSet=CharSet::Unicode)]
   static bool ReadFile( HandleRef hndRef, StringBuilder^ buffer, int numberOfBytesToRead, [Out]int * numberOfBytesRead, int flag ); // int instead of structure reference

   // since Overlapped2 is class, we can pass null as parameter,
   // no overload is needed 
   [DllImport("Kernel32.dll", CharSet=CharSet::Unicode, EntryPoint="ReadFile")]
   static bool ReadFile2( HandleRef hndRef, StringBuilder^ buffer, int numberOfBytesToRead, [Out]int * numberOfBytesRead, Overlapped2^ flag );
};

int main()
{

   FileStream^ fs = gcnew FileStream( "HandleRef.txt", FileMode::Open );
   HandleRef hr = HandleRef(fs,fs->Handle);
   StringBuilder^ buffer = gcnew StringBuilder( 5 );
   int read = 0;

   // platform invoke will hold reference to HandleRef until call ends
   LibWrap::ReadFile( hr, buffer, 5,  &read, 0 );
   Console::WriteLine( "Read with struct parameter: {0}", buffer );


   LibWrap::ReadFile2( hr, buffer, 5,  &read, nullptr );
   Console::WriteLine( "Read with class parameter: {0}", buffer );
}