Interop (Vorgehensweise in Visual C++)

Aktualisiert: November 2007

Diese Seite enthält Links zu Hilfethemen, die Aufgaben zu Interop in Visual C++ behandeln. Informationen zu weiteren Kategorien häufiger Aufgaben, die in der Hilfe behandelt werden, finden Sie unter Vorgehensweise in Visual C++.

Interoperabilität zwischen systemeigenem und CLR-Code

• Featurevergleich zwischen "gemischt", "rein" und "überprüfbar"
  Vergleicht die Features der drei unterschiedlichen /clr-Kompilierungsmodi.

• Gewusst wie: Migrieren auf /clr
  Behandelt Probleme, die beim Kompilieren von systemeigenem Code mit /clr und beim Konvertieren von Projekten in verwaltete Projekte auftreten.

• Gewusst wie: Kompilieren von MFC-Code und ATL-Code mit /clr
  Erläutert, wie vorhandene MFC- und ATL-Programme für die Common Language Runtime kompiliert werden können.

• Gemischte (systemeigene und verwaltete) Assemblys
  Beschreibt, wie Anwendungen mit einer Mischung aus verwalteter und nicht verwalteter Funktionalität erstellt werden können.

• Überlegungen zur Leistung von Interop (C++)
  Enthält Richtlinien zum Reduzieren der Auswirkungen von Interop-Übergängen zwischen verwalteten und nicht verwalteten Funktionen auf die Laufzeitleistung.

• How to: Declare public and private on Native Classes
  Veranschaulicht, wie von einem verwalteten Typ auf einen systemeigenen Typ verwiesen wird.

• How to: Pass a Delegate^ to a Native Function Expecting a Function Pointer
  Veranschaulicht, wie von einer verwalteten Komponente aus eine systemeigene Funktion mit Funktionszeigerparametern aufgerufen werden kann, wobei die systemeigene Funktion anschließend die Memberfunktion des Delegaten der verwalteten Komponente aufrufen kann.

• Gewusst wie: Zugriff auf Zeichen in einem System::String
  Veranschaulicht, wie Sie auf Zeichen eines String-Objekts zugreifen, um Hochleistungsaufrufe nicht verwalteter Funktionen auszuführen, die wchar_t*-Zeichenfolgen akzeptieren.

• Gewusst wie: Hinzufügen einer systemeigenen DLL zum globalen Assemblycache
  Beschreibt, wie eine systemeigene DLL (nicht COM) im globalen Assemblycache abgelegt wird.

• Gewusst wie: Konvertieren zwischen System::Guid und _GUID
  Beschreibt, wie zwischen Guid und _GUID konvertiert wird.

• Gewusst wie: Umwandeln von char * String nach System::Byte Array
  Veranschaulicht, dass die effizienteste Methode zur Umwandlung einer char *-Zeichenfolge in ein Byte-Array in der Verwendung der Marshal-Klasse besteht.

• Gewusst wie: Konvertieren einer Standardzeichenfolge nach System::String
  Beschreibt das Konvertieren einer Zeichenfolge aus der C++-Standardbibliothek (<string>) in String.

• Gewusst wie: Konvertieren von System::String zu Standardzeichenfolge
  Beschreibt das Konvertieren von String in eine Zeichenfolge aus der C++-Standardbibliothek (<string>).

• Gewusst wie: Umwandeln von System::String nach wchar_t* oder char*
  Erläutert die Verwendung von PtrToStringChars in Vcclr.h zum Konvertieren von String in das systemeigene wchar_t * oder char *.

• Gewusst wie: Deklarieren von Handles in systemeigenen Typen
  Zeigt, wie ein gcroot-Objekt auf dem systemeigenen Stapel erstellt wird.

• Gewusst wie: Ermitteln, ob ein Bild systemeigen oder CLR ist
  Veranschaulicht, wie Sie programmgesteuert überprüfen, ob ein Abbild für die Common Language Runtime erstellt wurde.

• Gewusst wie: Objektverweis in systemeigener Funktion
  Beschreibt, wie Sie gcroot.h verwenden, das GCHandle umschließt, um einen CLR-Objektverweis in nicht verwaltetem Arbeitsspeicher zu halten.

• Gewusst wie: Verweis auf Werttyp in systemeigenem Typ
  Beschreibt, wie Sie gcroot für geschachtelte Typen verwenden, um einen Verweis auf einen Werttyp in einem systemeigenen Typ zu implementieren.

• Gewusst wie: Abrufen eines Zeigers auf ein Byte-Array
  Beschreibt, wie Sie einen Zeiger auf den Array-Block in einem Byte-Array abrufen, indem Sie die Adresse des ersten Elements einem Zeiger zuweisen.

