Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

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

Pour les paramètres de type générique, le mot clé in spécifie que le paramètre de type est contravariant. Vous pouvez utiliser le mot clé in dans les interfaces et les délégués génériques.

La contravariance vous permet d'utiliser un type moins dérivé que celui spécifié par le paramètre générique. Cela permet la conversion implicite des classes qui implémentent des interfaces variantes et la conversion implicite des types délégués. La covariance et contravariance dans les paramètres de type générique sont prises en charge pour les types référence, mais elles ne sont pas prises en charge pour les types valeur.

Un type peut être déclaré contravariant dans une interface ou un délégué générique s'il est utilisé uniquement comme type d'arguments de méthode et non comme type de retour de méthode. Les paramètres Ref et out ne peuvent pas être variants.

Une interface ayant un paramètre de type contravariant autorise ses méthodes à accepter des arguments de types moins dérivés que ceux spécifiés par le paramètre de type d'interface. Par exemple, comme dans le .NET Framework 4, dans l'interface IComparer<T>, le type T est contravariant, vous pouvez assigner un objet de type IComparer(Of Person) à un objet de type IComparer(Of Employee) sans utiliser des méthodes de conversion spéciales si Employee hérite de Person.

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

Pour plus d'informations, consultez Covariance et contravariance (C# et Visual Basic).

L'exemple suivant indique comment déclarer, étendre et implémenter une interface générique contravariante. Il montre également comment vous pouvez 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;
    }
}


L'exemple suivant indique comment déclarer, instancier et appeler un délégué générique contravariant. Il montre également comment vous pouvez convertir implicitement un type 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()); 
}


Pour plus d'informations, consultez 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.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft