Usando interop C++ (PInvoke implícito)

Ao contrário de outros linguagens .NET, Visual C++ tem o suporte de interoperabilidade que permite que o código gerenciado e não gerenciados existir no mesmo aplicativo e até mesmo no mesmo arquivo (com os pragmas de gerenciado, não gerenciado ). Isso permite que os desenvolvedores do Visual C++ integrem a funcionalidade de .NET em aplicativos existentes do Visual C++ sem afetar o restante do aplicativo.

Você também pode chamar funções não gerenciados de um compiland gerenciado usando dllexport, dllimport.

PInvoke implícita é útil quando você não precisa especificar como os parâmetros de marshaling de função, ou qualquer um dos outros detalhes que podem ser especificadas ao chamar explicitamente DllImportAttribute.

Visual C++ fornece dois modos para que as funções gerenciados e não gerenciados interoperem:

• Usando PInvoke explícito em C++ (atributo DllImport)

PInvoke explícito tem suporte do.NET Framework e está disponível na maioria das linguagens .NET. Mas como seu nome, implica C++ Interoperabilidade é específico ao Visual C++.

Interoperabilidade C++

C++ Interoperabilidade é recomendado sobre PInvoke explícito porque fornece a melhor segurança de tipo, normalmente é menos fastidioso de implementá-los, é de perdão se a API não gerenciado é alterado, e torna aprimoramentos de desempenho possíveis que não é possível com PInvoke explícito. No entanto, C++ Interoperabilidade não é possível se o código-fonte não gerenciado não está disponível ou criar com /clr:safe (consulte Código puro e verificável (C++/CLI) para obter mais informações).

Interoperabilidade COM C++

Os recursos de interoperabilidade com suporte pelo Visual C++ oferecem uma vantagem específico em outras linguagens .NET quando se trata a interação com componentes COM. Em vez de restrição às limitações do .NET Framework Tlbimp.exe (Importador de Biblioteca de Tipos), como suporte limitado para tipos de dados e a possibilidade obrigatória de cada membro de cada interface COM, C++ Interoperabilidade permite que os componentes COM sejam acessados em e não requer assemblies separados de interoperabilidade. Para obter mais informações, consulte Using COM from .NET.

Tipos blittables

Para as APIs não gerenciado que usam tipos simples, intrínsecos (consulte Tipos blittable e não blittable), nenhuma codificação especial necessária porque esses tipos de dados têm a mesma representação na memória, mas os tipos de dados requerem mais complexos marshaling explícito de dados. Para ver um exemplo, consulte Como chamar DLLs nativas a partir do código gerenciado usando PInvoke.

Exemplo

// 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");
}

Nesta seção

• Como realizar marshaling de cadeias de caracteres ANSI usando interop C++

• Como realizar marshaling de cadeias de caracteres Unicode usando interop C++

• Como realizar marshaling de cadeias de caracteres COM usando interop C++

• Como realizar marshaling de estruturas usando interop C++

• Como realizar marshaling de matrizes usando interop C++

• Como realizar marshal de retornos de chamadas e delegados usando o C++ Interop

• Como realizar marshaling de ponteiros inseridos usando interop C++

• Como acessar caracteres em um System::String

• Como converter a cadeia de caracteres char * na matriz System::Byte

• Como converter System::String em wchar_t* ou char*

• Como converter System::String na cadeia de caracteres padrão

• Como converter cadeia de caracteres padrão em System::String

• Como obter um ponteiro para matriz de bytes

• Como carregar recursos não gerenciados em uma matriz de bytes

• Como modificar classe de referência em uma função nativa

• Como determinar se uma imagem é nativa ou CLR

• Como adicionar DLL nativo ao cache de assembly global

• Como manter a referência para tipo de valor em tipo nativo

• Como manter referência de objeto na memória não gerenciada

• Como detectar a compilação /clr

• Como fazer uma conversão entre System::Guid e _GUID

• Como especificar um parâmetro out

• Como usar um tipo nativo em uma compilação /clr

• Como declarar identificadores em tipos nativos

• Como encapsular classe nativa a ser usada por C#

Para obter informações sobre como usar delegados em um cenário de interoperabilidade, consulte delegado (Extensões de Componentes C++).

Consulte também

Conceitos

Chamando funções nativas a partir do código gerenciado