Jak uzyskać nazwę zmiennej, która została fizycznie wpisana w deklaracji?

Question

Powiel możliwe:
Finding the Variable Name passed to a Function in C#

Poniższa klasa zawiera Citi Field.

Potrzebuję dynamicznie określać nazwę pola, ponieważ jest wpisana w deklaracji klasy , tj. Muszę uzyskać ciąg "miasto" z instancji obiektu miasta.

Próbowałem to zrobić, sprawdzając jego typ DoSomething(), ale nie można go znaleźć podczas sprawdzania zawartości typu w debugerze.

Czy to możliwe?

public class Person 
{ 
    public string city = "New York"; 

    public Person() 
    { 
    } 


    public void DoSomething() 
    { 
    Type t = city.GetType(); 

    string field_name = t.SomeUnkownFunction(); 
    //would return the string "city" if it existed! 
    } 
} 

Niektórzy ludzie w swoich odpowiedziach poniżej pytali mnie, dlaczego chcę to zrobić. Oto dlaczego.

W mojej prawdziwej sytuacji na świecie istnieje niestandardowy atrybut nad miastem.

[MyCustomAttribute("param1", "param2", etc)] 
public string city = "New York"; 

Potrzebuję tego atrybutu w innym kodzie. Aby uzyskać atrybut, używam odbicia. I w kodzie refleksji muszę wpisać ciąg „miasto”

MyCustomAttribute attr; 
Type t = typeof(Person); 

foreach (FieldInfo field in t.GetFields()) 
{ 

    if (field.Name == "city") 
    { 
    //do stuff when we find the field that has the attribute we need 
    } 

} 

Teraz to nie jest typ bezpieczne. Gdybym zmienił zmiennej „miasto” na „workCity” w moim oświadczeniu pola osobiście linia ta nie powiedzie się, chyba że wiedział zaktualizować ciąg

if (field.Name == "workCity") 
//I have to make this change in another file for this to still work, yuk! 
{ 
} 

Więc staram się znaleźć jakiś sposób, aby przekazać ciąg do ten kod bez fizycznego wpisywania go.

Tak, mógłbym zadeklarować to jako stałą łańcuchową w Person (lub coś w tym stylu), ale to nadal byłoby wpisywanie jej dwukrotnie.

Uff! Trudno to wyjaśnić!

Dzięki

Dziękujemy wszystkim, którzy odpowiedzieli na to * dużo *. To wysłało mnie na nową ścieżkę, aby lepiej zrozumieć wyrażenia lambda. I stworzył nowe pytanie.

Answer 1

city w tym przypadku jest to instancja o numerze typu string. Po wywołaniu .GetType() zwraca się rzeczywisty typ łańcucha, który ma brak wiedzy o swojej konkretnej instancji miejskiej.

Trudno mi zrozumieć, dlaczego nie można po prostu wpisać "miasto" w kodzie jako literał łańcuchowy tutaj, jeśli tego właśnie potrzebujesz. Być może pomógłbyś, gdybyś podzielił się tym, do czego chcesz wykorzystać tę wartość iw jakich okolicznościach nazwiesz swoją funkcję DoSomething().

Obecnie mój najlepszy Domyślam się, że to, co naprawdę chcesz robić to odzwierciedlać całą Person klasę, aby uzyskać listę pól w tej klasie:

public void DoSomething() 
{ 
    MemberInfo[] members = this.GetType().GetMembers(); 

    // now you can do whatever you want with each of the members, 
    // including checking their .Name properties. 
} 

---

porządku, opartego na Twoja edycja Mam dla ciebie więcej.

można znaleźć nazwy pól, które są ozdobione atrybutu w czasie wykonywania tak:

Type t = typeof(Person); 
foreach (MemberInfo member in t.GetMembers() 
      .Where(m => 
       m.GetCustomAttributes(typeof(MyCustomAttribute)).Any() )) 
{ 
    // "member" is a MemberInfo object for a Peson member that is 
    // decorated with your attribute 
} 

Można również użyć wiążących flagi w pierwszych GetMembers() zadzwonić, żeby go po prostu pola ograniczyć , Jeśli chcesz.

Answer 2

t.GetField("city", BindingFlags.Public | BindingFlags.Instance); 

lub możesz zadzwonić GetFields(), aby uzyskać wszystkie pola

Answer 3

Trzeba zadzwonić dostać typ na klasy Osoba. Iteracja pól klasy tak, jak w odpowiedzi poniżej:

