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

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

La covariance vous permet d’utiliser un type plus dérivé que le paramètre générique spécifié. Cette fonctionnalité permet la conversion implicite de classes qui implémentent des interfaces covariantes et la conversion implicite de types délégués. Covariance et contravariance prennent en charge les types de référence, mais ils ne prennent pas en charge les types valeur.

Une interface avec un paramètre de type covariant permet à ses méthodes de retourner plus de types dérivés que ceux spécifiés par le paramètre de type. Par exemple, étant donné que dans .NET, dans IEnumerable<T>, le type T est covariant, vous pouvez affecter un objet du IEnumerable<string> type à un objet du IEnumerable<object> type sans utiliser de méthodes de conversion spéciales.

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

Pour plus d’informations, consultez Covariance et Contravariance.

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#.

L’exemple suivant montre 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, déclarez un paramètre de type covariant s’il remplit les conditions suivantes :

• Vous utilisez le paramètre de type uniquement comme type de retour de méthodes d’interface et ne l’utilisez pas comme type d’arguments de méthode.

  Remarque

  Il existe une exception à cette règle. Si une interface covariante a 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éset utilisation de variance pour les délégués génériques func et action.

• Vous n’utilisez pas le paramètre de type comme contrainte générique pour les méthodes d’interface.

L’exemple suivant montre comment déclarer, instancier et appeler un délégué générique covariant. Il montre é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, déclarez un type covariant si vous l’utilisez uniquement comme type de retour de méthode et non pour les arguments de méthode.

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

• Variance dans les interfaces génériques
• dans
• Modificateurs