Atributo wire_marshal

  • Artigo

O atributo [wire_marshal] especifica um tipo de dados que será usado para transmissão (o tipo de transmissão) em vez de um tipo de dados específico do aplicativo (o tipo de usuário).

typedef [wire_marshal(wire_type)] type-specifier userm-type; 
unsigned long __RPC_USER  < userm-type >_UserSize(
    unsigned long __RPC_FAR *pFlags,
    unsigned long StartingSize,
    < userm-type > __RPC_FAR * pUser_typeObject );
unsigned char __RPC_FAR * __RPC_USER  < userm-type >_UserMarshal(
    unsigned long  __RPC_FAR * pFlags,
    unsigned char __RPC_FAR * Buffer,
    < userm-type >  __RPC_FAR * pUser_typeObject);
unsigned char __RPC_FAR * __RPC_USER  < userm-type >_UserUnmarshal(
    unsigned long  __RPC_FAR *  pFlags,
    unsigned char __RPC_FAR *  Buffer,
    < userm-type > __RPC_FAR * pUser_typeObject);
void __RPC_USER  < userm-type >_UserFree(
    unsigned long  __RPC_FAR * pFlags,
    < userm-type >  __RPC_FAR * pUser_typeObject);

Parâmetros

tipo de fio

Especifica o tipo de dados de transferência nomeado que, na verdade, é transferido entre o cliente e o servidor. O tipo de fio deve ser um tipo base MIDL, um tipo predefinido ou um identificador de tipo de um tipo que pode ser transmitido pela rede.

type-specifier

O tipo para o qual o tipo de usuário se tornará um alias.

userm-type

Especifica o identificador do tipo de dados do usuário a ser realizado em marshaling. Pode ser qualquer tipo, conforme fornecido pelo especificador de tipo, desde que tenha um tamanho bem definido. O tipo de usuário não precisa ser transmitível, mas deve ser um tipo conhecido pelo compilador MIDL.

pFlags

Especifica um ponteiro para um campo de sinalizador (longsem sinal). A palavra de alta ordem especifica sinalizadores de representação de dados NDR conforme definido pelo DCE para representação de ponto flutuante, big-or little-endian e caractere. A palavra de baixa ordem especifica um sinalizador de contexto de marshaling. O layout exato dos sinalizadores é descrito em A função type_UserSize.

StartingSize

Especifica o tamanho do buffer atual (deslocamento) antes de dimensionar o objeto.

pUser_typeObject

Especifica um ponteiro para um objeto de userm_type.

Buffer

Especifica o ponteiro do buffer atual.

Comentários

Cada tipo de dados específico do aplicativo, tipo de usuário, tem uma correspondência um-para-um com um tipo de fio que define a representação de transmissão do tipo. Você deve fornecer rotinas para dimensionar os dados para marshaling, realizar marshaling e cancelar a gravação dos dados e liberar memória. Observe que, se houver tipos inseridos em seus dados que também são definidos com [wire_marshal] ou [user_marshal], você também precisará gerenciar a manutenção desses tipos inseridos. Para obter mais informações sobre essas rotinas, consulte O atributo wire_marshal.

Sua implementação deve seguir as regras de marshaling de acordo com a especificação OSF-DCE. Detalhes sobre a sintaxe de transferência de NDR podem ser encontrados em https://www.opengroup.org/onlinepubs/9629399/chap14.htm. Não é recomendável usar [wire_marshal] se você não estiver familiarizado com o protocolo de transmissão.

O tipo de fio não pode ser um ponteiro de interface ou um ponteiro completo. O tipo de fio deve ter um tamanho de memória bem definido. Consulte Regras de marshaling para user_marshal e wire_marshal para obter detalhes sobre como realizar marshaling de um determinado tipo de transmissão.

O tipo de usuário não deve ser um ponteiro de interface porque eles podem ter marshaling diretamente. Se o tipo de usuário for um ponteiro completo, você deverá gerenciar o aliasing por conta própria.

Você não pode usar o atributo [wire_marshal] com o atributo [allocate] , direta ou indiretamente, porque o mecanismo NDR não controla a alocação de memória para o tipo transmitido.

Exemplos

typedef unsigned long _FOUR_BYTE_DATA;

typedef struct _TWO_X_TWO_BYTE_DATA 
{
        unsigned short low;
        unsigned short high;
} TWO_X_TWO_BYTE_DATA;

typedef [wire_marshal(TWO_X_TWO_BYTE_DATA)] 
    _FOUR_BYTE_DATA FOUR_BYTE_DATA; 

//Marshaling functions:

// Calculate size that converted data will 
// require in the buffer
unsigned long __RPC_USER FOUR_BYTE_DATA_UserSize( 
    ULONG __RPC_FAR * pulFlags, 
    ULONG __RPC_FAR ulStartingSize,
    FOUR_BYTE_DATA __RPC_FAR * pul);

// Copy FOUR_BYTE_DATA into buffer as 
// TWO_X_TWO_BYTE_DATA
unsigned long __RPC_USER FOUR_BYTE_DATA_UserMarshal( 
    ULONG __RPC_FAR *pulFlags, 
    char __RPC_FAR * pBufferStart, 
    FOUR_BYTE_DATA __RPC_FAR * pul);

// Recreate FOUR_BYTE_DATA from TWO_X_TWO_BYTE_DATA in buffer
unsigned long __RPC_USER FOUR_BYTE_DATA_UserUnmarshal( 
    ULONG __RPC_FAR * pulFlags, 
    char __RPC_FAR * pBufferStart, 
    FOUR_BYTE_DATA __RPC_FAR * pul);

// Nothing to do here as the engine frees the top 
// node and FOUR_BYTE_DATA is a flat data type.
void __RPC_USER FOUR_BYTE_DATA_UserFree( 
    ULONG __RPC_FAR * pulFlags, 
    FOUR_BYTE_DATA __RPC_FAR * pul 
    );

Confira também

Alocar

Representação de dados

Tipos base MIDL

Longas

NdrGetUserMarshalInfo

O atributo wire_marshal

transmit_as

Unsigned

user_marshal