Blog de Nico-pyright(c) » C++ Interop

[C++/CLI] Comment créer un Wrapper C++/CLI, exemple de compression en .Cab

nico-pyright(c) — Sat, 27 Sep 2008 08:58:09 +0000

on me demande souvent comment créer un wrapper C++/CLI …

Je vais, dans ce post, vous guider dans la création d’un tel wrapper.
Pour l’exemple, je vais utiliser la très bonne bibliothèque de compression en .Cab, créée par Elmue sur CodeProject.

Cette bibliothèque possède une version C++ et une version .Net, cette dernière ayant été créé avec le Managed C++ de Visual Studio 2002, je vais vous montrer comment on peut encapsuler la version C++ pure dans un wrapper C++/CLI afin de l’utiliser avec vos projets .Net.

Pour cet exemple, je vais encapsuler uniquement la compression, donc je vais soulager le projet C++ de quelques fichiers et je vais les modifier pour retirer les références à ces fichiers inutiles.

J’ai donc cette liste de fichier qui vont me servir :
– Blowfish.h
– Compress.h
– Error.h
– File.h
– Map.h
– String.h

(notez que j’ai renommé les fichiers .hpp en .h parce que j’aime mieux …)

Je créé ensuite un nouveau projet CLR : Class Library que j’appelle CabUtil (il est donc compilé avec l’option /clr).
J’y ajoute les fichiers précédemment cités, je compile … et c’est presque terminé !
La fonctionnalité nommée C++ Interop a fait tout le boulot pour nous. Elle a compilé du code natif dans notre assembly .Net.

Passons désormais à la création du wrapper C++/CLI, qui fera office de wrapper et de façade en même temps.

Je créé une nouvelle classe, que j’appelle CabUtil.

Ici, je n’ai pas grand chose à wrapper, mais nous allons le faire quand même. On remarque qu’on a besoin d’un char * qui représente la clé de cryptage du .Cab.

Créons donc un membre privé de type char *

char * s8_EncryptionKey;

Je vais lui affecter une valeur par défaut dans mon constructeur :

CabCompress()
{
s8_EncryptionKey = new char[73];
strcpy(s8_EncryptionKey, "");
}

Maintenant, on va créer une propriété qui va exposer une String ^ .Net et qui se chargera de convertir en char * :

property String ^EncryptionKey
{
void set(String ^value)
{
if (value->Length > 72)
value = value->Substring(0, 72);
char* temp = static_cast(Marshal::StringToHGlobalAnsi(value).ToPointer());
strcpy(s8_EncryptionKey, temp);
Marshal::FreeHGlobal(safe_cast(temp));
}
}

Note : la clé ne peut pas dépasser 72 caractères.

Bien sur, il ne faudra pas oublier de désallouer le char * dans les destructeurs et finalizers :

~CabCompress()
{
delete s8_EncryptionKey;
s8_EncryptionKey = NULL;
}

protected:
!CabCompress()
{
delete s8_EncryptionKey;
s8_EncryptionKey = NULL;
}

Je vais maintenant passer à l’écriture d’une méthode qui va compresser une liste de fichier, cette méthode étant une façade pour un algorithme un peu plus complexe.
Il s’agit de la méthode :

void CompressFileList(IDictionary^ fileList, String ^compressFile)

Elle prend en paramètre un dictionnaire qui va contenir le nom du fichier à compresser et sa destination dans l’arborescence du .Cab. Le deuxième paramètre est le fichier archive de destination.

Il y a dans cette méthode quelques conversions de String ^ en char *, mais nous n’allons pas nous attarder, vu qu’on a déjà vu le principe plus haut.
L’autre élément intéressant est le mapping d’une callback native en delegate .Net. Nous allons créer un événement pour être informé de la mise à jour du status de la compression.

On avait en C++, la définition suivante pour gérer la callback :

Cabinet::CCompress::kCallbacks k_ComprCallbacks;
k_ComprCallbacks.f_UpdateStatus = &CMain::OnUpdateStatus;

avec la méthode statique associée :

static int CMain::OnUpdateStatus(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param)
{
...
}

pour wrapper ceci, nous allons créer un delegate, dans les membres privés :

[UnmanagedFunctionPointer(CallingConvention::StdCall)]
delegate int WrapperUpdateStatusHandler(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param);
WrapperUpdateStatusHandler ^UpdateStatusDelegate;

