Blog de Nico-pyright(c)

26
septembre
2008

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

Un article de nico-pyright(c) Comments

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<char *>(Marshal::StringToHGlobalAnsi(value).ToPointer());
strcpy(s8_EncryptionKey, temp);
Marshal::FreeHGlobal(safe_cast<IntPtr>(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<String^, String^>^ 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<string, string> dictionary = new Dictionary<string, string>
{
{"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

Laisser un commentaire

Vous devez être connecté pour poster un commentaire.

Connexion

Identifiez-vous

Créer un compte

Blog de Nico-pyright(c)

Laisser un commentaire

Articles récents

Commentaires récents

Archives

Catégories

Méta

Identifiant
Mot de passe

Mot de passe oublié ?