Comment : marshaler des chaînes ANSI à l’aide de l’interopérabilité C++

Cette rubrique montre comment les chaînes ANSI peuvent être passées à l’aide de L’interopérabilité C++, mais le .NET Framework String représente des chaînes au format Unicode, de sorte que la conversion en ANSI est une étape supplémentaire. Pour interagir avec d’autres types de chaînes, consultez les rubriques suivantes :

• Guide pratique pour marshaler des chaînes Unicode à l’aide de l’interopérabilité C++

• Guide pratique pour marshaler des chaînes COM à l’aide de l’interopérabilité C++

Les exemples de code suivants utilisent les directives de #pragma managées non managées pour implémenter des fonctions managées et non managées dans le même fichier, mais ces fonctions interagissent de la même manière si elles sont définies dans des fichiers distincts. Étant donné que les fichiers contenant uniquement des fonctions non managées n’ont pas besoin d’être compilés avec /clr (Compilation Common Language Runtime), ils peuvent conserver leurs caractéristiques de performances.

Exemple : Passer une chaîne ANSI

L’exemple illustre le passage d’une chaîne ANSI d’une fonction managée à une fonction non managée à l’aide StringToHGlobalAnside . Cette méthode alloue de la mémoire sur le tas non managé et retourne l’adresse après avoir effectué la conversion. Cela signifie qu’aucune épinglage n’est nécessaire (car la mémoire sur le tas GC n’est pas transmise à la fonction non managée) et que l’IntPtr retourné StringToHGlobalAnsi doit être explicitement libéré ou un résultat de fuite de mémoire.

// MarshalANSI1.cpp
// compile with: /clr
#include <iostream>
#include <stdio.h>

using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;

#pragma unmanaged

void NativeTakesAString(const char* p) {
   printf_s("(native) received '%s'\n", p);
}

#pragma managed

int main() {
   String^ s = gcnew String("sample string");
   IntPtr ip = Marshal::StringToHGlobalAnsi(s);
   const char* str = static_cast<const char*>(ip.ToPointer());

   Console::WriteLine("(managed) passing string...");
   NativeTakesAString( str );

   Marshal::FreeHGlobal( ip );
}

Exemple : Marshaling de données requis pour accéder à la chaîne ANSI

L’exemple suivant illustre le marshaling de données requis pour accéder à une chaîne ANSI dans une fonction managée appelée par une fonction non managée. La fonction managée, lors de la réception de la chaîne native, peut l’utiliser directement ou la convertir en chaîne managée à l’aide de la PtrToStringAnsi méthode, comme indiqué.

// MarshalANSI2.cpp
// compile with: /clr
#include <iostream>
#include <vcclr.h>

using namespace std;

using namespace System;
using namespace System::Runtime::InteropServices;

#pragma managed

void ManagedStringFunc(char* s) {
   String^ ms = Marshal::PtrToStringAnsi(static_cast<IntPtr>(s));
   Console::WriteLine("(managed): received '{0}'", ms);
}

#pragma unmanaged

void NativeProvidesAString() {
   cout << "(native) calling managed func...\n";
   ManagedStringFunc("test string");
}

#pragma managed

int main() {
   NativeProvidesAString();
}

Voir aussi

Utilisation de l’interopérabilité C++ (PInvoke implicite)