• Gewusst wie: Verwenden eines systemeigenen Typs in einer /clr-Kompilierung
  Beschreibt, wie Sie in einer /clr-Kompilierung einen systemeigenen Typ definieren, und erläutert Verwendungsmöglichkeiten des systemeigenen Typs innerhalb der Assembly.

• Gewusst wie: Kapseln einer systemeigenen Klasse zur Verwendung in C#
  Erläutert, wie eine systemeigene C++-Klasse umschlossen wird, um sie für Code in C# oder einer anderen .NET-Sprache verfügbar zu machen.

C++ Interop

• Gewusst wie: Marshallen von ANSI-Zeichenfolgen mit C++-Interop
  Veranschaulicht, wie C++ Interop zum Marshallen von ANSI-Zeichenfolgen zwischen verwaltetem und systemeigenem Code verwendet wird.

• Gewusst wie: Marshallen von Unicode-Zeichenfolgen mit C++-Interop
  Veranschaulicht, wie C++ Interop zum Marshallen von Unicode-Zeichenfolgen zwischen verwaltetem und systemeigenem Code verwendet wird.

• Gewusst wie: Marshallen von COM-Zeichenfolgen mit C++-Interop
  Veranschaulicht, wie C++ Interop zum Marshallen von COM-Zeichenfolgen zwischen verwaltetem und systemeigenem Code verwendet wird.

• Gewusst wie: Marshallen von Strukturen mit C++-Interop
  Veranschaulicht, wie C++ Interop zum Marshallen einer struct zwischen verwaltetem und systemeigenem Code verwendet wird.

• Gewusst wie: Marshallen von Arrays mit C++-Interop
  Veranschaulicht, wie C++ Interop zum Marshallen von Arrays zwischen verwaltetem und systemeigenem Code verwendet wird.

• Gewusst wie: Marshallen von Rückrufen und Delegaten mit C++-Interop
  Veranschaulicht, wie C++ Interop zum Marshallen von Rückrufen und Delegaten zwischen verwaltetem und systemeigenem Code verwendet wird.

• Gewusst wie: Marshallen von eingebetteten Zeigern mit C++-Interop
  Veranschaulicht, wie C++ Interop zum Marshallen eingebetteter Zeiger zwischen verwaltetem und systemeigenem Code verwendet wird.

• Gewusst wie: Angeben eines out-Parameters
  Veranschaulicht, wie ein Funktionsparameter als out-Parameter angegeben und die betreffende Funktion in einem C#-Programm aufgerufen wird.

COM-Interop

• Verwenden systemeigener .NET-COM-Server
  Beschreibt die verfügbaren Optionen für die Verwendung vorhandener COM-Komponenten aus .NET-Anwendungen sowie die Vor- und Nachteile des jeweiligen Ansatzes.

• Gewusst wie: Verwenden von systemeigenen COM-Servern mit TLBIMP
  Veranschaulicht, wie COM-Objekte mithilfe des Type Library Importer-Tool (Tlbimp.exe)-Tools in verwaltetem Code verwendet werden können.

• Gewusst wie: Verwenden von systemeigenen COM-Servern mit CRCWs
  Veranschaulicht, wie COM-Objekte mithilfe benutzerdefinierter, zur Laufzeit abrufbarer Wrapper in verwaltetem Code verwendet werden können.

• Verfügbarmachen von .NET Framework-Komponenten in COM
  Enthält verschiedene Tipps zum Schreiben von verwaltetem Code, der mit COM-Clients zusammenarbeitet.

P/Invoke

• Gewusst wie: Marshallen von Zeichenfolgen mit PInvoke
  Erläutert, wie systemeigene Funktionen, die Zeichenfolgen im C-Format entgegennehmen, mithilfe des CLR-Zeichenfolgentyps System.String unter Verwendung des Plattformaufrufs (P/Invoke) aufgerufen werden können.

• Gewusst wie: Aufrufen von systemeigenen DLLs in verwaltetem Code mithilfe von PInvoke
  Veranschaulicht, wie Funktionen, die in nicht verwalteten DLLs implementiert sind, in verwaltetem Code über Plattformaufrufe (P/Invoke) aufgerufen werden können.

• Gewusst wie: Marshallen von Strukturen mit PInvoke
  Erläutert, wie systemeigene Funktionen, die structs im C-Format entgegennehmen, unter Verwendung des Plattformaufrufs (P/Invoke) in verwaltetem Code aufgerufen werden können.

• Gewusst wie: Marshallen von Arrays mit PInvoke
  Erläutert, wie systemeigene Funktionen, die Arrays im C-Format entgegennehmen, unter Verwendung des Plattformaufrufs (P/Invoke) von verwaltetem Code aus aufgerufen werden können.

