Verwenden von C++-Interop (implizites PInvoke)

Im Gegensatz zu anderen .NET-Sprachen verfügt Visual C++ über eine Interoperabilitätsunterstützung, dank der verwalteter und nicht verwalteter Code in derselben Anwendung und sogar in derselben Datei verwendet werden können (mit den verwaltet, nicht verwaltet-Pragmas).Auf diese Weise können Visual C++-Entwickler .NET-Funktionalität in vorhandene Visual C++-Anwendungen integrieren, ohne den Rest der Anwendung zu beeinträchtigen.

Mit dllexport, dllimport können Sie außerdem nicht verwaltete Funktionen aus einer verwalteten Kompiliereinheit aufrufen.

Implizites PInvoke ist sinnvoll, wenn Sie das Marshalling von Funktionsparametern oder andere Details, die bei einem expliziten Aufruf von DllImportAttribute angegeben werden können, nicht festlegen müssen.

Visual C++ bietet zwei Möglichkeiten für die Interoperation von verwalteten und nicht verwalteten Funktionen:

• Verwenden von explizitem PInvoke in C++ (DllImport-Attribut)

Explizites PInvoke wird von .NET Framework unterstützt und ist in den meisten .NET-Sprachen verfügbar.Doch wie der Name schon sagt, ist C++-Interop Visual C++-spezifisch.

C++ Interop

C++-Interop wird gegenüber explizitem PInvoke empfohlen, da es bessere Typsicherheit bietet, normalerweise einfacher zu implementieren ist, sich bei Änderungen der nicht verwalteten API leichter handhaben lässt und Leistungsverbesserungen erlaubt, die mit explizitem PInvoke nicht möglich sind.C++-Interop kann jedoch nicht verwendet werden, wenn der nicht verwaltete Quellcode nicht verfügbar ist oder die Kompilierung mit /clr:safe durchgeführt wird (weitere Informationen finden Sie unter Reiner und überprüfbarer Code (C++/CLI)).

C++-COM-Interop

Die von Visual C++ unterstützten Interoperabilitätsfeatures bieten einen besonderen Vorteil gegenüber anderen .NET-Sprachen, wenn es um die Interoperation mit COM-Komponenten geht.Da es nicht durch die Einschränkungen der .NET Framework-Tlbimp.exe (Type Library Importer-Tool) beschränkt ist, z. B. durch beschränkte Unterstützung für Datentypen und das obligatorische Verfügbarmachen jedes einzelnen Members der einzelnen COM-Schnittstellen, kann mit C++-Interop beliebig auf COM-Komponenten zugegriffen werden, ohne dass separate Interop-Assemblys erforderlich sind.Weitere Informationen finden Sie unter Using COM from .NET.

Blitfähige Typen

Bei nicht verwalteten APIs, die einfache, systeminterne Typen verwenden (siehe Blitfähige und nicht blitfähige Typen), ist keine spezielle Codierung erforderlich, da diese Datentypen im Arbeitsspeicher auf dieselbe Weise dargestellt werden, während komplexere Datentypen ein explizites Datenmarshalling erfordern.Ein entsprechendes Beispiel finden Sie unter Gewusst wie: Aufrufen von systemeigenen DLLs in verwaltetem Code mithilfe von PInvoke.

Beispiel

// vcmcppv2_impl_dllimp.cpp
// compile with: /clr:pure user32.lib
using namespace System::Runtime::InteropServices;

// Implicit DLLImport specifying calling convention
extern "C" int __stdcall MessageBeep(int);

// explicit DLLImport needed here to use P/Invoke marshalling because
// System::String ^ is not the type of the first parameter to printf
[DllImport("msvcrt.dll", EntryPoint = "printf", CallingConvention = CallingConvention::Cdecl,  CharSet = CharSet::Ansi)]
// or just
// [DllImport("msvcrt.dll")]
int printf(System::String ^, ...); 

int main() {
   // (string literals are System::String by default)
   printf("Begin beep\n");
   MessageBeep(100000);
   printf("Done\n");
}

In diesem Abschnitt

• Gewusst wie: Marshallen von ANSI-Zeichenfolgen mit C++-Interop

• Gewusst wie: Marshallen von Unicode-Zeichenfolgen mit C++-Interop

• Gewusst wie: Marshallen von COM-Zeichenfolgen mit C++-Interop

• Gewusst wie: Marshallen von Strukturen mit C++-Interop

• Gewusst wie: Marshallen von Arrays mit C++-Interop

• Gewusst wie: Marshallen von Rückrufen und Delegaten mit C++-Interop

• Gewusst wie: Marshallen von eingebetteten Zeigern mit C++-Interop

• Gewusst wie: Zugriff auf Zeichen in einem System::String

• Gewusst wie: Umwandeln von char * String nach System::Byte Array

• Gewusst wie: Umwandeln von System::String nach wchar_t* oder char*

• Gewusst wie: Konvertieren von System::String zu Standardzeichenfolge

• Gewusst wie: Konvertieren einer Standardzeichenfolge nach System::String

• Gewusst wie: Abrufen eines Zeigers auf ein Byte-Array

• Gewusst wie: Laden von nicht verwalteten Ressourcen in ein Byte-Array

• Gewusst wie: Ändern der Verweisklasse in einer systemeigenen Funktion

• Gewusst wie: Ermitteln, ob ein Bild systemeigen oder CLR ist

• Gewusst wie: Hinzufügen einer systemeigenen DLL zum globalen Assemblycache

• Gewusst wie: Verweis auf Werttyp in systemeigenem Typ

• Gewusst wie: Objektverweis in nicht verwaltetem Arbeitsspeicher

• Gewusst wie: Erkennen der /clr-Kompilierung

• Gewusst wie: Konvertieren zwischen System::Guid und _GUID

• Gewusst wie: Angeben eines out-Parameters

• Gewusst wie: Verwenden eines systemeigenen Typs in einer /clr-Kompilierung

• Gewusst wie: Deklarieren von Handles in systemeigenen Typen

• Gewusst wie: Kapseln einer systemeigenen Klasse zur Verwendung in C#

Informationen über die Verwendung von Delegaten in einem Interop-Szenario finden Sie unter Delegat.

Siehe auch

Konzepte

Aufrufen systemeigener Funktionen aus verwaltetem Code