Les DLL natives en .NET

Date de publication : 18/11/2004 , Date de mise a jour : 18/11/2004

Par LEBRUN Thomas (Autres Articles)
 

Dans cet article, vous apprendrez comment faire appel, dans vos applications .NET, à des fonctions dont le code est implémenté dans des DLL natives.

I. Introduction

II. Utilisation

A. Explications

• La déclaration de la fonction doit être précédée de l'attribut DllImport, qui indique le nom de le 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

B. Exemples

Utilisation de DllImport
// 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);
			}

		}

• Changer le nom de votre méthode, et remplacer tous les appels de votre méthodes 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

Utilisation de l'attribut EntryPoint
// 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);
		}

Utilisation de SetLastError et GetLastWin32Error
// 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érer par une autre API...)
• Vous pouvez également utiliser une méthode que j'ai trouvée  ici

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

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 fournit 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 message d'erreur d'une DLL depuis le code d'erreur

III. Conversion de type

Ce tableau peut être retrouvé dans la MSDN de Microsoft, à cette adresse:  http://msdn.microsoft.com/msdnmag/issues/03/07/NET/default.aspx?fig=true#fig2

IV. Passage d'arguments par pointeurs

a. Les risques

b. La solution

// 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);
}

.....

V. Passage de chaînes de caractères

• Premièrement, vous pouvez essayer de comprendre le but du paramètre. En effet, si vous avez un paramètre ayant par exemple le nom de SetTexte, vous pouvez supposer que ce paramètre en en entrée uniquement. A l'inverse, un paramètre du nom de GetTexte fait plutôt penser à un pramètre de sortie. Bien que fonctionnant, cette technique n'est pas sur à 100% (que faire par exemple si le paramètre porte le nom de Toto ?), et n'est pas très "professionnelle"
• L'autre méthode consiste à regarder le nom du type de paramètre. Si celui-ci contient un C (par exemple LTCTSTR), le paramètre sera en entrée. Dans le cas contraire, le paramètre sera en sortie.

• Unicode
• ANSI

Passage de chaîne de caractères : Exemple avec un paramètre de sortie
// Déclaration des using
using System;
using System.Runtime.InteropServices;

class FenetreClignotante
{
	// Déclaration de la méthode à utiliser
	[ DllImport("kernel32", CharSet=CharSet.Auto) ]		
	public static extern uint GetCurrentDirectory
	(
		uint Taille,
		StringBuilder sTmp
	);


	// Point d'entrée de l'application
	static void Main(string[] args)
	{
		uint Taille = 255;
		StringBuilder sTmp = new StringBuilder((int)Taille);

		uint i = GetCurrentDirectory(Taille, sTmp);

		Console.WriteLine(sTmp);
	}

}

Passage de chaîne de caractères : Exemple avec un paramètre d'entrée et un paramètre de sortie
// ** Documentation for Win32 GetShortPathName() API Function
// DWORD GetShortPathName(
//   LPCTSTR lpszLongPath,      // file for which to get short path 
//   LPTSTR lpszShortPath,      // short path name (output)
//   DWORD cchBuffer            // size of output buffer
// );

[ DllImport("Kernel32", CharSet = CharSet.Auto) ]
static extern Int32 GetShortPathName
(
   String path,                // input string
   StringBuilder shortPath,    // output string
   Int32 shortPathLength);     // StringBuilder.Capacity
)

VI. Conclusion

Cet article vous a donc fourni une bonne approche des Dll natives et de leurs utilisations dans vos applications .NET. Il ne vous reste plus qu'à tenter vous-même l'expérience ;)
Et j'ajouterai juste un dernier mot, pour dire aux développeurs d'applications mobiles, qu'utiliser P/Invoke sur les périphériques embarqués (Pocket PC, SmartPhone, etc..) est tout à fait possible, comme le démontre cette source :  Contrôler la LED de votre Pocket PC.

VI. Liens

 Calling Win32 DLLs in C# with P/Invoke
 Consommation de fonctions DLL non managées