Usando a interoperabilidade de C++ (PInvoke implícita)

Ao contrário das linguagens. NET Outros, 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 funcionalidade do .NET em aplicativos existentes do Visual C++ sem perturbar o restante do aplicativo.

Também é possível chamar funções não gerenciadas um compiland gerenciado usando dllexport, DllImport.

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

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

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

PInvoke explícita é suportado pelo .NET estrutura e está disponível na maioria das linguagens. NET.Mas sistema autônomo seu nome indica, interoperabilidade de C++ é específica para o Visual C++.

Interoperabilidade de C++

Interoperabilidade de C++ é mais recomendada PInvoke explícito porque ele fornece melhor segurança de tipos, é geralmente menos entediante implementar, é mais complacente se a API não gerenciada é modificada e possibilita melhorias 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-fonte não gerenciada não estiver disponível ou durante a compilação de /clr:safe (consulte a Código puro e verificável Para obter mais informações).

Interoperabilidade de COM do C++

Os recursos de interoperabilidade suportados pelo Visual C++ oferecem uma vantagem específica sobre outras linguagens .NET quando se trata de interoperar com componentes COM.Em vez de estar limitado às restrições do.NET estrutura Tipo Biblioteca Importer (Tlbimp.exe), sistema autônomo 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 de COM sejam acessados à vontade e não requer assemblies de interoperabilidade separado. Para obter mais informações, consulte Usando servidores nativo COM do .NET.

Tipos blittable

Para APIs não gerenciadas que usam tipos simples e intrínsecos (consulte Blittable e tipos blittable não), nenhuma codificação especial é necessária porque esses tipos de dados têm a mesma representação na memória, mas tipos de dados mais complexos exigem o marshaling de dados explícito. Para um exemplo, consulte Como: Chamar nativo DLLs 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");
}

Begin beep Done

Nesta seção

• Como: realizar realizar marshaling o ANSI strings usando interoperabilidade C++

• Como: realizar realizar marshaling o Unicode Strings usando interoperabilidade C++

• Como: realizar realizar marshaling COM strings usando interoperabilidade C++

• Como: realizar marshaling Estruturas usando a interoperabilidade de C++

• Como: realizar realizar marshaling matrizes interoperabilidade de C++ usando

• Como: realizar realizar marshaling Callbacks e delegados usando interoperabilidade C++

• Como: realizar realizar marshaling ponteiros Embedded usando interoperabilidade C++

• Como: Caracteres de acesso em um sistema::String

• Como: Converter char * string a matriz sistema::Byte

• Como: Converter sistema::String wchar_t * ou char *

• Como: Converter sistema::String em cadeia de caracteres padrão

• Como: Converter string padrão sistema::String

• Como: Obter um ponteiro para matriz de byte

• Como: Carregar recursos não gerenciados em uma matriz de byte

• Como: Modificar a classe de referência em uma função nativo

• Como: Determinar se uma imagem é nativo ou CLR

• Como: Adicionar DLL nativo para cache de assembly global

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

• Como: Segure referência de objeto função nativo

• Como: Detectar /clr compilação

• Como: Converter entre sistema::Guid e _GUID

• Como: Especifique uma falta parâmetro

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

• Como: Declarar Handles em tipos nativo

• Como: Classe nativo a encapsular de uso por translation from VPE for Csharp

Para obter informações sobre como usar delegados em um cenário de interoperabilidade, consulte Delegar.

Consulte também

Conceitos

Chamando funções nativo código gerenciado