If you don’t know I have a new job in Bulgaria. I went away form Web Development and now I’m working as Winforms Developer. However, we had a client that exceed the number of window handles (more than 10 000) due to bad design of application. While diagnosing his application, we needed to understand how many handles are created and when they are born.

Reading MSDN I figure out that Windows API provide the availability to get all child handles for specified handle. We should use unmanaged EnumChildWindows function provided by user32.dll.

MSDN Definition

EnumChildWindows function enumerates the child windows that belong to the specified parent window by passing the handle to each child window, in turn, to an application-defined callback function. EnumChildWindows continues until the last child window is enumerated or the callback function returns FALSE.

Syntax

BOOL EnumChildWindows(
         HWND hWndParent,
         WNDENUMPROC lpEnumFunc,
         LPARAM lParam
);

hWndParent

          [in] Handle to the parent window whose child windows are to be enumerated.

lpEnumFunc

[in] Pointer to an application-defined callback function.

lParam

[in] Specifies an application-defined value to be passed to the callback function.

Note: If a child window has created child windows of its own, EnumChildWindows enumerates those windows as well.

How is used from .NET Framework

We are using DLLImport attribute to expose the method in .NET Environment. The specific point is that we create a handle to the list where are collected all pointers, due to availability to access it from the callback function where we know which is the child handle.

References

• MSDN

Sebbene il C# possa essere utilizzato in modalità nativa (unmanaged), viene ormai visto solo e unicamente come un linguaggio ad alto livello, è invece possibile utilizzarlo come ponte per il basso livello e la nostra applicazione. In questo modo, devo essere sincero, si dovranno gestire i problemi di entrambi i mondi, ma sarà possibile ottenere un controllo della macchina che è normalmente non possibile rimanendo nel dominio delle funzionalità managed.

Tutti sappiamo che il Framework .NET altro non è che un enorme conca di sabbia, dentro cui girano i nostri applicativi, del tutto ignari delle problematiche che un qualunque software dovrebbe gestire internamente, come l’allocazione della memoria e la richiesta e il rilascio delle risorse hardware. Abbiamo un applicativo che viene compilato in metaassembly CLR, e poi eseguito dalla macchina virtuale del .NET, particolarmente ottimizzata per le architetture moderne e non avente i vincoli che invece ha una JVM. Proprio perchè non esistono questi vincoli, .NET può chiamare funzioni esterne e allocare memoria sullo heap. In questo modo, può dialogare con il mondo esterno di Windows senza crearsi troppi problemi e estendendo le sue funzionalità anche a quelle non coperte dal Framework rilasciato da casa MS. L’inconveniente però è che il codice scritto in questa maniera viene marcato con i fuochi del P/INVOKE (Platform Invoke, ovvero tutto il dominio .NET che serve a invocare codice nativo per la piattaforma selezionata), e quindi non potremo ad esempio utilizzare la nostra applicazione in Mono.

L’argomento è esteso, quindi per oggi mi limiterò a trattare solo e unicamente quello che ho scritto nel titolo, ovvero l’invocazione di API C direttamente dal C#

Innanzitutto, per poter essere utilizzate in C#, le funzioni C devono essere scritte utilizzando lo standard di compilazione stdcall, come da standard Microsoft. Anche le API di Windows sono esposte utilizzando lo standard stdcall.

Ma prima un piccolo passo indietro. Quando a basso livello si parla di “richiamare una funzione”, semplicemente vengono fatte le seguenti operazioni:

1. Viene memorizzato l’indirizzo del prossimo opcode della funzione chiamate nello stack
2. Vengono memorizzati a uno a uno i parametri da passare alla funzione da chiamare nello stack
3. Viene effettuato il jump alla funzione da chiamare

Questa poi effettuerà le seguenti operazioni:

1. Leggerà gli argomenti dallo stack
2. Eseguirà le sue operazioni
3. Leggerà il punto delle istruzioni dove ritornare una volta terminato
4. Scriverà sullo stack il valore di ritorno
5. Effettuerà il jump sul punto di istruzioni letto (ovvero l’istruzione successiva al salto nella funzione chiamante)

Quando si parla di scrivere sullo stack, si usa l’istruzione assembly PUSH, quando si legge l’istruzione POP. Ricordo che lo stack è una pila, quindi un POP leggerà sempre l’ultimo valore immesso (e lo toglierà dalla pila), mentre un PUSH verrà sempre impilato sopra gli altri.

Questa divagazione è importante perchè nello standard di chiamata stdcall gli argomenti di una funzione vengono inseriti nello stack da destra verso sinistra (l’ultimo per primo) e i valori di ritorno, invece di essere inseriti nello stack, vengono tenuti nel registro EAX. Il chiamante è respostabile della pulitura dello stack.

