Partager via

Synthétisation d’interfaces (MIDL 3.0)

  • Article

Assigner des membres à des interfaces

une classe Windows Runtime fonctionne en termes d’interfaces. Toutefois, les interfaces ont été mentionnées dans la plupart des exemples précédents, car il s’agit généralement d’un détail d’implémentation que vous n’avez pas besoin de contrôler dans la plupart des cas.

Par conséquent, lorsque votre description de classe ne fait pas référence à une interface, mais lorsque l’une d’elles est nécessaire pour implémenter la classe, le compilateur MIDL 3,0 synthétise et les ajoute, si nécessaire.

Constructeur par défaut

quand vous déclarez un constructeur par défaut en tant que membre d’une classe, le compilateur produit une classe Windows Runtime qui est activable par défaut. Au niveau de l’implémentation, cela signifie que les métadonnées décrivent la classe comme étant activable par défaut, et la fabrique de classe pour le runtimeclass implémente l’interface IActivationFactory .

runtimeclass Area
{
    Area();
    ...
}

Dans ce cas, la zone est compilée avec les métadonnées [Activatable] de typenull .

Constructeur (s) non défini par défaut

lorsque vous déclarez un ou plusieurs constructeurs non définis par défaut en tant que membres d’une classe, le compilateur produit une classe Windows Runtime qui est activable, plutôt que par défaut activable. Au niveau de l’implémentation, cela signifie que les métadonnées décrivent la classe comme étant activable et spécifient l’interface contenant les méthodes de constructeur.

Par défaut, cette interface est nommée I <className> Factory, et la fabrique de classe pour le runtimeclass implémente cette interface. Si ce nom d’interface est déjà utilisé, le compilateur ajoute un suffixe de chiffre entier (à partir de 2), jusqu’à ce qu’il trouve un nom inutilisé.

runtimeclass Area
{
    Area(Int32 width, Int32 height);
    ...
}

Dans ce cas, le compilateur

  • synthétise une interface de fabrique nommée IAreaFactory,
  • Ajoute un exclusiveto attribut à l’interface synthétisée, en spécifiant que l’interface ne peut être référencée que par la classe d’exécution, et
  • Ajoute un activatable attribut à la classe Runtime indiquant que les clients peuvent utiliser des membres de l’interface IAreaFactory pour créer des instances de la classe.

Le MIDL ci-dessus peut donc être interprété comme suit.

[exclusiveto(Area)]
interface IAreaFactory
{
    Area(Int32 width, Int32 height);
}

[activatable(IAreaFactory)]
runtimeclass Area
{
    ...
}

Une classe peut contenir à la fois un constructeur par défaut et des constructeurs supplémentaires non définis par défaut.

runtimeclass Area
{
    Area();
    Area(Int32 width, Int32 height);
    ...
}

Dans ce cas, le MIDL peut être interprété comme suit : avec les deux formes de l' activatable attribut.

[exclusiveto(Area)]
interface IAreaFactory
{
    Area(Int32 width, Int32 height);
}

[activatable()]
[activatable(IAreaFactory)]
runtimeclass Area
{
    ...
}

Membres d’instance

Dans l’exemple ci-dessous, Area a des membres Height et Width.

runtimeclass Area : Windows.Foundation.IStringable
{
    Int32 Height;
    Int32 Width;
}

Ces membres ne font pas partie d’une interface implémentée par Area . Par conséquent, le compilateur synthétise une interface pour eux, par défaut, je <className> . Si ce nom d’interface est déjà utilisé, le compilateur ajoute un suffixe de chiffre entier (à partir de 2), jusqu’à ce qu’il trouve un nom inutilisé.

Dans le cas du MIDL ci-dessus, le compilateur

  • synthétise l’interface IArea ,
  • Ajoute un exclusiveto attribut à l’interface synthétisée, en spécifiant que l’interface ne peut être référencée que par la classe Runtime.
  • Spécifie que la classe Runtime implémente IArea, et
  • Convertit la nouvelle interface en interface par défaut pour la classe Runtime si la classe n’a pas encore d’interface par défaut.

