Leggere in inglese

Condividi tramite


Parola chiave union (RPC)

Alcune funzionalità del linguaggio C, ad esempio le unioni, richiedono parole chiave MIDL speciali per supportarne 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. Si tratta di 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: short, float o char. La definizione del tipo per l'unione include l'attributo MIDL switch_type che specifica il tipo del discriminante. In questo caso, [switch_type(short)] specifica che il discriminante è di tipo short. L'opzione deve essere un tipo integer.

Se l'unione è un membro di una struttura, il discriminante deve essere un 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 lo sUtype discriminante 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 inserisce il 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 MIDL RPC Microsoft consente dichiarazioni di unione al di fuori dei costrutti typedef . Questa funzionalità è un'estensione per DCE IDL. Per altre informazioni, vedere union.