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.

Read more: Codeproject

Posted via email from Jasper-net