• Gewusst wie: Marshallen von Funktionszeigern mit PInvoke
  Erläutert, wie beim Aufruf nicht verwalteter Funktionen mithilfe des Plattformaufrufs (P/Invoke) anstelle von Funktionszeigern verwaltete Delegaten verwendet werden können.

• Gewusst wie: Marshallen eingebetteter Zeiger mit PInvoke
  Erläutert, wie eingebettete Zeiger mithilfe des Plattformaufrufs (P/Invoke) gemarshallt werden.

• Gewusst wie: Ändern der Verweisklasse in einer systemeigenen Funktion
  Veranschaulicht, wie Sie eine Verweisklasse mit einem CLR-Array an eine systemeigene Funktion übergeben können und die Klasse mithilfe der PInvoke-Dienste bearbeiten.

• Gewusst wie: Analysieren von Zeichenfolgen mithilfe von regulären Ausdrücken
  Beschreibt, wie Sie einen Zeiger auf den Array-Block in einem Byte-Array abrufen, indem Sie die Adresse des ersten Elements einem Zeiger zuweisen.

C++-Unterstützungsbibliothek

• Gewusst wie: Erweitern der Marshallingbibliothek
  Erläutert, wie die Marshallingbibliothek erweitert wird, um mehr Konvertierungen zwischen Datentypen bereitzustellen.

Verwenden von Windows Forms in MFC

• Verwenden eines Windows Form-Benutzersteuerelements in MFC
  Erklärt, wie Sie mit den Windows Forms-Unterstützungsklassen in MFC Windows Forms-Steuerelemente in MFC-Anwendungen als ActiveX-Steuerelemente in MFC-Dialogfeldern oder -Anzeigen hosten können.

• Unterschiede beim Programmieren mit Windows Forms und MFC
  Bietet Hintergrundinformationen über Unterschiede beim Programmieren von Windows Forms und MFC.

• Hosten eines Windows Form-Benutzersteuerelements als MFC-Dialogfeld
  Beschreibt, wie ein Windows Forms-Steuerelement mithilfe der CWinFormsDialog-Klasse als MFC-Dialogfeld gehostet wird.

• Gewusst wie: Erstellen des Benutzersteuerelements und Hosten der MDI-Ansicht
  Zeigt das Erstellen eines .NET Framework-Benutzersteuerelements und das Erstellen des Benutzersteuerelements in einer Steuerelementklassenbibliothek (ein Windows-Steuerelementbibliotheks-Projekt) sowie das Kompilieren des Projekts in eine Assembly.

• Gewusst wie: Hinzufügen von Befehlsrouting zum Windows Forms-Steuerelement
  Beschreibt, wie Sie mit CWinFormsView Befehle weiterleiten und Befehlsmeldungen der Benutzeroberfläche für das Benutzersteuerelement aktualisieren, damit dieses MFC-Befehle behandeln kann.

• Gewusst wie: Aufrufen von Ereignissen und Methoden des Windows Forms-Steuerelements
  Erklärt, warum es ratsam ist, einen Member des Typs Benutzersteuerelement hinzuzufügen und diesen in IView::OnInitialUpdate zu initialisieren.

• Hosten eines Windows Form-Benutzersteuerelements als MFC-Ansicht
  Beschreibt, wie ein Windows Forms-Benutzersteuerelement als MFC-Ansicht gehostet wird.

• Gewusst wie: Erstellen des Benutzersteuerelements und des Hosts in einem Dialogfeld
  Erklärt, wie Sie einem neuen, auf Dialogfeldern basierenden MFC-Projekt ein Benutzersteuerelement hinzufügen.

• Gewusst wie: DDX-/DDV-Datenbindung mit Windows Forms
  Zeigt, wie eine systemeigene C++-Zeichenfolge an ein .NET-Benutzersteuerelement gebunden wird.

• Gewusst wie: Auffangen von Windows Forms-Ereignissen aus systemeigenen C++-Klassen
  Zeigt, wie Sie mit systemeigenen C++-Klassen Rückrufe von verwalteten Ereignissen empfangen können, die von Windows Forms-Steuerelementen oder anderen Formularen mit dem MFC-Makrozuordnungsformat stammen. Das Auffangen von Ereignissen in Anzeigen und Dialogfeldern entspricht der Vorgehensweise bei Steuerelementen.

• Hosten eines Windows Form-Benutzersteuerelements in einem MFC-Dialogfeld
  Beschreibt, wie ein Windows Forms-Benutzersteuerelement in einem MFC-Dialogfeld gehostet wird.

• Gewusst wie: DDX-/DDV-Datenbindung mit Windows Forms
  Zeigt, wie eine systemeigene C++-Zeichenfolge an ein .NET-Benutzersteuerelement gebunden wird.

Siehe auch

Konzepte

Vorgehensweise in Visual C++