Übergeben Sie die Eigenschaft als Funktionsargument und konvertieren Sie sie in einen String innerhalb

Question

Ich möchte jeden möglichen Typ als Funktionsparameter übergeben können.

Jetzt gibt es ein Problem mit der Weitergabe von Eigenschaften z.

class Foo 
{ 
    public int Bar { get; set; } 
} 

Ich bin in der Lage zu nutzen: nameof (Foo.Bar) aber ich bin nicht in der Lage A (Foo.Bar), wo in A zu tun nameof verwendet werden.

Ich möchte sicher haben, dass String aus Eigenschaft erstellt wird und ich möchte, dass die Eigenschaft an die API übergeben wird und nameof innerhalb der API ausgeführt wird.

Gibt es eine Möglichkeit, Eigenschaft über Funktion an nameof zu übergeben? Ich möchte die Konvertierung der Eigenschaft in eine Zeichenfolge innerhalb meiner Klasse ausblenden, anstatt die Zeichenfolge fertig zu machen. Wie erreichen Sie das?

edit: Der Schlüssel ist ungefähr: [?]

class B 
{ 
    public Prop {get; set;} 
} 

void foo([?]) 
{ 
    Console.WriteLine(nameof([?])); 
} 

Was stattdessen setzen wie Konsolenausgabe zu haben. Prop

Answer 1

Ich glaube, Sie nameof ein wenig hier falsch interpretieren.

In Ihrem ersten Beispiel wird die Methode immer T drucken und hängt nicht vom Typ T ab. Das Schlüsselwort nameof bewirkt nichts anderes, als den angegebenen Ausdruck durch eine Zeichenfolgendarstellung des Ausdrucks zu ersetzen. z.B. Wir geben nameof den Parameter T und er wird die Zeichenfolgendarstellung dieses Ausdrucks zurückgeben: T.

void A<T>(T smth) 
{ 
    Console.Writeline(nameof(T)); // example usage 
} 

Im Allgemeinen ist die Verwendung von nameof ist Refactoring-able Methode/Eigenschaft/... Namen Methoden zur Verfügung zu stellen.

Zum Beispiel die ArgumentOutOfRangeException hat als Parameter den Namen des Arguments, die außerhalb des zulässigen Bereichs ist.

void Test(int value) 
{ 
    if (value < 0) throw new ArgumentOutOfRangeException("value"); 
    // yada yada 
} 

Wenn wir den Namen als fest einprogrammierte Zeichenfolge wie im Beispiel bieten wir über eine Inkonsistenz erhalten würden, wenn die Parameter umbenennen.

Um dies zu lösen, verwenden wir nameof und weil wir den Parameter selbst anstelle einer fest codierten Zeichenfolge zur Verfügung stellen, ist es refaktorsicher.

void Test(int value) 
{ 
    if (value < 0) throw new ArgumentOutOfRangeException(nameof(value)); 
    // yada yada 
} 

Answer 2

der C# -Compiler Verwendungen ‚nameof‘ zu Art finden und Dinge zum Zeitpunkt der Kompilierung ersetzen, so wird es nicht funktionieren, wie Sie es erwarten. Stattdessen müssen Sie die Namen der Eigenschaften zur Laufzeit mithilfe von Expressions oder Reflection abrufen. Hier ist ein Beispiel dafür, wie es zu tun Ausdrücke verwenden:

public static string GetName<T>(Expression<Func<T>> expression) 
    { 
     var member = (MemberExpression)expression.Body; 
     return member.Member.Name; 
    } 
    public static string GetName<T>(Expression<Func<T, object>> expression) 
    { 
     var body = expression.Body as MemberExpression; 

     if (body == null) 
     { 
      body = ((UnaryExpression)expression.Body).Operand as MemberExpression; 
     } 

     return body.Member.Name; 
    } 

    public static void PrintName<T>(Expression<Func<T>> expression) 
    { 
     Console.WriteLine(GetName(expression)); 
    } 

    public static void PrintName<T>(Expression<Func<T, object>> expression) 
    { 
     Console.WriteLine(GetName(expression)); 
    } 

wie folgt verwendet:

class B 
{ 
    public Prop {get; set;} 
} 

static void Main(string[] args) 
    { 
     PrintName<B>((b) => b.Prop); 

     //Or 
     var someObject = new B(); 
     PrintName(() => someObject.Prop); 

     Console.ReadLine(); 
    }