Usando interoperabilidade C++ (PInvoke implícita)

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

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

PInvoke implícita é útil quando você não precisa especificar como parâmetros da função serão empacotados ou quaisquer outros detalhes que podem ser especificados ao chamar explicitamente DllImportAttribute.

Visual C++ fornece duas maneiras para funções gerenciadas e interoperar:

• Usando PInvoke Explicit no C++ (atributo DllImport)

PInvoke explícita é suportado pelo.NET Framework e está disponível na maioria.NET idiomas.Mas como seu nome implica, interoperabilidade de C++ é específica para Visual C++.

Interoperabilidade de C++

Interoperabilidade de C++ é recomendada pela PInvoke explícito porque fornece melhor segurança de tipos, é geralmente menos entediante implementar, é mais complacente se a API não gerenciada é modificada e possibilita aprimoramentos de desempenho que não são possíveis com PInvoke explícita.No entanto, interoperabilidade de C++ não é possível se o código não gerenciado não está disponível ou quando a compilação com /clr:safe (consulte Código puro e verificável (C + + / CLI) para obter mais informações).

Interoperabilidade de C++

Os recursos de interoperabilidade suportados pelo Visual C++ oferecem uma vantagem específica sobre outro.NET diferentes quando se trata de interoperar com componentes COM.Em vez de estar limitado a restrições da.NET Framework Tlbimp. exe (importador da biblioteca), como suporte limitado para tipos de dados e a exposição obrigatória de cada membro de cada interface COM, interoperabilidade de C++ permite que componentes COM sejam acessados à vontade e não requer assemblies de interoperabilidade separado.Para mais informações, consulte Using COM from .NET.

Tipos blittable

Para APIs não gerenciadas que usam tipos simples e intrínsecos (consulte Blittable e tipos 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 mais complexos exigem empacotamento de dados explícitos.Para um exemplo, consulte Como: chamar nativas DLLs de 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: Marshal ANSI Strings usando interoperabilidade de C++

• Como: Marshal Unicode seqüências de caracteres usando a interoperabilidade de C++

• Como: empacotamento COM seqüências de caracteres usando a interoperabilidade de C++

• Como: Marshal estruturas usando a interoperabilidade de C++

• Como: matrizes de empacotamento usando interoperabilidade de C++

• Como: empacotar retornos de chamada e delegados usando interoperabilidade de C++

• Como: empacotamento incorporado ponteiros com interoperabilidade de C++

• Como: caracteres de acesso em um System

• Como: converter char * String a matriz de System::Byte

• Como: converter System wchar_t * ou char *

• Como: converter seqüência padrão System

• Como: converter seqüência padrão para System

• Como: obter um ponteiro para matriz de bytes

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

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

• Como: determinar se uma imagem é nativo ou CLR

• Como: adicionar DLL nativo ao Cache de Assembly Global

• Como: manter a referência ao tipo de valor no tipo nativo

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

• Como: detectar /clr compilação

• Como: converter entre System::Guid e _GUID

• Como: especificar uma falta parâmetro

• Como: usar um tipo nativo em uma compilação /CLR.

• Como: Declare identificadores em tipos nativos

• Como: quebrar nativo classe para uso 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

Chamar funções nativas do código gerenciado