Вспомогательные блоки в C#?

Question

Есть ли у C# что-нибудь вроде Python's __getattr__?

У меня есть класс со многими свойствами, и все они имеют один и тот же код доступа. Я хотел бы иметь возможность полностью отказаться от отдельных аксессуаров, как в Python.

Вот что мой код выглядит сейчас:

class Foo 
{ 
    protected bool Get(string name, bool def) 
    { 
     try { 
      return client.Get(name); 
     } catch { 
      return def; 
     } 
    } 

    public bool Bar 
    { 
     get { return Get("bar", true); } 
     set { client.Set("bar", value); } 
    } 

    public bool Baz 
    { 
     get { return Get("baz", false); } 
     set { client.Set("baz", value); } 
    } 
} 

И вот что я хотел бы:

class Foo 
{ 
    public bool Get(string name) 
    { 
     try { 
      return client.Get(name); 
     } catch { 
      // Look-up default value in hash table and return it 
     } 
    } 

    public void Set(string name, object value) 
    { 
     client.Set(name, value) 
    } 
} 

Есть ли способ для достижения этой цели в C# без вызова Get напрямую?

Спасибо,

Answer 1

No. Хотя C# поддерживает отражение, читается - только (для загруженных сборок). Это означает, что вы не можете изменять какие-либо методы, свойства или любые другие метаданные. Хотя вы могли бы create a dynamic property, называть это было бы не очень удобно - было бы даже хуже, чем использовать ваш метод Get. Помимо использования Dictionary<string, object> и индексатора для вашего класса, вы ничего не можете сделать. Во всяком случае, не делает словарь лучше, если у вас есть много свойств?

Python не проверяет, существует ли атрибут в «время компиляции» (или, по крайней мере, время загрузки). C# делает. Это принципиальное различие между двумя языками. В Python вы можете сделать:

class my_class: 
    pass 

my_instance = my_class() 
my_instance.my_attr = 1 
print(my_instance.my_attr) 

В C# вы не были бы в состоянии сделать это, потому что C# на самом деле проверяет, является ли имя my_attr существует во время компиляции.

Answer 2

Это не то же самое, что вы получите в Python с динамическими именами свойств, но вы могли бы найти это полезным:

using System; 
using System.Collections.Generic; 

namespace Program 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      MyList<int> list = new MyList<int>(); 
      // Add a property with setter. 
      list["One"] = 1; 
      // Add a property with getter which takes default value. 
      int two = list["Two", 2]; 
      Console.WriteLine("One={0}", list["One"]); 
      Console.WriteLine("Two={0}/{1}", two, list["Two"]); 
      try 
      { 
       Console.WriteLine("Three={0}", list["Three"]); 
      } 
      catch 
      { 
       Console.WriteLine("Three does not exist."); 
      } 
     } 
     class MyList<T> 
     { 
      Dictionary<string, T> dictionary = new Dictionary<string,T>(); 

      internal T this[string property, T def] 
      { 
       get 
       { 
        T value; 
        if (!dictionary.TryGetValue(property, out value)) 
         dictionary.Add(property, value = def); 
        return value; 
       } 
      } 
      internal T this[string property] 
      { 
       get 
       { 
        return dictionary[property]; 
       } 
       set 
       { 
        dictionary[property] = value; 
       } 
      } 
     } 
    } 
} 

Answer 3

Я не уверен, но, возможно, динамические функции версии 4.0 помогут вам в этом. Вам придется подождать, хотя ...

Answer 4

Могу ли я спросить: Почему Не хотите ли вы индивидуальных свойств? Это идиоматический способ .NET выразить данные, связанные с объектом.

Лично, предполагая, что данные не редка, я хотел бы сохранить свойства и имеют общее использование метода отражения - это сделает ваш скомпилированный код как можно быстрее:

protected T Get<T>(string name, T @default) 
    { 
     var prop = GetType().GetProperty(name); 
     if(prop == null) return @default; 
     return (T) prop.GetValue(this, null); 
    } 

Конечно, если вы не заботятся о том, чтобы сами свойства были определены, тогда индекс и поиск (например, словарь) были бы в порядке. Есть также вещи, которые вы могли бы сделать с помощью postsharp, чтобы превратить набор свойств в пакет свойств - вероятно, это не стоит того.

Если вы хотите, чтобы свойства были доступны для привязки данных и обнаружения выполнения, но не могут определить их во время компиляции, вам нужно будет посмотреть на динамические типы дескрипторов; либо ICustomTypeDescriptor, либо TypeDescriptionProvider - справедливая работа, но очень универсальная (дайте мне знать, если вы хотите получить дополнительную информацию).