Parola chiave union (RPC)

Alcune funzionalità del linguaggio C, ad esempio le unioni, richiedono parole chiave MIDL speciali per supportare l'uso nelle chiamate di procedura remota. Un'unione nel linguaggio C è una variabile che contiene oggetti di tipi e dimensioni diversi. Lo sviluppatore crea in genere una variabile per tenere traccia dei tipi archiviati nell'unione. Per funzionare correttamente in un ambiente distribuito, la variabile che indica il tipo di unione o il discriminante, deve essere disponibile anche per il computer remoto. MIDL fornisce le parole chiave [switch_type] e [switch_is] per identificare il tipo e il nome discriminanti.

MIDL richiede che la discriminante venga trasmessa con l'unione in uno dei due modi seguenti:

• L'unione e il discriminante devono essere forniti come parametri.
• L'unione e il discriminante devono essere inseriti in una struttura.

Due tipi fondamentali di unioni discriminate sono forniti da MIDL: nonencapsulated_union e encapsulated_union. Il discriminante di un'unione non incapsulata è un altro parametro se l'unione è un parametro. È un altro campo se l'unione è un campo di una struttura. La definizione di un'unione incapsulata viene trasformata in una definizione di struttura il cui primo campo è il discriminante e il cui secondo e ultimo campo sono l'unione. Nell'esempio seguente viene illustrato come fornire l'unione e la discriminante come parametri:

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'unione nell'esempio precedente può contenere un singolo valore: breve, floato char. La definizione del tipo per l'unione include l'attributo MIDL switch_type che specifica il tipo di discriminante. In questo caso[ switch_type(short)] specifica che la discriminante è di tipo breve. L'opzione deve essere un tipo integer.

Se l'unione è membro di una struttura, il discriminante deve essere membro della stessa struttura. Se l'unione è un parametro, il discriminante deve essere un altro parametro. Il prototipo per la funzione UnionParamProc nell'esempio precedente mostra la discriminante sUtype come ultimo parametro della chiamata. Il discriminante può essere visualizzato in qualsiasi posizione nella chiamata. Il tipo del parametro specificato nell'attributo [switch_is] deve corrispondere al tipo specificato nell'attributo [switch_type].

Nell'esempio seguente viene illustrato l'uso di una singola struttura che crea un pacchetto della discriminante con l'unione:

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

Il compilatore MICROSOFT RPC MIDL consente dichiarazioni di unione al di fuori di costrutti typedef. Questa funzionalità è un'estensione per DCE IDL. Per altre informazioni, vedere union.