Minha intenção é apresentar alguns conceitos sobre as técnicas de integração entre código .NET e código dentro da plataforma Microsoft Windows. Um fator importante é de que não vou levantar razões arquiteturais que levam a necessidade existir um sistema composto por mais de uma linguagem de programação.
Então, vamos lá, quando é necessário integrar aplicações desenvolvidas em Visual C++ e .NET existem duas possibilidades (até o momento). A primeira é a utilização de um recurso conhecido como PInvoke que permite o código .NET acessar diretamente funções de uma DLL escrita em VC++. E também há possibilidade de utilizar a linguagem Visual C++.NET, também conhecido como C++/CLI, e escrever código misto.
Ambos os modelos trazem vantagens e desvantagens, então logo vamos tentar identificar qual recurso se encaixa nas necessidades e características de um ambiente. Ah sim, como o assunto é extenso vou dividir ele em algumas partes. A seguir a primeira parte que é o básico do PInvoke.
Parte I - Básico do PInvoke
Vamos começar pela codificação para termos um pouco mais de ação por aqui. A seguir o código básico em VC++ para gerar uma DLL Win32 com uma função, que criativamente chamei de AddTwoIntegers. Use o wizard do Visual Studio para criar uma DLL. Na figura 1 está o código gerado pelo Visual Studio (método DllMain) e também há o método que será executado através do código .NET.
O método AddTwoIntegers é muito simples para que seja possível apresentar todos os elementos que compõem a integração através do PInvoke. É importante não esquecer-se de adicionar ao seu projeto VC++ um arquivo .def, como o da figura 2.
Este arquivo serve que para que no momento que a DLL é carregada pelo código .NET as devidas funções estejam visíveis e acessíveis. Para notar a diferença basta compilar sua DLL sem o arquivo .def e abrir-lá com o dependency walker como na figura 3 e notar que não há nenhuma funções exporta para acesso.
Já na figura 4 é possível perceber que o método AddTwoIntegers está disponível .
Agora que temos DLL Win32 compilada e exportando corretamente o método que queremos, vamos para a utilização da DLL pelo .NET. Note que na figura 4 a primeira instrução é using System.Runtime.InteropServices para que seja possível utilizar todos os membros desse namespace.
Então é definida a carga da DLL através do atributo DllImport, onde os parâmetros passados são:
“Unmanaged.dll”: path completo para a DLL a ser carregada. Como foi definido apenas o nome da DLL ela será carregada da pasta onde estiver o executável.
EntryPoint = ”AddTwoIntegers”: Método exportado pela DLL.
CharSet = CharSet.Auto: Defini como as sequências de caracteres são exportados, valores possível Ansi ou Unicode. Defini como Auto para que a plataforma decida qual o tipo adequado.
CallingConvention = CallingConvention.Cdecl: padrão para chamada do método. Vulgarmente isto infere na maneira como a plataforma vai empilhar a chamado do método na heap.
Após a definição do atributo e seus parâmetros é necessário definir a assinatura do método através de: public static extern. Para o primeiro exemplo estamos utilizando apenas dois int basta copiar a assinatura do código não gerenciado.
O método NativeAdd, da figura 5, defini um método que outras classes .NET possam acessar o método importado da DLL servindo como um wrapper. Este foi o ultimo passo agora basta fazer um aplicativo para teste como na figura 6 e verificar o funcionamento.
Nenhum comentário:
Postar um comentário