Blog de Nico-pyright(c)

1
juin
2007

Interopérabilité C avec C#, utilisation de structures natives (c++ interop) (suite)

Un article de nico-pyright(c) Comments

Suite à mon billet d’interopérabilité pour marshaller des structures natives, on va compliquer un peu la structure pour voir différents scénarios d’interopérabilité.

Prenons les structures suivantes :

typedef struct {
int telfixe;
int telPort;
} MASTRUCTURETEL;

typedef struct {
int monAge;
int maTaille;
char *nom;
MASTRUCTURETEL structTel;
wchar_t *prenom;
} MASTRUCTURE;

On a donc une structure qui contient des entiers, une chaine (char *), une autre chaine (wchar_t *) et une structure qui contient elle même des entiers.

et maintenant, la fonction qui remplie la structure et retourne un pointeur.

extern "C" __declspec(dllexport) MASTRUCTURE * GetUneStructure()
{
MASTRUCTURE *maStruct = new MASTRUCTURE;
maStruct->maTaille = 185;
maStruct->monAge = 27;
maStruct->nom = new char[20];
maStruct->prenom = new wchar_t[20];
strcpy_s(maStruct->nom, 20, "pyright");
wcscpy_s(maStruct->prenom, 20, L"nico");
maStruct->structTel.telfixe = 123;
maStruct->structTel.telPort = 456;
return maStruct;
}

Reste maintenant à mapper cette structure un peu plus complexe en C# :

[StructLayout(LayoutKind.Sequential)]
public class MaStructCSharp
{
public Int32 monAge;
public Int32 maTaille;
public IntPtr nom;
public MaStructCSharpTel maStructTel;
public IntPtr prenom;
}
[StructLayout(LayoutKind.Sequential)]
public class MaStructCSharpTel
{
public Int32 telFixe;
public Int32 telPort;
}

Finalement, ce n’est pas si compliqué, les entiers deviennent des Int32, les chaines deviennent des IntPtr et la sous-structure une classe.

On reprend le même principe pour remplir la classe avec le pointeur sur la structure :

IntPtr maStructureCUnmanaged = GetUneStructure();
MaStructCSharp maStructureCSharp = new MaStructCSharp();
Marshal.PtrToStructure(maStructureCUnmanaged, maStructureCSharp);
Console.WriteLine(maStructureCSharp.monAge);
Console.WriteLine(maStructureCSharp.maTaille);
Console.WriteLine(maStructureCSharp.maStructTel.telFixe);
Console.WriteLine(maStructureCSharp.maStructTel.telPort);

Notez que pour la sous-structure, il n’y a rien de particulier à faire.

Viennent maintenant les chaines, on va utiliser des méthodes de la classe Marshal pour les convertir :

string nom = Marshal.PtrToStringAnsi(maStructureCSharp.nom);
Console.WriteLine(nom);
string prenom = Marshal.PtrToStringUni(maStructureCSharp.prenom);
Console.WriteLine(prenom);

PtrToStringAnsi pour convertir le char * et PtrToStringUni pour convertir le wchar_t *.

Assez simple globalement, mais les conversions de chaines sont assez lourdes. On est obligé de passer par un pointeur puis de le convertir, en utilisant une autre variable.

N’y aurait-il pas un moyen d’avoir directement des chaines C# dans notre structure plutot que des pointeurs et d’être obligé de convertir ?
Bien sur que si, la classe de marshal propose des attributs pour effectuer directement des opérations de marshaling sur des types qui ont un équivalent simple en C#.
Par exemple pour des chaines wchar_t *, on aura la strucure C :

typedef struct {
wchar_t *nom;
wchar_t *prenom;
} MASTRUCTURE;

dont l’équivalent sera

[StructLayout(LayoutKind.Sequential)]
public class MaStructCSharp
{
[MarshalAs(UnmanagedType.LPWStr)]
public string nom;
[MarshalAs(UnmanagedType.LPWStr)]
public string prenom;
}

On déclare directement des string et on utilise l’attribut MarshalAs et on précise le type, ici on va utiliser le paramètre UnmanagedType.LPWStr.
On pourra désormais récupérer les noms et prénoms ainsi :

Le code s’en trouve clarifié.

Voilà pour ces concepts d’interopérabilité

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é ?