в 15:31, 26 мая 2010

2010-05-26T15:31:53Z

Admin: 1 версия

2010-05-26T12:20:18Z

1 версия

Новая страница

==Calling a Function with a Structure Parameter==

<source lang="csharp">// Code from
// A Programmer"s Introduction to C# 2.0, Third Edition
// copyright 2000 Eric Gunnerson
using System;
using System.Runtime.InteropServices;
struct Point
{
public int x;
public int y;

public override string ToString()
{
return(String.Format("({0}, {1})", x, y));
}
}
struct Rect
{
public int left;
public int top;
public int right;
public int bottom;

public override string ToString()
{
return(String.Format("({0}, {1})\n ({2}, {3})", left, top, right, bottom));
}
}
struct WindowPlacement
{
public uint length;
public uint flags;
public uint showCmd;
public Point minPosition;
public Point maxPosition;
public Rect normalPosition;

public override string ToString()
{
return(String.Format("min, max, normal:\n{0}\n{1}\n{2}",
minPosition, maxPosition, normalPosition));
}
}
class MainClass
{
[DllImport("user32")]
static extern IntPtr GetForegroundWindow();

[DllImport("user32")]
static extern bool GetWindowPlacement(IntPtr handle, ref WindowPlacement wp);

public static void Main()
{
IntPtr window = GetForegroundWindow();

WindowPlacement wp = new WindowPlacement();
wp.length = (uint) Marshal.SizeOf(wp);

bool result = GetWindowPlacement(window, ref wp);

if (result)
{
Console.WriteLine(wp);
}
}
}</source>
<pre class=codeResult>min, max, normal:
(-32000, -32000)
(-60, -8)
(-1, -1)
(1273, 728)</pre>

==Calling Native DLL Functions==

<source lang="csharp">using System;
using System.Runtime.InteropServices;
class Test
{
[DllImport("user32.dll")]
public static extern int MessageBox(IntPtr h, string m, string c, int type);
public static void Main()
{
int retval = MessageBox(IntPtr.Zero, "Hello", "Caption", 0);
}
}</source>

==Enumerate Display Monitors==

<source lang="csharp">/*
NET Development for Java Programmers
# By Paul Gibbons
# ISBN: 1-59059-038-4
# 432 pp.
# Published: Jul 2002
*/

using System;
using System.Runtime.InteropServices;
[ StructLayout( LayoutKind.Sequential ) ]
struct Rect
{
public int left;
public int top;
public int right;
public int bottom;
}
[ StructLayout( LayoutKind.Sequential ) ]
struct MonitorInfo
{
public uint size;
public Rect monitor;
public Rect work;
public uint flags;
}
class MainClass
{
delegate bool MonitorEnumDelegate( IntPtr hMonitor,IntPtr hdcMonitor,ref Rect lprcMonitor, IntPtr dwData );
[ DllImport( "user32.dll" ) ]
static extern bool EnumDisplayMonitors( IntPtr hdc, IntPtr lprcClip, MonitorEnumDelegate lpfnEnum, IntPtr dwData );
[ DllImport( "user32.dll" ) ]
static extern bool GetMonitorInfo( IntPtr hmon, ref MonitorInfo mi );
static bool MonitorEnum( IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData )
{
MonitorInfo mi = new MonitorInfo();
mi.size = (uint)Marshal.SizeOf( mi );
bool success = GetMonitorInfo( hMonitor, ref mi );
return true;
}
[STAThread]
static void Main(string[] args)
{
MonitorEnumDelegate med = new MonitorEnumDelegate( MonitorEnum );
EnumDisplayMonitors( IntPtr.Zero, IntPtr.Zero, med, IntPtr.Zero );
}
}</source>

==Get Computer name (char * parameter)==

