J'imagine que j'ai déjà vu quelque part, mais je ne me souviens plus de l'avoir trouvé, existe-t-il un moyen de créer une propriété getter avec des arguments?
Je veux dire, comme je peux convertir "float getSize ();" pour "float Size"
float getSize() {
return this.size;
}
float Size {
get { return this.size; }
}
Ensuite, pourrais-je convertir par exemple, "float getSize (String unit);" pour "float Size (String unit)" ou quelque chose comme ça?
float getSize(String unit) {
return this.size;
}
float Size(String unit) {
get {
if (unit == Unit.Meters)
return this.size/100;
else
return this.size;
}
}
Je pense qu’il n’ya pas vraiment de problème d’utilisation de la fonction, mais cela peut paraître mieux ainsi: P
Pour répondre à la question: non, ce n'est pas possible, et comme déjà indiqué, un getter avec un paramètre ressemblerait à une méthode.
La chose à laquelle vous pensez pourrait être une propriété indexée par défaut, qui ressemble à ceci:
class Test
{
public string this[int index]
{
get { return index.ToString(); }
}
}
Cela vous permet d'indexer dans une instance de Test, comme ceci:
Test t = new Test();
string value = t[1];
Mais juste comme curiosité ... Avoir une propriété avec paramètre est possible dans VB .Net
On dirait que:
Public ReadOnly Property oPair(param As String) As Result
Get
'some code depends on param
End Get
End Property
Cela ne fonctionne pas mieux que la fonction normale, mais il est parfois agréable d’avoir une telle possibilité.
Il est possible pour un objet de classe d’avoir un comportement raisonnablement efficace en tant que getter de propriété indexée nommée en renvoyant une propriété à struct
qui contient simplement une référence privée à l’objet de classe et inclut un getter de propriété indexée qui se connecte à une méthode la classe. Une telle structure mono-article peut être générée à peu de frais (elle peut probablement être insérée dans un registre et sera chargée avec une valeur se trouvant dans un autre registre; le JIT pourrait même reconnaître que le même registre peut être utilisé Ainsi, si l’utilisation d’un tel getter rend le code plus lisible, c’est un argument de poids en sa faveur.
Malheureusement, l'incapacité des membres de la structure d'indiquer s'ils modifient ou non la structure sous-jacente ne permet pas d'utiliser la même approche pour un configurateur de propriétés indexé. Même s’il serait utile d’avoir un OrderedCollection<T>
avec quelque chose comme:
struct ByIndexAccessor {
OrderedCollection<T> owner;
ByIndexAccessor(OrderedCollection<T> o) { owner = o; }
T this[int index] {
get { return owner.handleGet(index); }
set { owner.handleSet(index, value); }
}
}
ByIndexAccessor ByIndex {
get {return new ByIndexAccessor(this); }
}
et dire myCollection.ByIndex[3] = newThing;
, C # rejetterait ce code car il ne dispose d'aucun moyen de savoir que cette implémentation set
indexée particulière peut être utilisée en toute sécurité sur une structure en lecture seule.