wire_marshal (attribut)

  • Article

L’attribut [wire_marshal] spécifie un type de données qui sera utilisé pour la transmission (type de fil) au lieu d’un type de données spécifique à l’application (le type userm).

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);

Paramètres

wire-type

Spécifie le type de données de transfert nommé qui est effectivement transféré entre le client et le serveur. Le type de câble doit être un type de base MIDL, un type prédéfini ou un identificateur de type d’un type qui peut être transmis sur le réseau.

type-specifier

Type pour lequel userm-type deviendra un alias.

userm-type

Spécifie l’identificateur du type de données utilisateur à marshaler. Il peut s’agir de n’importe quel type, tel qu’indiqué par le spécificateur de type, tant qu’il a une taille bien définie. Le type userm n’a pas besoin d’être transmissible, mais doit être un type connu du compilateur MIDL.

pFlags

Spécifie un pointeur vers un champ d’indicateur ( long non signé). Le mot d’ordre supérieur spécifie les indicateurs de représentation des données de remise de remise tels que définis par DCE pour la représentation à virgule flottante, big-endian ou little-endian et la représentation de caractères. Le mot d’ordre inférieur spécifie un indicateur de contexte de marshaling. La disposition exacte des indicateurs est décrite dans La fonction type_UserSize.

StartingSize

Spécifie la taille actuelle de la mémoire tampon (décalage) avant le dimensionnement de l’objet.

pUser_typeObject

Spécifie un pointeur vers un objet de userm_type.

Buffer

Spécifie le pointeur de mémoire tampon actuel.

Notes

Chaque type de données spécifique à l’application, userm-type, a une correspondance un-à-un avec un type de fil qui définit la représentation filaire du type. Vous devez fournir des routines pour dimensionner les données à des fins de marshaling, de marshaler et de démarshaler les données et de libérer de la mémoire. Notez que s’il existe des types incorporés dans vos données qui sont également définis avec [wire_marshal] ou [user_marshal], vous devez également gérer la maintenance de ces types incorporés. Pour plus d’informations sur ces routines, consultez Attribut wire_marshal.

Votre implémentation doit suivre les règles de marshaling conformément à la spécification OSF-DCE. Pour plus d’informations sur la syntaxe de transfert NDR, consultez https://www.opengroup.org/onlinepubs/9629399/chap14.htm. Il n’est pas recommandé d’utiliser [wire_marshal] si vous n’êtes pas familiarisé avec le protocole de connexion.

Le type de câble ne peut pas être un pointeur d’interface ou un pointeur complet. Le type de câble doit avoir une taille de mémoire bien définie. Pour plus d’informations sur le marshaling d’un type de câble donné, consultez Marshaling Rules for user_marshal and wire_marshal.

Le type utilisateur ne doit pas être un pointeur d’interface, car il peut être marshalé directement. Si le type d’utilisateur est un pointeur complet, vous devez gérer l’alias vous-même.

Vous ne pouvez pas utiliser l’attribut [wire_marshal] avec l’attribut [allocate], directement ou indirectement, car le moteur de remise de remise ne contrôle pas l’allocation de mémoire pour le type transmis.

Exemples

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 
    );

Voir aussi

Allouer

Représentation des données

MIDL Base Types

Long

NdrGetUserMarshalInfo

Attribut wire_marshal

transmit_as

Unsigned

user_marshal