<source lang="csharp">using System;
using System.Runtime.InteropServices;
class MainClass
{
[ DllImport( "kernel32.dll" ) ]
static extern unsafe bool GetComputerNameW( char* name, ref ulong size );
[STAThread]
static unsafe void Main(string[] args)
{
ulong size = 256;
char* name = stackalloc char[ (int)size ];
bool success = GetComputerNameW( name, ref size );
for ( uint i = 0; i < size; i++, name++ )
{
System.Console.Write( *name );
}
}
}</source>
<pre class=codeResult>nfex</pre>

==Get computer name (StringBuilder parameter)==

<source lang="csharp">using System;
using System.Runtime.InteropServices;
using System.Text;
class MainClass{
[ DllImport( "kernel32.dll" ) ]
static extern bool GetComputerName( StringBuilder name, ref ulong size );
[STAThread]
static void Main(string[] args)
{
ulong size = 256;
StringBuilder name = new StringBuilder( (int)size );
bool success = GetComputerName( name, ref size );
Console.WriteLine( name.ToString() );
}
}</source>
<pre class=codeResult>nfex</pre>

==Get current Active Window==

<source lang="csharp">using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Text;
public class MainClass
// Declare external functions.
[DllImport("user32.dll")]
private static extern IntPtr GetForegroundWindow();
[DllImport("user32.dll")]
private static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
public static void Main() {
int chars = 256;
StringBuilder buff = new StringBuilder(chars);
// Obtain the handle of the active window.
IntPtr handle = GetForegroundWindow();
// Update the controls.
if (GetWindowText(handle, buff, chars) > 0)
{
Console.WriteLine(buff.ToString());
Console.WriteLine(handle.ToString());
}
}
}</source>

==Get free disk space==

<source lang="csharp">using System;
using System.IO;
using System.Reflection;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

public class MainClass
{
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
static extern bool GetDiskFreeSpaceEx(string lpDirectoryName,
out ulong lpFreeBytesAvailable,
out ulong lpTotalNumberOfBytes,
out ulong lpTotalNumberOfFreeBytes);
public static void Main()
{
ulong freeBytesAvail;
ulong totalNumOfBytes;
ulong totalNumOfFreeBytes;
if (!GetDiskFreeSpaceEx("C:\\", out freeBytesAvail, out totalNumOfBytes, out totalNumOfFreeBytes))
{
Console.Error.WriteLine("Error occurred: {0}",
Marshal.GetExceptionForHR(Marshal.GetLastWin32Error()).Message);
}
else
{
Console.WriteLine("Free disk space:");
Console.WriteLine(" Available bytes : {0}", freeBytesAvail);
Console.WriteLine(" Total # of bytes: {0}", totalNumOfBytes);
Console.WriteLine(" Total free bytes: {0}", totalNumOfFreeBytes);
}
}
}</source>
<pre class=codeResult>Free disk space:
Available bytes : 33091416064
Total # of bytes: 60003381248
Total free bytes: 33091416064</pre>

==Get Monitor Information==

<source lang="csharp">/*
Revised from
NET Development for Java Programmers
*/
using System;
using System.Runtime.InteropServices;
[ StructLayout( LayoutKind.Explicit ) ]
struct Point
{
[ FieldOffset( 0 ) ]
public int x;
[ FieldOffset( 4 ) ]
public int y;
}
[ StructLayout( LayoutKind.Sequential ) ]
struct Rect
{
public int left;
public int top;
public int right;
public int bottom;
}
[ StructLayout( LayoutKind.Sequential ) ]
struct MonitorInfo
{
public uint size;
public Rect monitor;
public Rect work;
public uint flags;
}
class MainClass
{
[ DllImport( "user32.dll" ) ]
static extern IntPtr MonitorFromPoint( Point p, uint flags );
[ DllImport( "user32.dll" ) ]
static extern bool GetMonitorInfo( IntPtr hmon, ref MonitorInfo mi );
[STAThread]
static void Main(string[] args)
{
Point p = new Point();
p.x = 1;
p.y = 1;
IntPtr hmon = MonitorFromPoint( p, 1 );
MonitorInfo mi = new MonitorInfo();
mi.size = (uint)Marshal.SizeOf( mi );
bool success = GetMonitorInfo( hmon, ref mi );
Console.WriteLine(mi.size);
Console.WriteLine(mi.monitor);

}
}</source>
<pre class=codeResult>40
Rect</pre>