Notez que le delegate a bien sur la même signature que la méthode OnUpdateStatus.

Dans notre méthode, on pourra instancier notre delegate ainsi :

UpdateStatusDelegate = gcnew WrapperUpdateStatusHandler(this, &CabCompress::UpdateStatus);

qui est raccroché à la méthode

static int UpdateStatus(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param)

(les observateurs auront noté que j’ai changé le nom de la méthode C++, qui au passage, n’est plus statique)

Ensuite on utilise GetFunctionPointerForDelegate pour raccrocher ce delegate à la callback en C++

IntPtr p = Marshal::GetFunctionPointerForDelegate(UpdateStatusDelegate);
k_ComprCallbacks.f_UpdateStatus = (Cabinet::CCompress::kCallbacks::t_UpdateStatus)p.ToPointer();
i_Compress.SetCallbacks(&k_ComprCallbacks);

Maintenant, la méthode UpdateStatus pourra lever l’événement suivant (qu’on aura défini comme membre public de la classe) :

delegate void UpdateStatusHandler(int PercentComplete);
event UpdateStatusHandler ^OnUpdateStatus;

int UpdateStatus(UINT typeStatus, Cabinet::CCompress::kCurStatus *pk_CurStatus, void *p_Param)
{
if (pk_CurStatus->FolderPercent > 0)
OnUpdateStatus(pk_CurStatus->FolderPercent);
return 0;
}

Et voilà, il ne nous reste plus qu’à compiler et notre assembly est prête.

Reste à l’utiliser dans un programme C#. Pour ce faire, on référence cette assembly dans notre projet, et on peut appeler la méthode de compression ainsi :

static void Main()
{
CabCompress c = new CabCompress();
c.OnUpdateStatus += c_OnUpdateStatus;
Dictionary dictionary = new Dictionary
{
{"C:\\test.txt", "C\\test.txt"},
{"C:\\temp\\fichier.mp3", "C\\temp\\fichier.mp3"}
};
c.CompressFileList(dictionary, "C:\\OutPut_%d.cab");
}

static void c_OnUpdateStatus(int PercentComplete)
{
Console.WriteLine("Compression : {0} %", PercentComplete);
}

Vous pouvez télécharger les sources de cet exemple : version zip ou version rar

[C++ Interop] Marshaling d’un tableau de wchar_t

nico-pyright(c) — Thu, 13 Mar 2008 20:00:00 +0000

