Pensez-vous que les propriétés génériques seraient utiles dans .NET?

Question

Je ne parle pas de classes génériques qui déclarent des propriétés ou des champs avec le type d'un paramètre générique. Je parle de propriétés génériques qui pourraient être appliquées aux classes génériques et non génériques.

Je ne parle pas de ceci:

public class Base<T> 
{ 
    public T BaseProperty { get; set; } 
} 

Je parle de ceci:

public class Base 
{ 
    public T BaseProperty<T> 
    { 
     get 
     { 
      // Insert magic 
     } 
     set 
     { 
      // Insert magic 
     } 
    } 
} 

Ou ceci:

public class Base<U> 
{ 
    public T BaseProperty<T> 
    { 
     get 
     { 
      // Insert magic 
     } 
     set 
     { 
      // Insert magic 
     } 
    } 

    public U OtherBaseProperty { get; set; } 
} 

L'utilisation irait à quelque chose comme ça :

var b = new Base(); 
b.BaseProperty<int> = 42; 
int i = b.BaseProperty<int>; 
b.BaseProperty<string> = "Hi"; 
string s = b.BaseProperty<string>; 

Ou pour le deuxième exemple:

var b = new Base<string>(); 
b.BaseProperty<int> = 42; 
int i = b.BaseProperty<int>; 
b.OtherBaseProperty = "Hi"; 
string s = b.OtherBaseProperty; 

Le // Insérer magique se réfère à la manipulation de chaque appel au getter ou setter de propriété générique qui a un type différent pour le paramètre de type.

Par exemple ceci:

b.BaseProperty<int> = 42; 

doit être traité différemment à:

b.BaseProperty<string> = "Hi"; 

j'envisager que pour chaque T si le getter de type est appelé avant le poseur est alors appelé par défaut (T) est retourné. Lorsque le setter est appelé, la valeur est stockée par type T de sorte que lorsque le getter est appelé par la suite, la valeur précédente qui a été définie pour ce type est renvoyée.

Notez que sous les propriétés de couvertures sont juste des méthodes.

Pensez-vous que ce serait utile?

Answer 1

J'ai eu quelques fois où j'aurais aimé pouvoir le faire, oui.

Cependant, la syntaxe impliquée serait assez moche, et il est suffisamment rarement utile que je pense que je préfère juste l'aspirer et aller avec des méthodes génériques.

Answer 2

No.

Answer 3

Sans un cas d'utilisation de tueur, non. Vous pouvez déjà réaliser la même chose avec une paire de méthodes génériques, si vous en avez besoin.

Answer 4

Si pour une raison bizarre que vous avez décidé que vous vouliez, vous pouvez trier de faux avec les méthodes:

public class Thing 
{ 
    Dictionary<Type, object> xDict = new Dictionary<Type,object>(); 
    public void set_X<T>(T x) 
    { 
     xDict[typeof(T)] = x; 
    } 
    public T get_X<T>() 
    { 
     return (T)xDict[typeof(T)]; 
    } 
} 

Pourquoi vous voulez est une question tout à fait différente, cependant. Il est généralement plus logique de commencer avec quelque chose que vous voulez faire que d'une certaine façon que vous voulez le faire.

Answer 5

No.

méthodes génériques de sens, car ils incarnent une opération (générique) qui peut raisonnablement être appliquée à différents types.

Mais les propriétés n'ont de sens que sous la forme de valeurs nommées avec un contenu défini. Les «propriétés génériques», comme vous le suggérez, ne sont en réalité que des propriétés similaires avec des signatures et des contenus différents.

Answer 6

Voici un exemple où cela aurait été pratique pour moi, si cela aurait été possible.

var settings = new Settings(); 
int timeout = settings<int>["CacheInMinutes"]; 

Où Paramètres charge un fichier XML de variables de configuration.

que, par rapport à:

var settings = new Settings(); 
int timeout = int.Parse(settings["CacheInMinutes"]); 

Vraiment pas beaucoup de différence, mais bon, je serais toujours préféré l'indexeur générique.

Answer 7

bien, j'ai la situation qui a besoin de la propriété générique dans la classe non générique. Exemple Vous avez IComponent classe qui veulent fournir son parent IContainer avec la propriété Parent, puisque le composant peut appartenir à n'importe quel type de conteneur. de sorte que vous devez fournir la propriété générique plutôt que la méthode générique

Component c = new Component(); 
Container p = new Container(); 
p.Add(c); 

puis vous accédez à son parent en utilisant la propriété générique (pas aplicable maintenant)

c.Parent.ContainerProperty; 
c.Parent.ContainerMethod(); 

plutôt en utilisant la méthode bavard comme

c.Parent().ContainerProperty; 
c.Parent().ContainerMethod(); 

Eh bien, dans ce cas, la propriété générique est plus belle et logique, puisque vous n'avez besoin d'entrer aucun argument.