Answer 4

To nie jest możliwe (myślę, że tak naprawdę to tylko inwokuje kilka hacków i używa lambdas). Jeśli chcesz przechowywać atrybuty dotyczące Person i łatwo uzyskać nazwę atrybutu, sugeruję użycie Dictionary<TKey, TValue> z przestrzeni nazw System.Collections.Generic.

Zawsze można tworzyć publiczne właściwości, które zawijają słownik.

public class Person 
{ 
    Dictionary<string, string> attributes = new Dictionary<string, string(); 
    public string City 
    { 
    get { return attributes["city"]; } 
    set { attributes["city"] = value; } 
    } 

    public Person() 
    { 
    City = "New York"; 
    } 
} 

I można uzyskać listę wszystkich atrybutów z attributes.Keys.

Answer 5

Wystarczy popatrzeć na to stanowisko, jak to wygląda podobnie do tego, co starasz się zrobić:

Finding the variable name passed to a function

(zwłaszcza odpowiedź Konrad Rudolfa) Innym rozwiązaniem mogłoby być po prostu dodać „miasto” jako jeden parametrów w atrybucie i łowić ryby później.

Answer 6

Przeglądasz już kolekcję obiektów FieldInfo. Poszukaj na nich swojego atrybutu i kiedy znajdziesz FieldInfo zawierający Twój atrybut, masz ten, który chcesz. Następnie zadzwoń pod numer .Name.

system.reflection.fieldinfo.attributes

Answer 7

Wspomniałeś „to znaczy, że trzeba uzyskać ciąg«miasto»z instancji obiektu miasta.” Czy chcesz uzyskać nazwę pola od wartości pola. Na przykład: Jeśli obiekt 2 osoba ma jeden z miastem "Nowy Jork", a drugi z miastem "Londyn", czy szukasz funkcji zwracania "miasta". Czy to masz na myśli dynamiczny?

---

Przy aktualnym projekcie zawsze będziesz musiał porównać nazwę pola z FieldInfo z ciągiem znaków. Co, jeśli zamiast tego rozdzielisz to, aby zachować identyfikator, który będzie używany do celów porównawczych podczas odbicia jako część atrybutu. coś takiego:

public enum ReflectionFields 
{ 
    CITY = 0, 
    STATE, 
    ZIP,  
    COUNTRY 

} 

[AttributeUsage(AttributeTargets.Field,AllowMultiple=false)] 
public class CustomFieldAttr : Attribute 
{ 
    public ReflectionFields Field { get; private set; } 
    public string MiscInfo { get; private set; } 

    public CustomFieldAttr(ReflectionFields field, string miscInfo) 
    { 
     Field = field; 
     MiscInfo = miscInfo; 
    } 
} 

public class Person 
{ 
    [CustomFieldAttr(ReflectionFields.CITY, "This is the primary city")] 
    public string _city = "New York"; 

    public Person() 
    { 
    } 
    public Person(string city) 
    { 
     _city = city; 
    } 

} 

public static class AttributeReader<T> where T:class 
{ 
    public static void Read(T t) 
    { 
     //get all fields which have the "CustomFieldAttribute applied to it" 
     var fields = t.GetType().GetFields().Where(f => f.GetCustomAttributes(typeof(CustomFieldAttr), true).Length == 1); 

     foreach (var field in fields) 
     { 
      var attr = field.GetCustomAttributes(typeof(CustomFieldAttr), true).First() as CustomFieldAttr; 
      if (attr.Field == ReflectionFields.CITY) 
      { 
       //You have the field and you know its the City,do whatever processing you need. 
       Console.WriteLine(field.Name); 
      } 
     }    
    } 
} 

public class Program 
{ 
    public static void Main(string[] args) 
    { 
     PPerson p1 = new PPerson("NewYork"); 
     PPerson p2 = new PPerson("London"); 
     AttributeReader<PPerson>.Read(p1); 
     AttributeReader<PPerson>.Read(p2); 

} 
} 

Teraz można dowolnie zmienić nazwę pola _City osoby, która czegoś innego i kod wywołanie będzie nadal działać, ponieważ kod przy użyciu odbicia próbuje zidentyfikować pole wykorzystując wartość enum ReflectionFields ustawiony jako część inicjalizacji zestawu atrybutów na polu.

Answer 8

Dwie rzeczy tutaj.