Suite à une question, voici un exmple pour passer un tableau de wchar_t d’une DLL C à une application managée (C# par exemple).

Soit une dll C qui expose une méthode qui alloue et initialise un wchar_t ** :

#include

extern "C" __declspec(dllexport) void demo(wchar_t ** &tab)
{
#define SIZE 10
tab = new wchar_t* [SIZE];
for (int i = 0; i < SIZE ; i++)
{
tab[i] = new wchar_t[20];
swprintf(tab[i], L"chaine : %i", i);
}
}

et le code C# pour récupérer le tableau de chaine :

[DllImport("demoWchar.dll")]
public static extern void demo(out IntPtr buff);

static void Main()
{
IntPtr test;
demo(out test);

int tailleTableau = 10;
IntPtr[] tabPointeur = new IntPtr[tailleTableau];
Marshal.Copy(test, tabPointeur, 0, tailleTableau);
for (int i = 0; i < tailleTableau; i++)
Console.WriteLine(Marshal.PtrToStringUni(tabPointeur[i]));
}

La taille d’un tableau est toujours problèmatique.
Ici elle est fixée en dur, mais en général, c’est une donnée qui transite également dans les paramètres.

Télécharger l’exemple complet

[C++/CLI] Participez à l’augmentation de la bibliothèque marshal_as

nico-pyright(c) — Thu, 14 Feb 2008 20:00:00 +0000

Une nouveauté dans visual studio 2008 est l’utilisation du template marshal_as pour faire du marshaling.

Incomplète encore à l’heure actuelle, retrouvez le blog dédié à son enrichissement à cette adresse : http://www.marshal-as.net/
Vous pouvez également envoyer vos contributions à Kate Gregory

[C++/CLI] Intéropérabilité de structure

nico-pyright(c) — Fri, 01 Feb 2008 21:52:49 +0000

Je viens de mettre à jour mon tutoriel sur l’intéropérabilité où j’expose une manière plus simple de mettre à jour une structure C native par référence depuis un programme C#.

soit la structure C suivante

typedef struct {
int age;
int taille;
} MASTRUCTURE;

et la méthode suivante qui incrémente une structure passée en paramètre :

extern "C" __declspec(dllexport) void Inc(MASTRUCTURE * s)
{
s->age++;
s->taille++;
}

On peut utiliser les méthodes PtrToStructure et StructureToPtr pour faire l’intéropérabilité, mais on peut également utiliser une méthode très simple en déclarant notre structure avec le mot clé struct :

[StructLayout(LayoutKind.Sequential)]
public struct MaStructCSharp
{
public int age;
public int taille;
}

Et si on déclare le DllImport avec une référence :

[DllImport("libCStruct.dll")]
public static extern void Inc(ref MaStructCSharp s);

On pourra faire l’implémentation de notre code C# ainsi :

MaStructCSharp s = new MaStructCSharp();
s.age = 27;
s.taille = 185;
Inc(ref s);
Console.WriteLine(s.age);
Console.WriteLine(s.taille);

Voilà

J’en profite pour remercier Mike pour ses remarques constructives sur mon article

Tutoriel : Introduction à l’intéropérabilité (partie 2)

nico-pyright(c) — Sun, 28 Oct 2007 23:00:00 +0000

Je vous présente la deuxième partie de mon tutoriel d’introduction à l’intéropérabilité.

Vous apprendrez comment utiliser des structures C plus ou moins complexes dans un programme C#. Vous apprendrez aussi comment fonctionne COM Interop ainsi que le hosting de CLR afin d’utiliser des objets .Net dans une application native.

Aller au tutoriel d’introduction à l’intéropérabilité (partie 2)

Bonne lecture

L’avenir de visual c++ ?

nico-pyright(c) — Thu, 09 Aug 2007 19:00:00 +0000

Somasegar nous informe de l’orientation stratégique de Visual C++.

Comme on pouvait s’en douter, les priorités s’articulent autour de :

l’augmentation du support sur le développement natif
l’interop pour permettre a des applications natives d’accéder aux composants des framework.Net (WPF, WCF, …) que ce soit pour un relooking ou pour tirer parti des avancées du framework.
l’interop en tant que pont entre le monde managé et natif, pour tout ce qui est wrapper.

Des perspectives pour le C++/CLI, langage roi de l’intéropérabilité… et pour tout ce qui est natif, le C++ reste le langage de premier choix.

Comment intercepter des exceptions managées depuis du code natif ?

nico-pyright(c) — Tue, 07 Aug 2007 22:00:00 +0000

Des fois, il peut etre utile de pouvoir intercepter une exception managée à partir d’un code natif.

Soit le programme suivant qui simule, grace aux pragma unmanaged et managed, une intéraction entre un code natif et un code managé :

using namespace System;

void fonctionManagee()
{
throw gcnew Exception("Exception managée");
}

#pragma unmanaged
void fonctionNative()
{
fonctionManagee();
}
#pragma managed

int main()
{
fonctionNative();
return 0;
}

Si on exécute cet exemple, on obtient un crash de l’application à cause de la levée d’exception dans la méthode managée.

Le premier reflexe est d’utiliser un try catch … mais … quel type d’exception attraper ? Une solution pourrait être de tout attraper, avec une construction de ce genre :

void fonctionNative()
{
try
{
fonctionManagee();
}
catch (...)
{
std::cout << "N'importe quelle exception est attrapee, meme managee" << std::endl;
}
}

Cette construction a l’avantage de permettre d’intercepter l’exception levée dans la fonction managée depuis le code natif, mais a l’inconvénient de tout intercepter, à cause de la construction « … » suivant le catch.

La solution est d’utiliser un block try except, comme ci-dessous :

void fonctionNative()
{
__try
{
fonctionManagee();
}
__except(GetExceptionCode() == 0xE0434F4D ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
{
std::cout << "Uniquement les exceptions managees sont attrapees" << std::endl;
}
}

0xE0434F4D est le code d’erreur SEH correspond. (pour l’anectode, 0xE0434F4D correspond à 0xE0+ »COM » (= ‘àCOM’), car à l’origine, le CLR a été appelé COM+ 2.0. Le nom du projet a changé mais pas les codes d’exception)

L’inconvénient est qu’on ne peut pas avoir d’information sur l’exception, comme dans notre cas, le message d’exception levé.

Intéropérabilité de tableau dans une structure, le problème des tableaux à plusieurs dimensions

nico-pyright(c) — Fri, 29 Jun 2007 19:00:00 +0000

On vient de me poser une question :

je veux utiliser cette structure en C dans mon programme C#

typedef struct
{
int val;
int telfixe[10][2];
} MASTRUCTURETEL;

j’ai un peu modifié l’exemple pour que ce soit plus simple, mais la question porte sur le tableau à deux dimensions.

Alors, comment faire ?

Sur l’exemple de mes précédents billets, je vais créer une dll qui va exporter une fonction qui me retourne une structure :

typedef struct
{
int val;
int telfixe[10][2];
} MASTRUCTURETEL;

extern "C" __declspec(dllexport) MASTRUCTURETEL * GetUneStructure()
{
MASTRUCTURETEL *maStruct = new MASTRUCTURETEL;
for (int i = 0 ; i < 10 ; i++)
for (int j = 0; j < 2 ; j++)
maStruct->telfixe[i][j] = (i+1)*(j+1);
maStruct->val = 10;
return maStruct;
}

J’initialise mon tableau avec un peu n’importe quoi, mais bon voila, c’est exactement le tableau que je voulais avec les valeurs que je voulais :p

Maintenant, je veux pouvoir l’utiliser dans mon programme C#.

Il faut savoir que le marshaleur ne sait pas marshaler des tableaux multi-dimmensionnels, et donc que fatalement, nous allons récupérer un tableau à une seule dimension. Pour ce faire, on crée la structure C# ainsi :

[StructLayout(LayoutKind.Sequential)]
public class MaStructTelCSharp
{
public int val;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=10*2, ArraySubType=UnmanagedType.SysInt)]
public int[] telFixe;
}

