Les DLL natives en .NET

Toutes les classes qui vous permettent d'utiliser P/Invoke se trouvent dans l'espace de nom System.Runtime.InteropServices (vous devez donc penser à faire un using ou Import, selon le langage de programmation que vous utilisez, pour pouvoir utiliser ces classes).
Ensuite, vous devez déclarer, dans votre classe, la fonction que vous souhaitez utiliser. Cette déclaration doit suivre une certaine méthodologie :

• la déclaration de la fonction doit être précédée de l'attribut DllImport, qui indique le nom de la DLL ;
• les mots-clés static et extern (pour indiquer que la méthode à utiliser provient d'une source extérieure) doivent être utilisés ;
• le nom de la fonction doit être le même que celui spécifié dans la DLL ;
• chaque argument doit avoir un nom ;
• vous devez connaître le prototype de la méthode que vous désirez implémenter.

Étant donné que cela peut paraître abstrait, la section suivante vous montrera un exemple.

Le programme suivant vous montrera un exemple d'utilisation de l'attribut DllImport, pour utiliser une méthode contenue dans le fichier user32.dll.
La méthode que nous allons appeler est la méthode FlashWindow, dont le but est de faire clignoter une fenêtre (de la même façon qu'une fenêtre MSN Messenger par exemple).

// Déclaration des using
using System;
using System.Runtime.InteropServices;

class FenetreClignotante
{
    // Déclaration de la méthode à utiliser
    [ DllImport("user32") ]        
    static extern int FlashWindow
    (
        int hwnd,
        int bInvert
    );

    private int hWND;

    // Point d'entrée de l'application
    static void Main(string[] args)
    {
        hWND = (int)this.Handle;
        // Utilisation de la méthode
        FlashWindow(this.hWND, 1);
    }

}

Il est parfois possible que vous ne puissiez pas spécifier le nom de la méthode définie, car l'une de vos fonctions porte déjà ce même nom. Dans ce cas, vous avez deux possibilités :

• changer le nom de votre méthode, et remplacer tous les appels de votre méthode avec le nouveau nom (ce qui peut parfois s'avérer long…) ;
• changer le nom de la fonction implémentée dans la DLL native ;
• mettre votre classe dans un de vos namespace.

Dans le deuxième cas, vous devrez utiliser la propriété optionnelle EntryPoint (Point d'entrée) pour indiquer le nom de la méthode à charger.
Un exemple étant toujours plus parlant que des mots, voici de quoi je veux parler

// Déclaration des using
using System;
using System.Runtime.InteropServices;

// Déclaration de la méthode à utiliser
[ DllImport("user32.dll", EntryPoint="FlashWindow") ]        
static extern int MonClignotement
(
    int hwnd,
    int bInvert
);

private int hWND;

// Point d'entrée de l'application
static void Main(string[] args)
{
    hWND = (int)this.Handle;
    // Utilisation de la méthode
    MonClignotement(this.hWND, 1);
}

Une autre propriété qu'il est intéressant d'utiliser est SetLastError. En effet, lorsque vous programmez, il est important de penser aux différentes erreurs qui peuvent survenir (la plupart des DLL étant écrites en C, elles ne génèrent pas d'exceptions, mais renvoient des codes d'erreurs). Pour pouvoir intercepter ces erreurs lorsque vous travaillez avec P/Invoke, vous devez mettre à true (vrai) cette propriété, afin de pouvoir récupérer l'éventuelle exception qui pourrait survenir, au moyen de la méthode GetLastWin32Error (GetLastWin32Error est défini dans System.Runtime.InteropServices.Marshal).
Voici un exemple pour illustrer cette propriété :

// Nous utiliserons ici la méthode Beep de la DLL kernel32.dll
// Déclaration des using
using System;
using System.Runtime.InteropServices;

class FenetreClignotante
{
    // Déclaration de la méthode à utiliser
    [ DllImport("kernel32", SetLastError=true) ]        
    static extern bool Beep
    (
        uint iFreq,
        uint iDuration
    );

    // Point d'entrée de l'application
    static void Main(string[] args)
    {
        if ( !Beep(100, 100) )
        {
            Int32 err = Marshal.GetLastWin32Error();
                      throw new Win32Exception(err);
        }
    }

}

GetLastWin32Error() nous permet donc de récupérer le code d'erreur de l'exception. Vous pouvez voir à quoi correspond chaque code d'erreur à cette adresse : Liste des codes d'erreur.
Néanmoins, il existe deux techniques pour pouvoir récupérer directement la description correspondant au code d'erreur :

• vous pouvez utiliser l'API : FormatMessage, ce qui est assez fastidieux (vous devrez utiliser une API pour comprendre l'erreur générée par une autre API…) ;
• vous pouvez également utiliser une méthode que j'ai trouvée : ici.

La deuxième méthode est simple: dans votre code, remplacez :

Int32 err = Marshal.GetLastWin32Error();
throw new Win32Exception(err);

par ceci :

string errorMessage = new Win32Exception(Marshal.GetLastWin32Error()).Message;

errorMessage contient alors le message d'erreur, plutôt que le code d'erreur.

Si vous tenez tout de même à utiliser l'API FormatMessage voici une classe fournie par : abelman et qui vous permet de récupérer le message d'une DLL à partir du code d'erreur : Classe permettant la récupération des messages d'erreur d'une DLL depuis le code d'erreur.

Utiliser le passage d'arguments par pointeurs peut représenter un gros risque si vous n'avez pas bien saisi le fonctionnement du Garbage Collector (ramasse-miette).
En effet, ce ramasse-miette est « l'outil » du framework .NET qui est chargé de libérer les objets qui ne sont plus nécessaires dans votre application : il est donc chargé de déplacer des objets en mémoire. Étant donné que son passage est aléatoire, vous prenez le risque, si vous passez l'adresse d'un objet par l'intermédiaire d'un pointeur, que le Garbage Collector déplace cet objet en mémoire. Votre pointeur sera alors invalide, car il ne pointera plus vers l'objet. Ce résultat entraînera alors des bugs ou bien des plantages de votre application.

Pour éviter que cela ne se produise, vous devez fixer les objets en mémoire. Cela peut être fait au moyen du mot clef fixed. Le Garbage Collector saura alors qu'il ne doit pas bouger, en mémoire, les instances de ces objets. Un exemple de code vous permettra de mieux comprendre de quoi il retourne: nous utiliserons la méthode ReadFile, qui doit être utilisée après un appel à la méthode CreateFile. Pour information, ces méthodes peuvent être utilisées pour envoyer et lire des données sur les ports COM.

// Fonction ReadFile
[ DllImport("kernel32") ]
public static extern bool ReadFile
(
    IntPtr hFile,
    void *lpBuffer,
    uint NbOctevtALire,
    uint *lpNbOctetsLus,
    IntPtr lpOverlapped
);

...

int handle = ... // Appel à la fonction CreateFile
uint NbOctectsLus = 0;
byte [] Buffer = new Byte[1024];

fixed( byte* pBuffer = Buffer )
{
    bool b = ReadFile(handle, pBuffer, 1024, &NbOctectsLus, 0);
}

.....

Notez que la fonction ReadFile renvoie un booléen, qui indique si la méthode s'est bien déroulée ou non.
Une petite astuce pour savoir si un argument doit être passé par valeur ou par référence: si, dans son prototype, le type d'un paramètre commence par la lettre P ou par les lettres LP, alors vous devez passer ce paramètre par référence.