Le MIDL ci-dessus peut donc être interprété comme suit.

[exclusiveto(Area)]
interface IArea
{
    Int32 Height;
    Int32 Width;
}

runtimeclass Area : IArea, Windows.Foundation.IStringable
{
}

Membres static

Dans l’exemple ci-dessous, Area contient le membre static NumberOfAreas.

runtimeclass Area : Windows.Foundation.IStringable
{
    static Int32 NumberOfAreas { get; };
}

Le membre statique ne fait pas partie d’une interface statique que la zone implémente. Par conséquent, le compilateur synthétise une interface appelée, par défaut, je <className> les statiques. Si ce nom d’interface est déjà utilisé, le compilateur ajoute un suffixe de chiffre entier (à partir de 2), jusqu’à ce qu’il trouve un nom inutilisé.

Dans le cas du MIDL ci-dessus, le compilateur

  • synthétise l’interface IAreaStatics ,
  • Ajoute un exclusiveto attribut à l’interface synthétisée, en spécifiant que l’interface ne peut être référencée que par la classe d’exécution, et
  • Ajoute un statics attribut à la classe d’exécution, en spécifiant que la fabrique de classe implémente IAreaStatics.

Le MIDL ci-dessus peut donc être interprété comme suit.

[exclusiveto(Area)]
interface IAreaStatics
{
    Int32 NumberOfAreas { get; };
}

[static(IAreaStatics)]
runtimeclass Area : Windows.Foundation.IStringable
{
}

Membres protégés

Dans l’exemple ci-dessous, Area contient le membre protégé DoProtectedWork.

runtimeclass Area : Windows.Foundation.IStringable
{
    protected void DoProtectedWork();
}

Le membre protégé ne fait pas partie d’une interface protégée que la zone implémente. Par conséquent, le compilateur synthétise une interface appelée, par défaut, j’ai>< protégé. Si ce nom d’interface est déjà utilisé, le compilateur ajoute un suffixe de chiffre entier (à partir de 2), jusqu’à ce qu’il trouve un nom inutilisé.

Dans le cas du MIDL ci-dessus, le compilateur

  • synthétise l’interface IAreaProtected ,
  • Ajoute un exclusiveto attribut à l’interface synthétisée, en spécifiant que l’interface ne peut être référencée que par la classe d’exécution, et
  • Ajoute un protected attribut à la classe d’exécution, en spécifiant que la classe implémente l’interface protégée IAreaProtected.

Le MIDL ci-dessus peut donc être interprété comme suit.

[exclusiveto(Area)]
interface IAreaProtected
{
    void DoProtectedWork();
}

[protected(IAreaProtected)]
runtimeclass Area : Windows.Foundation.IStringable
{
}

Membres substituables

Dans l’exemple ci-dessous, le volume (qui dérive de Area) a le membre substituable DoOverridableWork.

runtimeclass Volume : Area
{
    overridable void DoOverridableWork();
}

Le membre Overridable ne fait pas partie d’une interface substituable que la zone implémente. Par conséquent, le compilateur synthétise une interface appelée, par défaut, je <className> les remplacements. Si ce nom d’interface est déjà utilisé, le compilateur ajoute un suffixe de chiffre entier (à partir de 2), jusqu’à ce qu’il trouve un nom inutilisé.

Dans le cas du MIDL ci-dessus, le compilateur

  • synthétise l’interface IAreaOverrides ,
  • Ajoute un exclusiveto attribut à l’interface synthétisée, en spécifiant que l’interface ne peut être référencée que par la classe d’exécution, et
  • Ajoute un overridable attribut à la classe d’exécution, en spécifiant que la classe implémente l’interface substituable IAreaOverrides.

Le MIDL ci-dessus peut donc être interprété comme suit.

[exclusiveto(Area)]
interface IAreaOverrides
{
    void DoOverridableWork();
}

[overridable(IAreaOverrides)]
runtimeclass Area : Windows.Foundation.IStringable
{
}