==GetVersionEx by using kernel32.dll==

<source lang="csharp">using System;
using System.Runtime.InteropServices;
[StructLayout(LayoutKind.Sequential)]
public class OSVersionInfo
{
public int dwOSVersionInfoSize;
public int dwMajorVersion;
public int dwMinorVersion;
public int dwBuildNumber;
public int dwPlatformId;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public String szCSDVersion;
}

class MainClass
{
[DllImport("kernel32.dll")]
public static extern bool GetVersionEx([In, Out] OSVersionInfo osvi);
static void Main(string[] args)
{
OSVersionInfo osvi = new OSVersionInfo();
osvi.dwOSVersionInfoSize = Marshal.SizeOf(osvi);
GetVersionEx(osvi);
Console.WriteLine("Class size: " + osvi.dwOSVersionInfoSize);
Console.WriteLine("Major Version: " + osvi.dwMajorVersion);
Console.WriteLine("Minor Version: " + osvi.dwMinorVersion);
Console.WriteLine("Build Number: " + osvi.dwBuildNumber);
Console.WriteLine("Platform Id: " + osvi.dwPlatformId);
Console.WriteLine("CSD Version: " + osvi.szCSDVersion);
Console.WriteLine("Platform: " + Environment.OSVersion.Platform);
Console.WriteLine("Version: " + Environment.OSVersion.Version);
}
}</source>
<pre class=codeResult>Class size: 148
Major Version: 5
Minor Version: 1
Build Number: 2600
Platform Id: 2
CSD Version: Service Pack 2
Platform: Win32NT
Version: 5.1.2600.131072</pre>

==Get Workstation information==

<source lang="csharp">/*
NET Development for Java Programmers
# By Paul Gibbons
# ISBN: 1-59059-038-4
# 432 pp.
# Published: Jul 2002
*/
using System;
using System.Runtime.InteropServices;
using System.Text;
class NWGetInfo
{
[ StructLayout( LayoutKind.Sequential ) ]
struct WkstaInfo102
{
public uint platform_id;
public IntPtr computername;
public IntPtr langroup;
public uint ver_major;
public uint ver_minor;
public IntPtr lanroot;
public uint logged_on_users;
}
[ DllImport( "Netapi32.dll" ) ]
static extern unsafe int NetWkstaGetInfo( IntPtr servername, int level, byte** bufptr );
[ DllImport( "Netapi32.dll" ) ]
static extern unsafe int NetApiBufferFree( byte* bufptr );
[STAThread]
static unsafe void Main(string[] args)
{
byte* bp = null;
int rc = NetWkstaGetInfo( IntPtr.Zero, 102, &bp );
WkstaInfo102* wip = (WkstaInfo102*)bp;
Console.WriteLine( "System {0} has {1} users logged on", Marshal.PtrToStringAuto( wip->computername ), wip->logged_on_users );
rc = NetApiBufferFree( bp );
}
}</source>
<pre class=codeResult>System nfex has 3 users logged on</pre>

==Lock work station==

<source lang="csharp">using System;
using System.Collections;
using System.Data;
using System.Runtime.InteropServices;
public class MainClass {
[ DllImport( "user32.dll" ) ]
private static extern bool LockWorkStation();

[STAThread]
static void Main()
{
LockWorkStation();
}
}</source>

==Reading INI file: Get Private Profile String==

