Partager via

in (Modificateur générique) (Référence C#)

Pour les paramètres de type générique, utilisez le in mot clé pour autoriser les arguments de type contravariant. Utilisez le in mot clé dans les interfaces et délégués génériques.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

Contravariance vous permet d’utiliser un type moins dérivé que le type spécifié par le paramètre générique. Cette fonctionnalité permet la conversion implicite de classes qui implémentent des interfaces contravariantes et la conversion implicite de types délégués. Les types de référence prennent en charge la covariance et la contravariance dans les paramètres de type générique, mais les types valeur ne prennent pas en charge ces fonctionnalités.

Vous pouvez déclarer un type comme contravariant dans une interface générique ou un délégué uniquement s’il définit le type de paramètres d’une méthode et non le type de retour de la méthode. In, refet les out paramètres doivent être invariants, ce qui signifie qu’ils ne sont ni covariants ni contravariants.

Une interface qui a un paramètre de type contravariant permet à ses méthodes d’accepter des arguments de types moins dérivés que ceux spécifiés par le paramètre de type d’interface. Par exemple, dans l’interface IComparer<T> , le type T est contravariant. Vous pouvez affecter un objet du IComparer<Person> type à un objet du type sans utiliser de IComparer<Employee> méthodes de conversion spéciales si Employee hérite Person.

Vous pouvez affecter un délégué contravariant à un autre délégué du même type, mais avec un paramètre de type générique moins dérivé.

Pour plus d’informations, consultez Covariance et Contravariance.

Interface générique contravariante

L’exemple suivant montre comment déclarer, étendre et implémenter une interface générique contravariante. Il montre également comment utiliser la conversion implicite pour les classes qui implémentent cette interface.

// Contravariant interface.
interface IContravariant<in A> { }

// Extending contravariant interface.
interface IExtContravariant<in A> : IContravariant<A> { }

// Implementing contravariant interface.
class Sample<A> : IContravariant<A> { }

class Program
{
    static void Test()
    {
        IContravariant<Object> iobj = new Sample<Object>();
        IContravariant<String> istr = new Sample<String>();

        // You can assign iobj to istr because
        // the IContravariant interface is contravariant.
        istr = iobj;
    }
}

Délégué générique contravariant

L’exemple suivant montre comment déclarer, instancier et appeler un délégué générique contravariant. Il montre également comment convertir implicitement un type de délégué.

// Contravariant delegate.
public delegate void DContravariant<in A>(A argument);

// Methods that match the delegate signature.
public static void SampleControl(Control control)
{ }
public static void SampleButton(Button button)
{ }

public void Test()
{

    // Instantiating the delegates with the methods.
    DContravariant<Control> dControl = SampleControl;
    DContravariant<Button> dButton = SampleButton;

    // You can assign dControl to dButton
    // because the DContravariant delegate is contravariant.
    dButton = dControl;

    // Invoke the delegate.
    dButton(new Button());
}

Spécification du langage C#

Pour plus d'informations, voir la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

  • Last updated on