L’important est de noter la taille du tableau dans le paramètre SizeConst de l’attribut MarshalAs. On lui précise aussi qu’on veut récupérer des entiers.

Puis, on récupère la structure ainsi :

[DllImport("testLib.dll")]
public static extern IntPtr GetUneStructure();

...
IntPtr maStructureCUnmanaged = GetUneStructure();
MaStructTelCSharp maStructureCSharp = new MaStructTelCSharp();
Marshal.PtrToStructure(maStructureCUnmanaged, maStructureCSharp);

Au final donc, on se retrouve avec une structure qui contient un tableau à une dimension au lieu d’un tableau à deux dimensions.
C’est triste mais c’est ainsi.

Rien ne vous empeche de reconstruire éventuellement un tableau à deux dimensions à partir de notre tableau à 1 dimension.

COM Interop – Conserver la signature des méthodes

nico-pyright(c) — Sun, 24 Jun 2007 19:32:15 +0000

Le billet précédent présente une méthode qui simplifie grandement l’écriture de notre programme natif qui utilise un objet managé via COM Interop.
La contrainte qu’il rajoute est la transformation des signatures des méthodes à la sauce COM.
Ainsi, une méthode :

String^ ReadLine();

sera wrappée en

HRESULT ReadLine(/*[out,retval]*/ BSTR);

Ce qui suggère l’utilisation de la macro SUCCEEDED pour tester la bonne marche de la fonction.

Mais pouvons-nous encore simplifier et se passer de ce type de signature ? On aimerait pouvoir avoir une signature du genre :

BSTR ReadLine();

Bref, conserver la signature de la méthode, aux types près …

Et bien c’est possible, grâce à un attribut disponible dans le namespace System::Runtime::CompilerServices.

Notre classe managée ne change pas d’écriture, mais l’interface sera écrite ainsi :

using namespace System::Runtime::CompilerServices;

namespace MonStreamReader
{
public interface class IClassWrap
{
[MethodImpl(MethodImplOptions::PreserveSig)]
void SetFile(String ^fileName);
[MethodImpl(MethodImplOptions::PreserveSig)]
bool Create();
[MethodImpl(MethodImplOptions::PreserveSig)]
String^ ReadLine();
};

public ref class ClassWrap : IClassWrap
{
.........
}
}

