Loop holes around PInvoke

Introduction

In working with PInvoke, I found it utterly tedious having to write those structures as arguments to pass into the function calls. Particularly, since I myself am not a Win32 developer. I decided to start an article focused on some shortcuts (good or bad) one can use to speed up the whole process. Here are just some things to make the job a little easier (if you didn't already know). This article is intended to serve as a journal of findings and as such will remain a living document. If there are any quick tricks you know as a reader, please inform me so I can update it. :-)

Opening files/devices/etc

In Win32, the CreateFile function is used as a general access method to open files, named pipes, directories, communication resources, physical disks, volumes, the console buffer, tape drives, or mail slots. Here is the basic signature for the function:

HANDLE CreateFile(
  LPCTSTR filename,
  DWORD fileaccess,
  DWORD fileshare,
  LPSECURITY_ATTRIBUTES securityattributes,
  DWORD creationdisposition,
  DWORD flags,
  HANDLE template);

Most of the samples I have seen take the approach of creating constants to represent the various values associated with the parameters: fileaccess, fileshare, and creationdisposition. You can however use the FileAcces enum to represent fileaccess, the FileMode enum to represent creation-disposition and the FileShare enum to represent fileshare. You would simply have to manually marshal the enums as integers. Since enums in .NET represent integer type constants, this should not be a problem. Here is how the declaration of CreateFile would look:

[DllImport("Kernel32.dll")]

static extern IntPtr CreateFile(
                string filename,
                [MarshalAs(UnmanagedType.U4)]FileAccess fileaccess,
                [MarshalAs(UnmanagedType.U4)]FileShare fileshare,
                int securityattributes,
                [MarshalAs(UnmanagedType.U4)]FileMode creationdisposition,
                int flags,
                IntPtr template);

I use int for securityattributes to illustrate that (if you are not planning to use it, you can simple map it as an int and pass 0 rather than create the entire structure just to pass it in).

With the above function declared, you can call CreateFile from your code much easier:

IntPtr ptr= CreateFile("text.txt",FileAccess.ReadWrite,
    FileShare.ReadWrite,0,FileMode.Create,0, IntPtr.Zero);

The above code will return a handle that can be used to access the object.

If you specified "COM1" as the filename above (you would have to change some of the parameters), you would get back a handle to the COM port 1. Trying to do this with the File factory provided by .NET as follows:

FileStream fs = File.Create("COM1");

will not work. CreateFile however does not return a FileStream; rather you get back a Handle which you must the pass in subsequent calls to other IO functions like CreateFileMapping. In the case of serial communication, the standard practice is to use the read and write Win32 functions to read from and write to the port. Here is the definition for WriteFile.

BOOL WriteFile(
  HANDLE hfile,
  LPCVOID pointertobuffer,
  DWORD numberofbytestowrte,
  LPDWORD numberofbyteswritten,
  LPOVERLAPPED useoverlappedio
);

Fortunately, you do not have to do this. Although .NET does not allow you to directly open devices, (the example I showed above), it does let you create filestreams from Windows handles (yeah!), so you could access the stream associated with the device like this:

IntPtr ptr= CreateFile("COM1",
FileAccess.ReadWrite,
FileShare.ReadWrite,
0,
FileMode.Create,
0,
IntPtr.Zero //pointed out by Parrys

);
FileStream fs = new FileStream(ptr,FileAccess.ReadWrite);

Because the File class allows you to get an instance to a FileStream from the handle of a file, you can open a file using standard Win32 mechanism, use its handle to create a FileStream, and write to it using all the standard .NET mechanisms. It's not much to write home about when you're just working with files, but with some imagination you can achieve the equivalent of:

FileStream fs = File.Open("//./device",FileMode.open);

Something that is not yet implemented in .NET. Using this in tandem with DeviceIOControl can bring .NET pretty close to the AssemblyZone.

Multimedia

For quick access to cross platform multimedia functionality such as playing all waveform audio, capturing video & audio, etc., use the multimedia library winmm.dll. It gives very low level access to everything without having to redistribute DirectX. In fact, you can you the mciSendString() function and just send text based messages directly to the multimedia device drivers. Please see the article below for a more detailed description of this:

Using MCI to control multimedia.