(Per maggiori informazioni: http://en.wikipedia.org/wiki/X86_calling_conventions#stdcall)

Ipotizziamo di voler aprire un file utilizzando non File.Open(), ma una API di Win32. La API in questione è CreateFile e il prototipo è questo:

 

HANDLE WINAPI CreateFile(LPCTSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);

Non ci tratteniamo sul significato dei parametri, anche perchè su MSDN possiamo trovare la pagina di aiuto completa:

http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx

Adesso, per poterlo importare in C#, dobbiamo inanzitutto:

1. Conoscere il nome della DLL che contiene la funzione che ci interessa. La funzione deve essere esposta. Nel caso di CreateFile, la DLL è Kernel32.dll
2. Essere sicuri che il nome sia giusto. Ad esempio, nel caso di CreateFile, nella DLL esistono due funzioni, CreateFileA e CreateFileW, rispettivamente la versione ANSI e la versione UNICODE. Usando la chiamata in C, il compilatore si prende la briga di selezionare quella più giusta per il sistema su cui stiamo compilando il sorgente (per WinNTè UNICODE, come definito in windows.h). Nel caso nostro, o definiamo una flag per la selezione del charset, o dovremo scegliere quella più opportuna manualmente.
3. Essere sicuri che la DLL sia raggiungibile. La DLL deve essere o nel path dell'eseguibile, o nel path della macchina (ovvero anche nelle cartelle di sistema).
4. Creare una classe che contenga la definizione della funzione. La funzione deve essere dichiarata extern static.

Ecco quindi come diventerà CreateFile per noi, utilizzando la flag di charset per definire l'Unicode:

 

using System;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

public class TestCLinking
{
    [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    public static extern SafeFileHandle CreateFile(String lpFileName, UInt32 dwDesiredAccess, UInt32 dwShareMode, IntPtr pSecurityAttributes, UInt32 dwCreationDisposition, UInt32 dwFlagsAndAttributes, IntPtr hTemplateFile);
}

oppure, se vogliamo richiamare manualmente la versione ansi:

 

using System;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

public class TestCLinking
{
    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern SafeFileHandle CreateFileA(String lpFileName, UInt32 dwDesiredAccess, UInt32 dwShareMode, IntPtr pSecurityAttributes, UInt32 dwCreationDisposition, UInt32 dwFlagsAndAttributes, IntPtr hTemplateFile);
}

La struttura SafeFileHandle è un puntatore alla memoria appositamente wrappato dal .NET per l'utilizzo con operazioni di accesso ai files. Espone delle proprietà e dei distruttori atti ad assicurare che la risorsa di file sia restituita al sistema operativo. Il link diretto MSDN è: http://msdn.microsoft.com/it-it/library/microsoft.win32.safehandles.safefilehandle.aspx

IntPtr è invece una classe che definisce un puntatore a un area di memoria (formato Int 32 bit). E' equivalente a mettere un operatore star davanti a un tipo C. Unica differenza, il controllo di un puntatore C# a null va fatto come:

IntPtr a;

[ops]

if (a == IntPtr.Zero) { è a null }

Con questa semplice classe, passando i valori corretti, potremo aprire un file senza passare per il .NET, ma richiedendolo direttamente al sistema operativo. Immaginate di scrivere la vostra classe C, magari, che so, per comunicare con un microcontrollore mediante la porta COM e protocollo MODBUS (http://en.wikipedia.org/wiki/Modbus). Immaginate che sia estremamente performante, ma che adesso si presenti un piccolo problema: scrivere una GUI interamente in C può essere massacrante in termini di lavoro e tempo. Allora che si fa? Si scrive la GUI in .NET,e  si passa tutta la logica di controllo alla classe C. Facile e veloce.

La chiamata viene effettuata come un qualunque metodo static.

Calling an unmanaged Win32 DLL (Dynamic Linked Library) via a managed programming language is a hard task. But I have found an easy lesson for beginner-intermediate C# programmer to learn how to call Win32 DLLs using P/Invoke. By calling a native Win32 DLL you can do advanced tasks in C#. The article is a very long so I have included the link to the article in the MSDN Library below.

http://msdn.microsoft.com/en-us/magazine/cc164123.aspx

pinvoke.net: the interop wiki!

A wiki for .NET developers

PInvoke.net is primarily a wiki, allowing developers to find, edit and add PInvoke* signatures, user-defined types, and any other information related to calling Win32 and other unmanaged APIs from managed code (written in languages such as C# or VB.NET).

.NET developers worldwide can easily contribute to the community, sharing their valuable knowledge, whenever they have time to do so.

Das hier habe ich langelange gesucht:

(und einen Teil der dort archivierten Schnippets auch schon selbst fabriziert)

pinvoke.net: the interop wiki!

A wiki for .NET developers

PInvoke.net is primarily a wiki, allowing developers to find, edit and add PInvoke* signatures, user-defined types, and any other information related to calling Win32 and other unmanaged APIs from managed code (written in languages such as C# or VB.NET).

.NET developers worldwide can easily contribute to the community, sharing their valuable knowledge, whenever they have time to do so.

In one of my recent assignments at work I was to communicate with native code from my C# application. Micros0ft provides two kinds of platform invoke functionality i.e.

Implicit p/invoke: This is supported by VC++ only so managed C++ can call unmanaged code.

Explicit p/invoke: This is supported by .NET platform and any code written in C# or VB.NET can execute native code and vice versa.

Other than these, if native code is implemented as COM servers, .NET runtime provides COM Callable Wrappers to communicate with the managed code. Similarly it provides Runtime Callable Wrappers where managed code is exposed as COM objects for native code to communicate with the managed code.

In this article my focus will be on explicit p/invoke providing callback functionality and related memory issues.

To call unmanaged code from managed is pretty straight forward. All you have to do is to export the functions in the DLL. Then provide the declaration matching exact signature with Dllimport attribute and if custom structures or classes are being used as parameters provide their definition as well in the managed code.

For example if some dll Example.dll exports a function “int nStatus GetUpdate(char* strParam)”. To call this funciton in your .NET application declare it as follows

[Dllimport("Path\\Example.dll")]

public extern static int GetUpdate(MarshalAs(UnmanagedType.LPStr)] string strParam);

Then call it as follows

string strParam = "test data";

int iStatus = GetUpdate(strParam);

The native code would look like

int GetUpdate(char* strParam)

}

Lets involve custom structures first as value parameters and later on as ref parameter so that native application will allocate memory and managed code will consume.

[StructLayout(LayoutKind.Sequential)]
struct BridgeMember
{
public int nMember;
[MarshalAs(UnmanagedType.LPStr)]
public string strMember;
}
[StructLayout(LayoutKind.Sequential)]
struct BridgeData
{
public int nData;
public uint dwData;
[MarshalAs(UnmanagedType.LPStr)]
public string strData;
public eType eData;
public BridgeMember BMData;
}
enum eType { one = 1, two };

[DllImport(@"path\Example.dll", ExactSpelling = true, CharSet = CharSet.Ansi)]
public static extern int ProcessObjectByVal(BridgeData BInData);

Use it as follows
BridgeData oBridgeData = new BridgeData();
oBridgeData.BMData.nMember = 10;
oBridgeData.BMData.strMember = "From C# assembly";
oBridgeData.dwData = 20;
oBridgeData.eData = eType.one;
oBridgeData.nData = 30;
oBridgeData.strData = "From C#";

int n = ProcessObjectByVal(oBridgeData);

The native code will include the definitions of the structures exactly as above and the ProcessObjectByVal() will look like as follows


int ProcessObjectByVal(BridgeData BInData)
{
//get values from BInData and process...
return iSomeStatus;
}


Now if we want to pass BridgeData as ref or out parameter, for strings allocations has to be done using COM memory functions such as CoTaskMemAlloc. Because .NET runtime expect native code to allocate memory using CoTaskMemAlloc and it frees the pointers using CoTaskMemFree. If memory is allocated using other functions like new or malloc; the memory will not be freed or worse crash can occur as .NET runtime will try to free it using CoTaskMemFree in any case.
For details please this article on MSDN.
Following example illustrate the correct use of memory functions for p/invoke.
Native Code:

int ProcessObjectByRef(BridgeData* pBOutData)
{
pBOutData->BMData.nMember = 1;
int size = 400;
//pBOutData->BMData.strMember = new char[size]; //who will free it? using coTaskMemAlloc will fix this leak
pBOutData->BMData.strMember = (char*)CoTaskMemAlloc(size);
memset(pBOutData->BMData.strMember,0,size);
strcpy_s(pBOutData->BMData.strMember,size,"This is medium string");
pBOutData->dwData = 55;
pBOutData->eData = two;
pBOutData->nData = 14;
pBOutData->strData = (char*)CoTaskMemAlloc(20); //who will free it? will using coTaskMemAlloc fix this leak?
memset(pBOutData->strData,0,20);
strcpy_s(pBOutData->strData,20,"small string");
return pBOutData->nData;
}


Managed code:

[DllImport(@"path\Example.dll", ExactSpelling = true, CharSet = CharSet.Ansi)]
public static extern int ProcessObjectByRef(out BridgeData BInData);

BridgeData oBridgeDataOut;
n = ProcessObjectByRef(out oBridgeDataOut);
//use oBridgeDataOut here...


We just discussed out to process objects by ref where native code will allocate memory as required instead of passing String or StringBuilder with pre-allocated memory which might not be a good option for all cases where data is created by native application.

In the above example if IntPtr is used in place of attributed string, the managed code has to de-allocate the memory itself rather than relying on the Runtime for example

IntPtr IntPtrData;
String strData = Marshal.PtrToStringAuto(IntPtrData);
Marshal.FreeCoTaskMem(IntPtrData);

On various forums people report problems with programmatically assigning a virtual COM port to Bluetooth GPS receivers. It seems especially hard for developers to configure the virtual COM port without the need to reboot the phone.

Below are my C# code snippets that I managed to write. The code still references some functions which I haven’t pasted, but you should be able to analyze it without them.

Here’s how it works:

1. Use BluetoothClient.DiscoverDevices() from 32feet to find bluetooth devices in range
2. Let your user choose one – (lbDevices.SelectedValue in my code)
3. Check if the selected device already has COM port configured (lines 9-17 in first code snippet)
4. Let your user choose COM port and baud rate (that’s what GPSBluetoothSerialPortForm)
5. If the bluetooth GPS device is not paired yet, do it with BluetoothSecurity.PairRequest
6. Configure the COM port in the registry (HKLM\Software\Microsoft\Bluetooth\Serial\Ports (GPSConfig.SetBluetoothPortName() does that)
7. This is the key part if you don’t want to reboot the phone: call RegisterDevice() to notify the btd.dll driver about new COM port (GPSConfig.SetBluetoothPortName())

Now, you can open the COM port directly and read the NMEA sentences from it. However, if you want a few applications to share the GPS receiver, you should use it through the GPS Intermediate Driver.

There are three things to set in the GPS ID:

1. GPS ID hardware port (IntermediateDriver.SetExternalInPort())
2. GPS ID hardware port baud rate (IntermediateDriver.SetExternalInPortBaudRate())
3. GPS ID software port, if it’s not set (IntermediateDriver.GetOutPort() and IntermediateDriver.SetOutPort())
4. enable GPS ID (IntermediateDriver.EnableIntermediateDriver())
5. notice GPS ID about new config, so it reloads it (IntermediateDriver.Update())

All the GPS Intermediate Driver config is done through the system registry (HKLM\System\CurrentControlSet\GPS Intermediate Driver\). To make the GPS ID reload configuration, you have to open the GPD0 device with CreateFileW() and call the DeviceIoControl() with IOCTL_SERVICE_REFRESH parameter. I didn’t paste the code here, but I think I’ll write another blog post about it later.

Here’s the main part of the code:

        private void btDalej_Click(object sender, EventArgs e)
        {
            BluetoothDeviceInfo bdi = (BluetoothDeviceInfo)lbDevices.SelectedValue;
            bool has_serial_port = false;
            string serial_port = string.Empty;

            Guid[] services = bdi.InstalledServices;

            foreach (Guid serv in services)
            {
                if (serv == BluetoothService.SerialPort)
                {
                    has_serial_port = true;
                    serial_port = GPSConfig.GetBluetoothPortName(bdi.DeviceAddress);
                    break;
                }
            }

            using (GPSBluetoothSerialPortForm portform = new GPSBluetoothSerialPortForm(has_serial_port, serial_port))
            {
                portform.Owner = this;
                if (portform.ShowDialog() == DialogResult.OK)
                {
                    Application.DoEvents();

                    Cursor.Current = Cursors.WaitCursor;
                    string SelectedPort = (string)portform.cbPortName.SelectedItem;
                    string PinValue = (string)portform.tbPin.Text;
                    int SelectedBaudRate = (int)portform.cbBaud.SelectedItem;

                    // 1. setup selected COM port for bluetooth device
                    if (bdi.Authenticated == false)
                    {
                        bool ret = BluetoothSecurity.PairRequest(bdi.DeviceAddress, PinValue);
                        if (ret == false)
                        {
                            Cursor.Current = Cursors.Default;
                            MessageBox.Show("Connection to selected bluetooth device failed. If your GPS receiver was turned off, turn it on and try again, or try other device");
                            return;
                        }
                    }

                    if (GPSConfig.SetBluetoothPortName(bdi.DeviceAddress, SelectedPort) == false)
                    {
                        Cursor.Current = Cursors.Default;
                        MessageBox.Show("Failed to open selected COM port. Choose other COM port or restart your phone and try again");
                        return;
                    }

                    // 2. set selected COM port as GPS Intermediate Driver Hardware port
                    IntermediateDriver.SetExternalInPort(SelectedPort);
                    IntermediateDriver.SetExternalInPortBaudRate(SelectedBaudRate);

                    string GPSIDOutPort = IntermediateDriver.GetOutPort();
                    if (GPSIDOutPort == null || GPSIDOutPort.Length == 0)
                    {
                        // there is no software COM port set in GPS Intermediate Driver

                        // choose first free COM port
                        GPSIDOutPort = GPSConfig.GetFreeGPSIDPort();
                        if (GPSIDOutPort == null || GPSIDOutPort.Length == 0)
                        {
                            MessageBox.Show("Can't find free COM port. GPS configuration failed", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
                            Cursor.Current = Cursors.Default;
                            DialogResult = DialogResult.Cancel;
                            Close();
                        }

                        IntermediateDriver.SetOutPort(GPSIDOutPort);
                    }
                    IntermediateDriver.EnableIntermediateDriver();
                    IntermediateDriver.Update();

                    // 3. save configuration settings
                    Program.cfg.GPSPortName = IntermediateDriver.GetOutPort();
                    Program.cfg.GPSBaudRate = SelectedBaudRate;

                    Cursor.Current = Cursors.Default;
                    DialogResult = DialogResult.OK;
                    Close();
                }
            }
        }

GPSConfig.GetBluetoothPortName(...) and GPSConfig.SetBluetoothPortName(...) code

        public static string GetBluetoothPortName(BluetoothAddress deviceaddress)
        {
            string portname = string.Empty;
            long l_deviceaddress = deviceaddress.ToInt64();

            using (RegistryKey rk = Registry.LocalMachine.OpenSubKey(@"\Software\Microsoft\Bluetooth\Serial\Ports"))
            {
                foreach (string s_address in rk.GetSubKeyNames())
                {
                    long address = long.Parse(s_address, System.Globalization.NumberStyles.AllowHexSpecifier);

                    if (address == l_deviceaddress)
                    {
                        using (RegistryKey thisrk = rk.OpenSubKey(s_address))
                        {
                            portname = (string)thisrk.GetValue("Port", string.Empty);
                        }
                        break;
                    }
                }
            }

            return portname.TrimEnd(new char[] { '', '\n', '\r' });
        }

        public static bool SetBluetoothPortName(BluetoothAddress deviceaddress, string portname)
        {
            if (portname == null)
                return false;   

            string strDeviceAddress = deviceaddress.ToString("8");

            using (RegistryKey rkPorts = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Bluetooth\Serial\Ports", true))
            {
                RegistryKey rkNewPort;

                rkNewPort = rkPorts.OpenSubKey(strDeviceAddress, true);
                if (rkNewPort == null)
                {
                    rkNewPort = rkPorts.CreateSubKey(strDeviceAddress);

                    if (rkNewPort == null)
                    {
                        return false;
                    }
                }
                else
                {
                    // deregister for old port
                    string oldPort = ((string)rkNewPort.GetValue("Port", null)).Trim('');
                    if (oldPort != null)
                        DeregisterDevice(oldPort);
                }

                rkNewPort.SetValue("KeepDCB", 0);
                rkNewPort.SetValue("RemoteDCB", 0);
                rkNewPort.SetValue("Encryption", 0);
                rkNewPort.SetValue("Authentication", 0);
                rkNewPort.SetValue("Port", portname);
                rkNewPort.SetValue("Server", 0);

                rkNewPort.Close();
                rkNewPort = null;

                PORTEMUPortParams pep = new PORTEMUPortParams();
                pep.uiportflags = RFCOMM_PORT_FLAGS.REMOTE_DCB;
                pep.flocal = false;
                pep.device = deviceaddress.ToInt64();
                pep.uuidService = BluetoothService.SerialPort;

                string portprefix = portname.Substring(0, 3);
                int portindex = int.Parse(portname[3].ToString());

                IntPtr handle = RegisterDevice(portprefix, portindex, "btd.dll", ref pep);
                if (handle == IntPtr.Zero)
                {
                    rkPorts.DeleteSubKeyTree(strDeviceAddress);

                    return false;
                }
            }

            return true;
        }

… and the pinvokes

    [DllImport("coredll.dll", SetLastError = true)]
    private static extern IntPtr RegisterDevice(
        string lpszType,
        int dwIndex,
        string lpszLib,
        ref PORTEMUPortParams dwInfo);

    [StructLayout(LayoutKind.Sequential)]
    internal struct PORTEMUPortParams
    {
        internal int channel;
        [MarshalAs(UnmanagedType.Bool)]
        internal bool flocal;
        internal long device;//10
        internal int imtu;
        internal int iminmtu;
        internal int imaxmtu;
        internal int isendquota;
        internal int irecvquota;
        internal Guid uuidService;//16
        internal RFCOMM_PORT_FLAGS uiportflags;
    }

Update: this seems important, and I forgot to add it before. Below is the IntermediateDriver.Update() code

    // update GPS intermediate driver configuration
    public static bool Update()
    {
        IntPtr hGPS;

        hGPS = CECreateFileW("GPD0:", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
        IntPtr.Zero, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, IntPtr.Zero);

        if ((int)hGPS != INVALID_HANDLE_VALUE)
        {
            uint bytesReturned;
            DeviceIoControl(hGPS, IOCTL_SERVICE_REFRESH, IntPtr.Zero, 0, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero);
            CECloseHandle(hGPS);
            return true;
        }
        else
            return false;
    }

The .Net libraries have many built-in objects that can be used to create most types of programs for windows. In most cases, the typical developer would not need anything more. However, there are a few cases in which a direct call to a COM object is needed. The ability to call objects that are not .Net from within .Net is called Interoperability. InterOp calls are often used in cases where a .Net program needs to communicate with older software that is based on COM. It can also be used to make direct calls to the windows Kernel. In these cases, a common term among .Net developers is the Pinvoke. Using a Pinvoke is very similar to calling a Windows API from VB6. You need to copy the declaration and import the library and then you can use it. The compiler sees code that uses Pinvoke as being unsafe code. This means that you will need to set the project properties for your code to allow compile unsafe code. The declarations and constants used for these calls can all be found at http://www.pinvoke.net/. Some sample .Net code that uses a Pinvoke can be seen below. This code is using the Windows Kernel to create a file.

using System;

using System.Collections.Generic;

using System.Text;

namespace CreateFilewithPinInvoke

{

    class FileReader

    {

        const uint GENERIC_READ = 0×80000000;

        const uint FILE_ALL_ACCESS = 0×80000000;

        const uint OPEN_EXISTING = 3;

        const uint OPEN_ALWAYS = 3;

        System.IntPtr handle;

        [System.Runtime.InteropServices.DllImport("kernel32", SetLastError = true)]

        static extern unsafe System.IntPtr CreateFile

        (

            string FileName,          // file name

            uint DesiredAccess,       // access mode

            uint ShareMode,           // share mode

            uint SecurityAttributes,  // Security Attributes

            uint CreationDisposition, // how to create

            uint FlagsAndAttributes,  // file attributes

            int hTemplateFile         // handle to template file

        );

        [System.Runtime.InteropServices.DllImport("kernel32", SetLastError = true)]

        static extern unsafe bool CloseHandle

        (

            System.IntPtr hObject // handle to object

        );

        public bool Open(string FileName)

        {

            // open the existing file for reading      

            handle = CreateFile(FileName,FILE_ALL_ACCESS,0,0, OPEN_ALWAYS,0,0);

            if (handle != System.IntPtr.Zero)

                return true;

            else

                return false;

        }

        public bool Close()

        {

            return CloseHandle(handle);

        }

    }

    class Program

    {

        static int Main(string[] args)

        {

            if (args.Length != 1)

            {

                System.Console.WriteLine(“Usage : CreateFile.exe <FileName>”);

                return 1;

            }

            FileReader fr = new FileReader();

            if (fr.Open(args[0]))

            {

                System.Console.WriteLine(“Created requested file”);

                return 0;

            }

            else

            {

                System.Console.WriteLine(“Failed to create file!”);

                return 1;

            }

        }

    }

}

-Enjoy.

It may seem like a waste to have a whole post dedicated to a feature that isn’t there, but knowing this fact would have saved me some wasted mental effort and disappointment.

The Compact Framework is necessarily small. Microsoft only puts functionality into it that developers will be likely to actually need. This means that a lot of stuff you’d like to be there isn’t. This also means that you might need to interoperate with native code to do some of what you want to do.

If you are like me, this means you would like to use C++/CLI (the old-school .NET technology formerly known as Managed C++) to do that interop. You, like me, would be sorely disappointed. C++/CLI is not supported on the Compact Framework, and as far as I know there are no plans to add it. Prepare to P/Invoke.

با سلام خدمت دوستان خوبم امروز می خوام یک سری کد و یک نمونه برنامه براتون بزارم تا با نحوه دریافت تصاویر از webcam و ذخیره تصاویر دریافتی در فایل avi آشنا بشین. بدون بحث اضافی می رم تا توضیح مختصری در مورد کد های برنامه براتون بدم. در این پروژه ما سه تا کلاس اساسی داریم که به قول معروف، تقریبا کارهای تصویر برداری و ضبط تصاویر رو بر عهده دارن.

1- کلاس CaptureAPI : نمونه pinvoke شده API های کار با دوربین

2- کلاس AVIStreamAPI : نمونه pinvoke شده API های کار با فایل های avi از قبیل ساخت فایل، ساخت استریم avi، ساختن header های فایل avi و …

3- کلاس AviStream : که وظیفه ساخت فایل و ضبط تصاویر رو با استفاده از api های pinvoke شده رو بر عهده داره.

در این پروژه پس از اتصال به webcam با استفاده از توابع کلاس CaptureAPI و پخش تصاویر با استفاده از event OnVideoCaptured هر frame به bitmap تبدیل شده و سپس بر روی pictureboxنمایش داده میشه. با استفاده از این روش و تبدیل frame های استخراج شده به bitmap نوبت میرسه به ساخت فایل avi و stream مربوط به فایل avi با استفاده از توابع کلاس AviStream، ابتدا فایل avi Initialize شده سپس با استفاده از flage Create فایل avi خام بدون هیچگونه data و header ی که در ساخت avi به کار میره، ساخته میشه . پس از مراحل ساخت فایل نوبت به initalize کردن stream فایل avi میرسه، پس از ساخت stream ، اولین frame که به صورت bitmap هستش به stream اضافه میشه و به همین ترتیب frame های بعدی تا زمان توقف تصویربرداری و بستن فایل avi . شما به راحتی میتونید با استفاده از این روش با دوربین یا webcam ی که در منزل دارید برنامه ای بنویسید که دوربین رو شناسایی کرده اطلاعات رو frame به frame بگیره و ضبط کنه.

نمونه ی برنامه رو می تونید از لینک پایین دانلودش کنید. امیدوارم تونسته باشم کمکی در یادگیری کار با دوربین و ضبط تصاویر کرده باشم.

لینک دریافت نمونه پروژه :http://www.megaupload.com/?d=2SJM7J40

Meine persönliche Topliste der nützlichsten Tools, die jeder .NET-Programmierer kennen sollte:

Visual Studio:

• Resharper 4.1 (sehr umfangreiches Produktivitäts-Add-In)
• VisualSVN, TortoiseSVN, Subversion (Versionsverwaltung)
• PowerToys for Visual Studio (Einige nützliche Helfer)
• TeamCity (Continuous Integration Server)
• PInvoke.NET (Add-In mit (fast?) allen nativen P/Invokes)
• PowerCommands (Noch mehr kleine nützliche Helfer)
• Strg + Tab (Kein Add-In, sondern ein Tipp, den kaum einer nutzt *g*)
• Tree Surgeon (Erlaubt zügiges Erstellen von Projekten-Bäumen)
• Reflector.NET + Addins (Untersucht Klassen mit Reflektion)
• GhostDoc (Erstellt automatische XML-Kommentare)

• db4o (Objektorientierte Datenbank)
• Castle Project Windsor Container, ActiveRecord und MonoRail (Diverse Pattern-Implementierungen)
• Ogre3d (Grafikengine) / Mogre (Managed)
• NUnit (Unit Testing for .Net)
• moq (Mocking-Framework, das die neuen Features (Lambda-Expressions) von C# 3.5 nutzt)

Bis auf Resharper und VisualSVN sind alle Tools kostenfrei erhältlich. Diese Liste werde ich in regelmäßigen Abständen erweitern

This article has moved.

My last post detailed how to monitor user activity and update the user’s state when they become inactive.  With that code, we can switch between Available, Inactive, and Away states based on user input via the keyboard or mouse.  The next step is to notify OCS when the user locks their machine, by changing the user’s availability to Away.  To do this, we’re going to need to use P/Invoke again, this time calling the WTSRegisterSessionNotification function, part of WtsApi32.dll.  This will only work on a Windows XP or newer OS.  This function takes a handle to a window we own, which is then notified of session changes by the WM_WTSSESSION_CHANGE message.  To receive that notification we need a class that can hook into the windows message loop, something derived from System.Windows.Forms.Control, which I added as a private nested class in the PresenceManager:

Surprisingly, WTSRegisterSessionNotification was not yet documented at pinvoke.net, so I added a page for it.  The SessionChangeHandler registers itself when it is constructing, and makes a corresponding call to WTSUnRegisterSessionNotification just before the handle is destroyed.  Any time the machine is locked or unlocked, the appropiate event is fired, which the PresenceManager can easily handle:

We can use the same code to publish the presence state to OCS as we did in the timer callback, which I’ll cover in part three.  If you’re not sure it worked, adding a few calls to Debug.WriteLine can help.  At this point, the PresenceManager handles availability the same way we are used to seeing from other IM clients.  It just needs to be instantiated and kept somewhere, and it will handle automatic presence until disposed.  In the last part of this series I’ll cover publishing presence state to OCS, and the issues I encountered with the UCC API.

Most popular IM clients, including Communicator 2007, automatically modify the user’s status when they are inactive or away.  While piloting Office Communications Server we created a simple application that had the main features of Communicator (chat, A/V, presence, etc.) to show that we could incorporate that functionality into our in-house applications so that our agents only have to work with one piece of software.  The presence functionality is important to us, as we don’t want to route inbound calls from Speech Server to an agent who isn’t available.  As part of the pilot, I created a simple presence manager to monitor user activity and update availability when necessary.  After five minutes of inactivity, a state value of Inactive is published.  After 15 minutes, a state value of Away is published.  Finally, if the user locks the machine, a state value of Away is published.

Basically, there are two different things the manager needs to detect: the last time there was input (keyboard/mouse) to the machine, and when Windows is locked.  After a little digging, I found the easiest way to achieve our first goal was to P/Invoke the GetLastInputInfo function, which returns the time of the last keyboard/mouse activity.  Using a timer, we can call this method as often as necessary to check if our thresholds (five and 15 minutes) have been reached.  For the sake of simplicity, I removed the code that publishes the state to OCS.  We could also easily add logic to check if the user is on the phone, so the “In a Call” state isn’t overwritten. 

NOTE: I’m using the System.Threading.Timer class.

Now we just need to define the LASTINPUTINFO structure that we pass in GetLastInputInfo.  I nested it inside the manager:

GetLastInputInfo requires the cbSize field to be set before the method is called, so I added a Create method to return an instance ready to be uses.  The timer calls back on a thread retrieved from the thread pool, but we can publish to OCS from any thread.  I found that two seconds was a good interval that updated the state to Available in a reasonable time.  In the second post I’ll cover detecting when the machine is locked/unlocked using another P/Invoke operation.

Am Anfang dieses Monats habe ich über Win 32-Api-Calls in C#-Anwendungen geschrieben. Ich beschrieb wie ich diese Funktionen mittels DllImport usw. aufrufen und benutzen kann.

Die Schwiereigkeit dabei ist, die geeigneten Datentypen oder überhaupt die richtige DLL-Datei zu finden. Hier schafft die Seite http://pinvoke.net/ Abhilfe.

Die Seite selbst beschreibt sich: “A wiki for .NET developers: PInvoke.net is primarily a wiki, allowing developers to find, edit and add PInvoke signatures, user-defined types, and any other information related to calling Win32 and other unmanaged APIs from managed code (written in languages such as C# or VB.NET).”

Das ist schonmal gut. Aber besser ist noch, dass die Community um PInvoke ein Add-in für Visual Studio bereitstellt um direkt auf den Inhalt von Pinvoke zuzugreifen:  Download the PInvoke.net Add-in for FREE now.

Einfacher geht es nur, wenn wir Win32-Api-Calls nie mehr benutzen müssten…

Una de las cosas que más me atrae de Mono para ciertas tareas es su plataforma P/Invoke, un método para aprovechar las bibliotecas dinámicas que estén presentes en el sistema. Esto permitiría, por ejemplo, utilizar las funciones de bibliotecas no nativas como NCurses o TCL.

Utilizar P/Invoke es muy sencillo incluso para un profano como yo. Sólo es necesario incluir el namespace System.Runtime.InteropServices y la etiqueta DllImport. A continuación lo ilustraré con un ejemplo.


using System;
using System.Runtime.InteropServices;
public class Libc
{
[DllImport ("libc")]
private extern static int getpid ();
public int Getpid ()
{
return (getpid());
}
}
public class PruebaLibc
{
public static void Main (string [] args)
{
Libc obtenerPID = new Libc();
Console.WriteLine ("El PID del proceso es: {0}", obtenerPID.Getpid());
}
}

El ejemplo es muy sencillo. En la clase que he definido, la etiqueta indica el nombre de la biblioteca de donde se va a tomar la función. En este caso basta poner libc ya que se corresponde con la biblioteca libc.so.6. En el archivo /etc/mono/config podemos ver todas las correspondencias configuradas por defecto.

Una vez importadas todas las funciones de la biblioteca es necesario crear envolturas para cada una de ellas. Esto se debe a que es muy aconsejable definir las funciones importadas como privadas.

¡Y ya está! Sólo falta escribir una nueva clase de prueba. En ella he creado un objeto de la clase Libc y he llamado al método Getpid(), cuyo funcionamiento es idéntico al getpid() original.

La salida de este programa será algo así.

$ mono Libc.exe
El PID del proceso es: 19090
$

En los enlaces que he puesto más arriba podreis encontrar más información sobre P/Invoke. Yo, con vuestro permiso, seguiré explorando las bondades de Mono

Wieder einmal eine Frage, die sich der ein oder andere sicherlich schon mal gestellt hat, was ist, wenn der Befehl/die Funktion die ich brauche nicht in der .NET-Library enthalten ist? – Klar, momentan gibt es (so gut wie .NET 3.5) aber es ist immer noch nicht alles von Windows “gewrappt” worden.

Kann man also unter (innerhalb) von C# Win32-Api-Methoden aufrufen? – JA.

Und zwar so:

1. Wir machen unsere Funktion ausfindig. Z.B. die Methode den um die Workstation, also unsere aktuelle Windows-Sitzung zu sperren.
2. Die MSDN-Library sagt hierzu, dass wir die Methode LockWorkStation aus der user32.dll-Datei brauchen.
3. Nun schreiben wir in unsere C#-Klasse folgende Zeilen:
[DllImport("user32.dll", SetLastError = true)]
public static extern bool LockWorkStation();

   Hierbei Importieren wir die “user32.dll” mittels “DllImport” und müssen natürlich die Methode als “extern” definieren, da sie ja aus dieser DLL-Datei importiert wird.
   “SetLastError=true” sagt nur, dass wir eine Fehlermeldung der Importierten Methode auslesen könnten.Anmerkung: Hätten wir zu dem DllImport-Attribute noch ” EntryPoint=”LockWorkStation” ” geschrieben hätten wir unsere Methode anders benennen können, also z.B. wie folgt:
   [DllImport("user32.dll", EntryPoint="LockWorkStation", SetLastError = true)]
public static extern bool Lock();

4. Das ist auch schon alles.
    

Viel Spass!