Cette page vous a-t-elle été utile ?
Votre avis sur ce contenu est important. N'hésitez pas à nous faire part de vos commentaires.
Vous avez d'autres commentaires ?
1500 caractères restants
out (modificateur générique) (Référence C#)
Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

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

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

La covariance vous permet d'utiliser un type plus 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 la contravariance sont prises en charge pour les types référence mais pas pour les types valeur.

Une interface ayant un paramètre de type covariant permet à ses méthodes de retourner des types plus dérivés que ceux spécifiés par le paramètre de type. Par exemple, comme dans .NET Framework 4, dans IEnumerable<T>, le type T est covariant, vous pouvez assigner un objet de type IEnumerabe(Of String) à un objet de type IEnumerable(Of Object) sans utiliser des méthodes de conversion spéciales.

Un autre délégué du même type peut être assigné à un délégué covariant, mais avec un paramètre de type générique plus 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 covariante. Il montre également comment utiliser la conversion implicite pour les classes qui implémentent une interface covariante.


// Covariant interface.
interface ICovariant<out R> { }

// Extending covariant interface.
interface IExtCovariant<out R> : ICovariant<R> { }

// Implementing covariant interface.
class Sample<R> : ICovariant<R> { }

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

        // You can assign istr to iobj because
        // the ICovariant interface is covariant.
        iobj = istr;
    }
}


Dans une interface générique, un paramètre de type peut être déclaré covariant s'il satisfait aux conditions suivantes :

  • Le paramètre de type est utilisé uniquement comme type de retour de méthodes d'interface et non comme type d'arguments de méthode.

    Remarque Remarque

    Il existe une exception à cette règle. Si dans une interface covariante vous avez un délégué générique contravariant comme paramètre de méthode, vous pouvez utiliser le type covariant comme paramètre de type générique pour ce délégué. Pour plus d'informations sur les délégués génériques covariants et contravariants, consultez Variance dans les délégués (C# et Visual Basic) et Utilisation de la variance pour les délégués génériques Func et Action (C# et Visual Basic).

  • Le paramètre de type n'est pas utilisé comme contrainte générique pour les méthodes d'interface.

L'exemple suivant indique comment déclarer, instancier et appeler un délégué générique covariant. Il indique également comment convertir implicitement des types délégués.


// Covariant delegate.
public delegate R DCovariant<out R>();

// Methods that match the delegate signature.
public static Control SampleControl()
{ return new Control(); }

public static Button SampleButton()
{ return new Button(); }

public void Test()
{            
    // Instantiate the delegates with the methods.
    DCovariant<Control> dControl = SampleControl;
    DCovariant<Button> dButton = SampleButton;

    // You can assign dButton to dControl
    // because the DCovariant delegate is covariant.
    dControl = dButton;

    // Invoke the delegate.
    dControl(); 
}


Dans un délégué générique, un type peut être déclaré covariant s'il est utilisé uniquement comme un type de retour de méthode et n'est pas utilisé pour les arguments de méthode.

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.

Afficher:
© 2015 Microsoft