L’attribut PreserveSig, comme son nom le suggère un peu, permet de préserver la signature ; et au final de simplifier encore un brin le programme natif.

int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize(NULL);
MonStreamReader::IClassWrapPtr pClass(__uuidof(MonStreamReader::ClassWrap));
CComBSTR filePath = "c:\\test.txt";
pClass->SetFile(filePath);
if (pClass->Create())
{
CComBSTR line;
line = pClass->ReadLine();
while (line)
{
_bstr_t line_(line);
std::cout << line_ << std::endl;
line = pClass->ReadLine();
}
}
return 0;
}

Dingue ca, on dirait presque du C++/CLI :p, à part un ou deux BSTR qui trainent …

Un dernier petit truc : ne faites pas trop confiance à l’intellisense, il se débrouille pas trop mal, mais suite à quelques compilations, enregistrements, … dès fois, il pert un peu le nord. Heureusement que nous savons exactement ce que nous voulons faire

Wrapper de classes pour COM Interop, simplification et utilisation d’interfaces

nico-pyright(c) — Thu, 21 Jun 2007 00:19:38 +0000

Si vous êtes allé au bout du précédent billet, je vous félicite. Je rappelle que le but est de pouvoir utiliser un objet .net depuis notre exe natif pur et de passer des paramètres à son constructeur via un wrapper CLI.
Quand je re-regarde le code du billet, il me fait peur Tout ce code pour finalement si peu de choses…

N’y aurait-il pas moyen de faire plus simple ?

Forcément, si j’écris ca, c’est qu’il doit y avoir un moyen…

La solution est d’utiliser la capacité de visual studio à incorporer les tlb grâce à #import et à le convertir en classes C++.

Nous transformons notre précédente classe managée qui wrappe de manière simpliste le StreamReader pour faire en sorte que la classe implémente une interface :

using namespace System;
using namespace System::IO;

namespace MonStreamReader
{
public interface class IClassWrap
{
void SetFile(String ^fileName);
bool Create();
String^ ReadLine();
};

public ref class ClassWrap : IClassWrap
{
private:
String ^_fileName;
StreamReader ^sr;
protected:
!ClassWrap()
{
if (sr)
sr->Close();
}
public:
ClassWrap() {}
~ClassWrap()
{
this->!ClassWrap();
}
virtual void SetFile(String ^fileName)
{
_fileName = fileName;
}
virtual bool Create()
{
if (!String::IsNullOrEmpty(_fileName))
{
try
{
sr = gcnew StreamReader(_fileName);
return true;
}
catch (Exception ^)
{
sr = nullptr;
return false;
}
}
return false;
}
virtual String^ ReadLine()
{
if (sr)
return sr->ReadLine();
return nullptr;
} };
}

On génère le tlb, et on l’importe dans notre programme natif. Visual C++ va générer des classes et notamment une qui nous interesse IClassWrapPtr. C’est un smart pointer qui permet d’accèder à l’objet COM.

Il ne reste plus qu’à utiliser ce smart pointer pour appeler directement les méthodes de notre classe. Notez que les fonctions ont été relookées à la mode COM. On récupère un HRESULT et le retour de fonction se fait par un paramètre en sortie [out].

#include
#include

#import "..\debug\MonStreamReader.tlb" raw_interfaces_only

int _tmain(int argc, _TCHAR* argv[])
{
CoInitialize(NULL);
MonStreamReader::IClassWrapPtr pClass(__uuidof(MonStreamReader::ClassWrap));
CComBSTR filePath = "c:\\test.txt";
if (SUCCEEDED(pClass->SetFile(filePath)))
{
unsigned char resultBool;
if (SUCCEEDED(pClass->Create(&resultBool)))
{
if (resultBool)
{
CComBSTR line;
if (SUCCEEDED(pClass->ReadLine(&line)))
{
while (line)
{
_bstr_t line_(line);
std::cout << line_ << std::endl;
if (FAILED(pClass->ReadLine(&line)))
break;
}
}
}
}
}
return 0;
}

C’est quand même plus digeste !!
Notez l’utilisation de CComBstr pour passer des chaines qui seront marshalées en String^.net. Par contre, mon retour booleen donne un unsigned char.
Pour l’affichage, j’utilise également la classe _bstr_t qui dispose d’une surcharge de char *.

Vous pouvez télécharger le projet exemple.