Exemplo de Wrapper para Invocação de Plataforma

Se uma estrutura contém tipos simples, ela poderá ser passada para uma função nativa.A rotina nativa precisa obedecer às maneiras como o .NET Compact Framework empacota a estrutura.

Considere um nativo função chamada DoRequest que aceita um parâmetro, um ponteiro para uma estrutura. A estrutura define dois campos:

• Uma matriz de caracteres contendo uma sequência ANSI finalizada por NULL.

• Um inteiro.

Aqui está a estrutura em C++:

typedef struct 
{
    char *RequestName,
    int   Count,
} ALERT_REQUEST;

int DoAlertRequest(ALERT_REQUEST *pRequest);

Sua versão gerenciada correspondente no C# é:

struct AlertRequest
{
    String RequestName;
    int    Count;
}

class AlertClass
{
    [DLLImport("ALERT.DLL", EntryPoint="DoAlertRequest", 
        CharSet=CharacterSet.Ansi)]
    public static extern int DoRequest(ref AlertRequest Req);
}

The DllImportAttribute atributo anota os metadados de telefonar do método nativo. Ele notifica o Common linguagem tempo de execução que o DoRequest método está em alerta.dll, que é o nome do método DoAllertRequeste para realizar realizar marshaling strings para ANSI porque todas as strings no código gerenciado são strings de caracteres Unicode.

Uma chamada para este método em C++ no .Net Framework pode se parecer com isso:

AlertRequest Request = new AlertRequest()
Request.RequestName = "beep";
Request.Count = 10;
AlertClass.DoRequest(ref Request);

Quando common linguagem tempo de execução do .NET Framework encontrar o DoRequest, chamá-lo dinamicamente carrega alerta.dll, obtém o endereço de DoAlertRequest, constrói uma versão não gerenciada da estrutura convertendo strings sistema autônomo necessário, empurra um ponteiro para essa estrutura e chamadas DoAlertRequest. Ele apenas não é possível passar um ponteiro para a estrutura porque ele contém um incorporados String objeto.

Dadas essas restrições, o nativo DoRequest método não pode ser chamado diretamente. Em vez disso, uma telefonar intermediária de conversão (thunking) deve embalar DoRequest. O seguinte código C# é um exemplo:

class AlertClass
{
    [DllImport("ALERT.DLL", EntryPoint="DoAlertRequestThunk")]
    private static extern int DoRequestThunk(String RequestName, int Count);

    public static int DoRequest(ref AlertRequst Req)
        {
            return DoRequestThunk(Req.RequestName, Req.Count);
        }
}

AlertClass ainda contém um método com a mesma assinatura sistema autônomo sua contraparte no .NET estrutura. O.NET Compact estrutura DoRequest é uma rotina gerenciada que chama uma particular nativo rotina. Observe que os campos da estrutura foram divididos em argumentos separados na telefonar para a rotina nativa porque o String objeto dentro da estrutura não seria empacotado. A conversão intermediária ajusta a nativoDoRequest. Ele cria uma versão não gerenciada da estrutura e executa a conversão de string, conforme mostrado aqui em C++:

int DoRequestThunk(wchar_t *RequestNameW, int Count)
{
    ALERT_REQUEST Req;
    int ReturnCode;
       
    // CreateAnsiFromUnicodeString allocates and builds an ANSI
    // version of the Unicode string.
    Req.RequestName = CreateAnsiFromUnicodeString(RequestNameW);
    if (Req.RequestName == NULL) 
        Return 0;

    Req.Count = Count;

    // This is the native DoRequest, not to be confused
    // with the managed method of the same name.
    ReturnCode = DoAlertRequest(&Req);

    free(Req.RequestName)
    return ReturnCode;
}

Consulte também

Outros recursos

Suporte a invocação de plataforma