Po pierwsze, jak wskazano powyżej, dostajesz typ dla napisu, a nie dla osoby. Tak więc typeof (Person) .GetMembers() dostanie listę członków.

Numer dwa, a co ważniejsze, wygląda na to, że nie rozumiesz celu atrybutów. Ogólnie atrybuty są używane do oznaczenia elementu do określonego przetwarzania lub do dodania dodatkowych informacji. Tutaj używasz nazwy, aby wskazać, jakie przetwarzanie chcesz i atrybut do określenia parametrów, które miesza metafory lub coś.

Odpowiedź Abhijeeta jest bardziej odpowiednia, należy oznaczyć pole jako a pole miejskie, a następnie zrobić z nim to, co lubisz. Tam, gdzie nie zgadzam się, używam różnych klas atrybutów zamiast wyliczania.

Coś jak:

public class MyAttribute : Attribute 
    { 

    } 

    [AttributeUsage(AttributeTargets.Field)] 
    public class MyCityAttribute : MyAttribute 
    { 
    } 

    [AttributeUsage(AttributeTargets.Field] 
    public class MyNameAttribute: MyAttribute 
    { 
    } 

    public class Person 
    { 

     [MyCity] 
     public string city = "New York"; 

     [MyCity] 
     public string workCity = "Chicago"; 

     [MyName] 
     public string fullName = "John Doe"; 

     public Person() 
     { 
     } 


     public void DoSomething() 
     { 
      Type t = typeof(Person); 
      FieldInfo[] fields = t.GetFields(BindingFlags.Instance | BindingFlags.Public); 

      foreach (var field in fields) 
      { 
       MyAttribute[] attributes = field.GetCustomAttributes(typeof(MyAttribute)); 
       if (attributes.Count > 0) 
       { 
        if (attributes[0] is MyCityAttribute) 
        { 
         //Dosomething for city 
         break; 
        } 

        if (attributes[0] is MyNameAttribute) 
        { 
         //Dosomething for names 
         break; 
        } 
       } 
      } 
     } 
    } 

To pozwala stosować różne parametry dla Mycity vs MyName że więcej sensu w kontekście przetwarzania każdy.

Myślę, że z powyższym komentarzem "yuk" uderzasz w głowę. To, że musisz zmienić stałą łańcuchową, jeśli zmienisz nazwę zmiennej, jest wskaźnikiem, że robisz coś źle.

Answer 9

Może potrzebujesz tego. Działa w porządku.

Znalazłem to here.

static void Main(string[] args) 
{ 
    var domain = "matrix"; 
    Check(() => domain); 
    Console.ReadLine(); 
} 

static void Check<T>(Expression<Func<T>> expr) 
{ 
    var body = ((MemberExpression)expr.Body); 
    Console.WriteLine("Name is: {0}", body.Member.Name); 
    Console.WriteLine("Value is: {0}", ((FieldInfo)body.Member) 
    .GetValue(((ConstantExpression)body.Expression).Value)); 
} 

wyjściowe będą:

 
Name is: 'domain' 
Value is: 'matrix' 

Answer 10

Tak, to możliwe !!!

Spróbuj tego ...

public string DoSomething(object city) 
    { 
     return city.GetType().GetProperty("Name",typeof(string)).GetValue(city,null); 
    } 

Answer 11

Wiem, że to stare pytanie, ale starałem się osiągnąć to samo i google wysłał mnie tutaj. Po wielu godzinach w końcu znalazłem sposób. Mam nadzieję, że ktoś inny uzna to za przydatne.

Istnieje rzeczywiście więcej sposobów, aby to osiągnąć:

static void Main(string[] args) 
{ 
    GetName(new { var1 }); 
    GetName2(() => var1); 
    GetName3(() => var1); 
} 

static string GetName<T>(T item) where T : class 
{ 
    return typeof(T).GetProperties()[0].Name; 
} 

static string GetName2<T>(Expression<Func<T>> expr) 
{ 
    return ((MemberExpression)expr.Body).Member.Name; 
} 

static string GetName3<T>(Func<T> expr) 
{ 
    return expr.Target.GetType().Module.ResolveField(BitConverter.ToInt32(expr.Method.GetMethodBody().GetILAsByteArray(), 2)).Name; 
} 

Pierwszym z nich jest najszybszy. Ostatnie 2 są około 20 razy wolniejsze od pierwszego.

http://abdullin.com/journal/2008/12/13/how-to-find-out-variable-or-parameter-name-in-c.html