Propriété Getter avec des arguments

Question

Je suppose que j'ai déjà vu quelque part auparavant, mais maintenant je ne me souviens pas de la trouver, y a-t-il un moyen de créer une propriété getter avec des arguments? Je veux dire que je peux convertir "float getSize();" à "float Size"

float getSize() { 
    return this.size; 
} 

float Size { 
    get { return this.size; } 
} 

Puis, puis-je convertir par exemple, "float getSize (String unit);" à "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'y a pas vraiment problème d'utiliser la fonction du tout, mais peuvent être mieux ainsi: P

Answer 1

Pour répondre à la question: Non, il est impossible, et comme l'a déjà souligné, un getter avec un paramètre ressemblerait à une méthode.

La chose que vous pensez peut-être une propriété par défaut indexé, qui ressemble à ceci:

class Test 
{ 
    public string this[int index] 
    { 
     get { return index.ToString(); } 
    } 
} 

Cela vous permet d'indexer en une instance de test, comme ceci:

Test t = new Test(); 
string value = t[1]; 

Answer 2

Mais juste comme curiosité ... Avoir la propriété avec le paramètre est possible dans VB .Net

Cela ressemble à:

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

Answer 3

Un objet de classe peut raisonnablement avoir quelque chose qui se comporte comme un getter de propriété indexée nommé en ayant une propriété qui retourne un struct qui contient simplement une référence privée à l'objet de classe et inclut un getter de propriété indexée à une méthode dans la classe. Une telle structure mono-item peut être générée à peu près gratuitement (elle peut probablement tenir dans un registre, et sera chargée avec une valeur qui est dans un autre registre, le JIT peut même être capable de reconnaître que le même registre peut être utilisé pour deux fins), donc si l'utilisation d'un tel getter rend le code plus lisible c'est un argument substantiel en faveur.

Malheureusement, l'incapacité des membres de structure à indiquer s'ils modifient ou non la structure sous-jacente rend impossible l'utilisation de la même approche pour un ensemble de propriétés indexées. Même si il serait utile qu'il on aurait pu 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 parce qu'il n'a aucun moyen de savoir que ce particulier indexé set mise en œuvre peut être utilisé sans danger sur une structure en lecture seule.