<source lang="csharp">using System;
using System.Runtime.InteropServices;
using System.Text;
class MainClass
{
// Declare the unmanaged functions.
[DllImport("kernel32.dll", EntryPoint = "GetPrivateProfileString")]
private static extern int GetPrivateProfileString(string lpAppName, string lpKeyName, string lpDefault, StringBuilder lpReturnedString, int nSize, string lpFileName);

static void Main(string[] args)
{
string section = "SampleSection"
string key = "Key1";
string filename = "\\initest.ini";
int chars = 256;
StringBuilder buffer = new StringBuilder(chars);
string sDefault = "";
if (GetPrivateProfileString(section, key, sDefault, buffer, chars, filename) != 0)
{
Console.WriteLine("Value of Key1 in [SampleSection] is: " + buffer.ToString());
}
else
{
Console.WriteLine("Value of Key1 in [SampleSection] is: " + null);
}
}
}</source>

==The windows version information==

<source lang="csharp">// Code from
// A Programmer"s Introduction to C# 2.0, Third Edition
// copyright 2000 Eric Gunnerson
using System;
using System.Runtime.InteropServices;
unsafe struct OSVERSIONINFO
{
public uint dwOSVersionInfoSize;
public uint dwMajorVersion;
public uint dwMinorVersion;
public uint dwBuildNumber;
public uint dwPlatformId;
public fixed char szCSDVersion[128];
}
class Program{
[DllImport("Kernel32.dll", CharSet = CharSet.Unicode)]
static extern bool GetVersionEx(ref OSVERSIONINFO lpVersionInfo);
unsafe static void Main(string[] args)
{
OSVERSIONINFO versionInfo = new OSVERSIONINFO();
versionInfo.dwOSVersionInfoSize = (uint)sizeof(OSVERSIONINFO);
bool res = GetVersionEx(ref versionInfo);
Console.WriteLine(Marshal.PtrToStringUni(new IntPtr(versionInfo.szCSDVersion)));
}
}</source>
<pre class=codeResult>S</pre>

==Use native windows function to read file==

<source lang="csharp">// Code from
// A Programmer"s Introduction to C# 2.0, Third Edition
// copyright 2000 Eric Gunnerson

using System;
using System.Runtime.InteropServices;
using System.Text;
class FileRead
{
const uint GENERIC_READ = 0x80000000;
const uint OPEN_EXISTING = 3;
IntPtr handle;

public FileRead(string filename)
{
// opens the existing file
handle = CreateFile( filename,
GENERIC_READ,
0,
0,
OPEN_EXISTING,
0,
0);
}

[DllImport("kernel32", SetLastError=true)]
static extern IntPtr CreateFile(
string filename,
uint desiredAccess,
uint shareMode,
uint attributes, // really SecurityAttributes pointer
uint creationDisposition,
uint flagsAndAttributes,
uint templateFile);

[DllImport("kernel32", SetLastError=true)]
static extern unsafe bool ReadFile(
IntPtr hFile,
void* lpBuffer,
int nBytesToRead,
int* nBytesRead,
int overlapped);

public unsafe int Read(byte[] buffer, int count)
{
int n = 0;
fixed (byte* p = buffer)
{
ReadFile(handle, p, count, &n, 0);
}
return n;
}
}
class Test
{
public static void Main(string[] args)
{
FileRead fr = new FileRead("test.cs");

byte[] buffer = new byte[128];
ASCIIEncoding e = new ASCIIEncoding();

// loop through, read until done
Console.WriteLine("Contents");
while (fr.Read(buffer, 128) != 0)
{
Console.Write("{0}", e.GetString(buffer));
}
}
}</source>
<pre class=codeResult>Contents</pre>

==Writing INI file: Write Private Profile String==

<source lang="csharp">using System;
using System.Runtime.InteropServices;
using System.Text;
class MainClass
{
[DllImport("kernel32.dll", EntryPoint = "WritePrivateProfileString")]
private static extern bool WritePrivateProfileString(string lpAppName, string lpKeyName, string lpString, string lpFileName);
static void Main(string[] args)
{
// Write a new value.
WritePrivateProfileString("MySection", "MyKey", "New Value", "\\initest.ini");
}
}</source>

← Предыдущая	Версия 15:31, 26 мая 2010
(нет различий)

Csharp/CSharp Tutorial/Windows/Native Windows Function - История изменений

в 15:31, 26 мая 2010

Admin: 1 версия