Spécifier les génériques de la classe où T doit être sous-classe de l'autre type

Voici ce que je suis en train de faire, même pas sûr si possible..

Je suis la création de BaseViewModel<T> et je veux qu'il accepte les types hérités de Entity

Considérer ce code:

public abstract class BaseViewModel<T> : NotificationObject, INavigationAware
{

public T MyEntity;

public SomeMethod()
{
MyEntity.SomeEntityProperty = SomeValue;
}

}

Donc, je tiens à dire que mon T hérité de Entity et donc je SAIS qu'il va avoir SomeEntityProperty.

Est-ce possible?

OriginalL'auteur katit | 2011-10-18

c#generics

25

Salvatore réponse est tout à fait correcte, je voulais juste décrire le concept un peu mieux.

Ce que vous avez besoin est un "type générique contrainte"; pour spécifier que le type T doit être conforme à certains comportements (tels que les dérivés d'un objet ou d'une interface plus dérivé de l'Objet), augmentant ainsi que vous êtes autorisé à faire avec cet objet, sans autre casting (qui est généralement à éviter dans les génériques).

Salvatore réponse de la montre, les Cg sont définies à l'aide de la "où" mot-clé:
```
public abstract class BaseViewModel<T> :
    NotificationObject,
    INavigationAware

    where T : Entity;
{
   ...
```
Cette CG est dit en substance que tout doit dériver (mais à distance) de l'Entité. Cela vous permet de traiter les T comme si elle était une Entité (sauf pour l'instanciation de la nouvelle-Ts; qui nécessite un supplément de GTC), indépendamment de la façon plus ou moins dérivé de la réelle générique type de paramètre est à partir de l'Entité. Vous pouvez appeler n'importe quelle méthode qui s'affiche sur l'Entité, et obtenir/définir un champ ou une propriété.

Vous pouvez également spécifier que:
- Le type doit être une classe (where T:class), ou alternativement doit être un ValueType (where T:struct). Cela permet ou empêche la comparaison et l'attribution d'un T exemple à null, ce qui permet ou empêche l'utilisation de null-coalescence de l'opérateur ??.
- Le type doit avoir un constructeur sans paramètre (where T:new()). Cela permet d'instanciations de Ts à l'aide de la new mot-clé, en s'assurant au moment de la compilation que tous les types utilisés comme Ts avoir un constructeur qui ne prend pas de paramètres.
Désolé de necro a 6 ans réponse mais comment fait-on indiquer une signature du constructeur? par exemple, T:new(int,float). C'est la seule référence que je peux trouver à cette capacité et le compilateur ne semble pas comme elle, mais il semble définitivement comme un utile contrainte s'il y a bien un moyen de le définir.
Pas possible, c'était une erreur dans le post original. La seule contrainte générique en relation directe avec les constructeurs est le constructeur par défaut de la contrainte nécessitant un constructeur sans paramètre de T. Vous pouvez définir d'autres contraintes qui vous permettrait de s'assurer qu'un constructeur (ou méthode de fabrique) signature existé, mais il ne serait pas universel comme "où T:new(int, string)".
Merci pour l'explication.

OriginalL'auteur

public abstract class BaseViewModel<T> :
    NotificationObject,
    INavigationAware

    where T : Entity
{

    public T MyEntity;

    public SomeMethod()
    {
        MyEntity.SomeEntityProperty = SomeValue;
    }

}

OriginalL'auteur

Suffit d'utiliser la where mot-clé:

public abstract class BaseViewModel<T> : NotificationObject, INavigationAware
    where T:Entity
{
...

OriginalL'auteur

Essayez d'utiliser le où contrainte:

public abstract class BaseViewModel<T> : NotificationObject, INavigationAware
    where T : Entity
{
    public T MyEntity;

    public SomeMethod()
    {
        MyEntity.SomeEntityProperty = SomeValue;
    }
}

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.