union mot clé (RPC)

Certaines fonctionnalités du langage C, telles que les unions, nécessitent des mots clés MIDL spéciaux pour prendre en charge leur utilisation dans les appels de procédure distante. Une union dans le langage C est une variable qui contient des objets de différents types et tailles. Le développeur crée généralement une variable pour effectuer le suivi des types stockés dans l’union. Pour fonctionner correctement dans un environnement distribué, la variable qui indique le type de l’union, ou le discriminant, doit également être disponible pour l’ordinateur distant. MIDL fournit les mots clés [switch_type] et [switch_is] pour identifier le type et le nom discriminants.

MIDL exige que le discriminant soit transmis avec l’union de deux manières :

• L’union et le discriminant doivent être fournis en tant que paramètres.
• L’union et le discriminant doivent être emballés dans une structure.

Le MIDL fournit deux types fondamentaux de syndicats discriminatoires : nonencapsulated_union et encapsulated_union. Le discriminant d’une union non encapsulée est un autre paramètre si l’union est un paramètre. Il s’agit d’un autre champ si l’union est un champ d’une structure. La définition d’une union encapsulée est transformée en définition de structure dont le premier champ est le discriminant et dont les deuxième et dernier champs sont l’union. L’exemple suivant montre comment fournir l’union et le discriminant en tant que paramètres :

typedef [switch_type(short)] union 
{
    [case(0)]    short     sVal;
    [case(1)]    float     fVal;
    [case(2)]    char      chVal;
    [default]    ;
} DISCRIM_UNION_PARAM_TYPE;
 
short UnionParamProc(
    [in, switch_is(sUtype)] DISCRIM_UNION_PARAM_TYPE Union,
    [in] short sUtype);

L’union dans l’exemple précédent peut contenir une seule valeur : short, float ou char. La définition de type pour l’union inclut l’attribut MIDL switch_type qui spécifie le type du discriminant. Ici, [switch_type(short)] spécifie que le discriminant est de type short. Le commutateur doit être de type entier.

Si le syndicat est membre d’une structure, le discriminant doit être membre de la même structure. Si l’union est un paramètre, le discriminant doit être un autre paramètre. Le prototype de la fonction UnionParamProc dans l’exemple précédent montre le sUtype discriminant comme dernier paramètre de l’appel. (Le discriminant peut apparaître dans n’importe quelle position dans l’appel.) Le type du paramètre spécifié dans l’attribut [switch_is] doit correspondre au type spécifié dans l’attribut [switch_type].

L’exemple suivant illustre l’utilisation d’une structure unique qui empaquette le discriminant avec l’union :

typedef struct 
{
    short utype;  /* discriminant can precede or follow union */
    [switch_is(utype)] union 
    {
       [case(0)]   short     sVal;
       [case(1)]   float     fVal;
       [case(2)]   char      chVal;
       [default]   ;
    } u;
} DISCRIM_UNION_STRUCT_TYPE;
 
short UnionStructProc(
    [in] DISCRIM_UNION_STRUCT_TYPE u1);

Le compilateur MICROSOFT RPC MIDL autorise les déclarations d’union en dehors des constructions typedef . Cette fonctionnalité est une extension de DCE IDL. Pour plus d’informations, consultez union.