Type a page name and press Enter. You'll jump to the page if it exists, or you can create it if it doesn't.
To create a page in a module other than kernel32, prefix the name with the module name and a period.
<System.Runtime.InteropServices.DllImport("kernel32.dll", SetLastError:=True, CharSet:=System.Runtime.InteropServices.CharSet.Auto)> _
Friend Function CreateFile(ByVal lpFileName As String, _
ByVal dwDesiredAccess As EFileAccess, _
ByVal dwShareMode As EFileShare, _
ByVal lpSecurityAttributes As IntPtr, _
ByVal dwCreationDisposition As ECreationDisposition, _
ByVal dwFlagsAndAttributes As EFileAttributes, _
ByVal hTemplateFile As IntPtr) As Microsoft.Win32.SafeHandles.SafeFileHandle
End Function
# Define Values for the fields
$CreateFileFieldValueArray = [Object[]] @(
"CreateFile",
$True,
$True,
[System.Runtime.InteropServices.CallingConvention]::Winapi,
[System.Runtime.InteropServices.CharSet]::Auto
)
# Create a Custom Attribute and add to our Method
$CreateFileCustomAttribute = New-Object System.Reflection.Emit.CustomAttributeBuilder(
$CreateFileDllImport,
@("kernel32.dll"),
$CreateFileFieldArray,
$CreateFileFieldValueArray
)
$CreateFileMethod.SetCustomAttribute($CreateFileCustomAttribute)
Sample Code:
# Create the Type within our Module
$Kernel32 = $TypeBuilder.CreateType()
# Use the Method
$Kernel32::CreateFile(\\.\PHYSICALDRIVE0, [System.IO.FileAccess]::Read, [System.IO.FileShare]::Read, [System.IntPtr]::Zero, [System.IO.FileMode]::Open, [System.UInt32]0x02000000 )
/// <summary>
/// A managed version of Memory mapped file
/// By SHG at mail@Toolsbox.dk
/// </summary>
public class CMemoryMappedFile : IDisposable
{
IntPtr _hMMF = IntPtr.Zero;
FileStream _fs;
public uint _AllocationGranularity;
BinaryFormatter _Formatter = new BinaryFormatter();
/// <summary>
/// Creates a FileMapping handel
/// </summary>
/// <param name="FileName"></param>
/// <param name="Name"></param>
public CMemoryMappedFile(string FileName, string Name)
hMVF = Win32API.MapViewOfFile(_hMMF, Win32API.FileMapAccess.FileMapRead, FileMapStart, (Int32)MapViewSize);
if (hMVF == IntPtr.Zero)
throw new Win32Exception();
byte* p = (byte*)hMVF.ToPointer() + iViewDelta;
UnmanagedMemoryStream ums = new UnmanagedMemoryStream(p, MapViewSize, MapViewSize, FileAccess.Read);
byte[] ba = new byte[BytesToRead];
return ums.Read(Buffer, 0, BytesToRead);
}
finally
{
if (hMVF != IntPtr.Zero)
Win32API.UnmapViewOfFile(hMVF);
}
FILE_GENERIC_EXECUTE =
StandardRightsExecute |
FILE_READ_ATTRIBUTES |
FILE_EXECUTE |
Synchronize
}
/// <summary>
/// returns the streamed size of an object
/// </summary>
/// <param name="T"></param>
/// <returns></returns>
public long Size(Object T)
{
MemoryStream ms = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, T);
return ms.Length;
}
[Flags]
public enum EFileShare : uint
{
/// <summary>
///
/// </summary>
None = 0x00000000,
/// <summary>
/// Enables subsequent open operations on an object to request read access.
/// Otherwise, other processes cannot open the object if they request read access.
/// If this flag is not specified, but the object has been opened for read access, the function fails.
/// </summary>
Read = 0x00000001,
/// <summary>
/// Enables subsequent open operations on an object to request write access.
/// Otherwise, other processes cannot open the object if they request write access.
/// If this flag is not specified, but the object has been opened for write access, the function fails.
/// </summary>
Write = 0x00000002,
/// <summary>
/// Enables subsequent open operations on an object to request delete access.
/// Otherwise, other processes cannot open the object if they request delete access.
/// If this flag is not specified, but the object has been opened for delete access, the function fails.
/// </summary>
Delete = 0x00000004
}
public void Dispose()
{
if (_hMMF != IntPtr.Zero)
Win32API.CloseHandle(_hMMF);
_hMMF = IntPtr.Zero;
if (_fs != null)
_fs.Close();
}
}
internal sealed class Win32API
{
[DllImport("Kernel32", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr CreateFileMapping(IntPtr hFile, IntPtr lpAttributes, FileMapProtection flProtect, Int32 dwMaxSizeHi, Int32 dwMaxSizeLow, string lpName);
internal static IntPtr CreateFileMapping(System.IO.FileStream File, FileMapProtection flProtect, Int64 ddMaxSize, string lpName)
{
int Hi = (Int32)(ddMaxSize / Int32.MaxValue);
int Lo = (Int32)(ddMaxSize % Int32.MaxValue);
return CreateFileMapping(File.SafeFileHandle.DangerousGetHandle(), IntPtr.Zero, flProtect, Hi, Lo, lpName);
}
public enum ECreationDisposition : uint
{
/// <summary>
/// Creates a new file. The function fails if a specified file exists.
/// </summary>
New = 1,
/// <summary>
/// Creates a new file, always.
/// If a file exists, the function overwrites the file, clears the existing attributes, combines the specified file attributes,
/// and flags with FILE_ATTRIBUTE_ARCHIVE, but does not set the security descriptor that the SECURITY_ATTRIBUTES structure specifies.
/// </summary>
CreateAlways = 2,
/// <summary>
/// Opens a file. The function fails if the file does not exist.
/// </summary>
OpenExisting = 3,
/// <summary>
/// Opens a file, always.
/// If a file does not exist, the function creates a file as if dwCreationDisposition is CREATE_NEW.
/// </summary>
OpenAlways = 4,
/// <summary>
/// Opens a file and truncates it so that its size is 0 (zero) bytes. The function fails if the file does not exist.
/// The calling process must open the file with the GENERIC_WRITE access right.
/// </summary>
TruncateExisting = 5
}
[StructLayout(LayoutKind.Sequential)]
internal struct SYSTEM_INFO
{
internal _PROCESSOR_INFO_UNION uProcessorInfo;
public uint dwPageSize;
public IntPtr lpMinimumApplicationAddress;
public IntPtr lpMaximumApplicationAddress;
public IntPtr dwActiveProcessorMask;
public uint dwNumberOfProcessors;
public uint dwProcessorType;
public uint dwAllocationGranularity;
public ushort dwProcessorLevel;
public ushort dwProcessorRevision;
}
''
'' MaximumAllowed access type
''
Friend Enum ECreationDisposition
''' <summary>
''' Creates a new file, only if it does not already exist.
''' If the specified file exists, the function fails and the last-error code is set to ERROR_FILE_EXISTS (80).
''' If the specified file does not exist and is a valid path to a writable location, a new file is created.
''' </summary>
CREATE_NEW = 1
''' <summary>
''' Creates a new file, always.
''' If the specified file exists and is writable, the function overwrites the file, the function succeeds, and last-error code is set to ERROR_ALREADY_EXISTS (183).
''' If the specified file does not exist and is a valid path, a new file is created, the function succeeds, and the last-error code is set to zero.
''' For more information, see the Remarks section of this topic.
''' </summary>
CREATE_ALWAYS = 2
''' <summary>
''' Opens a file or device, only if it exists.
''' If the specified file or device does not exist, the function fails and the last-error code is set to ERROR_FILE_NOT_FOUND (2).
''' For more information about devices, see the Remarks section.
''' </summary>
OPEN_EXISTING = 3
''' <summary>
''' Opens a file, always.
''' If the specified file exists, the function succeeds and the last-error code is set to ERROR_ALREADY_EXISTS (183).
''' If the specified file does not exist and is a valid path to a writable location, the function creates a file and the last-error code is set to zero.
''' </summary>
OPEN_ALWAYS = 4
''' <summary>
''' Opens a file and truncates it so that its size is zero bytes, only if it exists.
''' If the specified file does not exist, the function fails and the last-error code is set to ERROR_FILE_NOT_FOUND (2).
''' The calling process must open the file with the GENERIC_WRITE bit set as part of the dwDesiredAccess parameter.
''' </summary>
TRUNCATE_EXISTING = 5
End Enum
You can use the IntPtr from Createfile with FileStream. This is usefull for opening devices such as Com1:, Lpt1: and Prn.
Unlike the FileStream ctor, CreateFile also allows you to open or create Windows 2000 sub-streams (e.g. "C:\Temp.dat:SubStream1").
For example:
IntPtr ptr = CreateFile(filename,access, share,0, mode,0, IntPtr.Zero);
/* Is bad handle? INVALID_HANDLE_VALUE */
if (ptr.ToInt32() == -1)
{
/* ask the framework to marshall the win32 error code to an exception */
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
else
{
return new FileStream(ptr,access);
}
Microsoft .NET Framework 2.0 Changes
If you are using version 2.0 of the .NET framework, you will need to make a few changes because of obsolete methods in the release for OpenFile. You can no longer try the good old
Now you can use the normal .NET enums that people are familiar with
Thought I post a sample code to help out anyone else who may need help : )
/// Sample code provided as is.
/// Sample Composed by Wijaya "Wi" T
/// References:
/// http://www.dotnettalk.net/Needed_help_on_printing_from_C_and_printer-6941579-1297-a.html
/// http://www.dotnet247.com/247reference/msgs/16/84730.aspx
/// http://www.groupsrv.com/dotnet/viewtopic.php?t=72572
/// http://www.pinvoke.net/default.aspx/kernel32.CreateFile
/// Usage:
/// Initialize this class in your main code (see below),
/// and walla you are now printing!
///
/// e.g.:
/// PrintFactory objPrintFactory = new PrintFactory();
/// Thank you:
/// Thank you all who have been contributing to printing to LPT port.
/// God Bless you! : )
/// Addt'l info:
/// Don't forget to reference:
/// using System.Runtime.InteropServices;
/// using System.IO;
///
public class PrintFactory
{
public const short FILE_ATTRIBUTE_NORMAL = 0x80;
public const short INVALID_HANDLE_VALUE = -1;
public const uint GENERIC_READ = 0x80000000;
public const uint GENERIC_WRITE = 0x40000000;
public const uint CREATE_NEW = 1;
public const uint CREATE_ALWAYS = 2;
public const uint OPEN_EXISTING = 3;
/* Is bad handle? INVALID_HANDLE_VALUE */
if (ptr.ToInt32() == -1)
{
/* ask the framework to marshall the win32 error code to an exception */
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
else
{
String Temp = "This is a test print";
//This is the cut command on Star TSP 600 Printer
char[] prnCmdCut = {(char)27, (char)100, (char)51};
FileStream lpt = new FileStream(ptr,FileAccess.ReadWrite);
Byte[] Buff = new Byte[1024];
//Check to see if your printer support ASCII encoding or Unicode.
//If unicode is supported, use the following:
//Buff = System.Text.Encoding.Unicode.GetBytes(Temp);
Buff = System.Text.Encoding.ASCII.GetBytes(Temp);
lpt.Write(Buff,0,Buff.Length);
Buff = System.Text.Encoding.ASCII.GetBytes(prnCmdCut);
lpt.Write(Buff,0,Buff.Length);
lpt.Close();
}
}
}
Sample Code with C#:
This code writes to disk as a file. Tested on USB flash drives as zerofill utility.
/* Sample Code provided by MertG */
/* References: */
/* This page,
http://stackoverflow.com/questions/4288031/createfile-in-kernel32-dll-does-not-allow-me-to-open-a-physical-disk */
//Using directives needed:
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
//function to read
private static byte[] ReadDrive( string FileName, int sizeToRead ) {
if ( (sizeToRead < 1) || (sizeToRead == null) ) throw new System.ArgumentException("Size parameter cannot be null or 0 or less than 0!");
SafeFileHandle drive = CreateFile( fileName: FileName,
fileAccess: FileAccess.Read,
fileShare: FileShare.Write | FileShare.Read | FileShare.Delete,
securityAttributes: IntPtr.Zero,
creationDisposition: FileMode.Open,
flags: 4, //with this also an enum can be used. (as described above as EFileAttributes)
template: IntPtr.Zero );
if (drive.IsInvalid) {
throw new IOException( "Unable to access drive. Win32 Error Code " + Marshal.GetLastWin32Error() );
//if get windows error code 5 this means access denied. You must try to run the program as admin privileges.
}
Where is the secutityAttributes?! It's not to uncommon to want a file handle to be inheritable (e.g. you want to pass a handle to a server component like something running as a "servicedComponent" or a service...) and by using the securityAttributes this can be done...
***********
Note that on win98, mapping the parameters to FileAccess and FileShare will cause CreateFileA to fail. I found this out the hard way, banging my head against a very slow win98 machine across an even slow connection. https://pinvoke.net/emoticons/sad_smile.gif Instead use the EFileAccess, and EFileShare enumeration constants that match the windows constants ( as mentioned earlier in the article ).
The CreateFileMapping function creates or opens a named or unnamed file mapping object for the specified file.
3/29/2013 4:27:04 PM - -211.5.143.129
An IntPtr is a pointer to a memory location (unmanaged) that adapts to the platform it is running on (64-bit, etc.) UNLIKE a standard int/Integer. You should always use this type for unmanaged calls that require it, even though an int will appear to work on your development machine.
1/13/2008 4:00:13 AM - Damon Carr-72.43.165.29
TODO - a short description
3/16/2007 7:52:17 AM - anonymous
TODO - a short description
3/16/2007 7:52:17 AM - anonymous
Click to read this page
12/2/2010 4:36:50 PM - -81.247.25.174
An IntPtr is a pointer to a memory location (unmanaged) that adapts to the platform it is running on (64-bit, etc.) UNLIKE a standard int/Integer. You should always use this type for unmanaged calls that require it, even though an int will appear to work on your development machine.
1/13/2008 4:00:13 AM - Damon Carr-72.43.165.29
Click to read this page
12/2/2010 4:36:50 PM - -81.247.25.174
Please edit this page!
Do you have...
helpful tips or sample code to share for using this API in managed code?
corrections to the existing content?
variations of the signature you want to share?
additional languages you want to include?
Select "Edit This Page" on the right hand toolbar and edit it! Or add new pages containing supporting types needed for this API (structures, delegates, and more).
kernel32
Revisions