Usar a interoperabilidade de C++ (PInvoke implícito)

Ao contrário de outros.NET idiomas, o 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 managed, unmanaged pragmas). Isso permite que os 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 compiland gerenciado que usa dllexport, dllimport.

Implicit PInvoke is useful when you do not need to specify how function parameters will be marshaled, or any of the other details that can be specified when explicitly calling DllImportAttribute.

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

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

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

Interoperabilidade de C++

Interoperabilidade de C++ é mais recomendada PInvoke explícito porque fornece melhor segurança de tipo, é geralmente menos entediante implementá, é mais complacente se a API não gerenciada é modificada e possibilita melhorias de desempenho que não são possíveis com o PInvoke explícita. No entanto, a interoperabilidade de C++ não é possível se o código de origem não gerenciada não estiver disponível ou quando compilando com /clr:safe (consulte 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 em particular sobre outros.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 o suporte limitado para tipos de dados e a exposição obrigatória de todos os membros de cada interface COM, interoperabilidade de C++ permite que os componentes COM para serem acessados à vontade e não requer assemblies de interoperabilidade separada. For more information, see Using Native COM Servers from .NET.

Tipos blittable

Para APIs não gerenciadas que usam tipos simples e intrínsecos (consulte Blittable e tipos de 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 que exigem o empacotamento de dados explícitos. For an example, see 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");
}

In This Section

• Como: Seqüências de caracteres ANSI Marshal usando a interoperabilidade de C++

• Como: Cadeias de caracteres do Unicode Marshal usando a interoperabilidade de C++

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

• Como: Interoperabilidade de C++ usando estruturas de empacotamento

• Como: Empacotar matrizes interoperabilidade de C++ usando

• Como: Retornos de chamada de empacotamento e delegados usando a interoperabilidade de C++

• Como: Empacotar os ponteiros incorporados usando a interoperabilidade de C++

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

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

• Como: Converter System:: String wchar_t * ou char *.

• Como: Converter System:: String para a seqüência de caracteres padrão

• Como: Converter a seqüência de caracteres padrão para System:: String

• Como: Obter um ponteiro para a 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 é nativos ou CLR

• Como: Adicionar a DLL nativa para o Cache de Assembly Global

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

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

• Como: Detectar /clr compilação

• Como: Converter entre System::Guid e _GUID

• Como: Especifique um limite parâmetro

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

• Como: Declare as alças de tipos nativos

• Como: Dispor de classe nativa para uso por C#

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

Consulte também

Conceitos

Chamar funções nativas do código gerenciado