Резервные средства доступа в C #? - PullRequest
Новая
       12

Резервные средства доступа в C #?

2 голосов
/ 01 февраля 2009

Есть ли в C # что-то похожее на Python __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?

Спасибо

Ответы [ 4 ]

2 голосов
/ 01 февраля 2009

Нет. Хотя C # поддерживает отражение, оно доступно только для чтения (для загруженных сборок). Это означает, что вы не можете изменять какие-либо методы, свойства или любые другие метаданные. Хотя вы могли бы создать динамическое свойство , вызывать его было бы не очень удобно - это было бы даже хуже, чем при использовании вашего метода 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 во время компиляции.

1 голос
/ 01 февраля 2009

Могу я спросить: почему вам не нужны отдельные свойства? Это идиоматический способ .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 - трудоемкий, но очень универсальный (дайте мне знать, если вам нужна дополнительная информация).

1 голос
/ 01 февраля 2009

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

0 голосов
/ 01 февраля 2009

Это не то же самое, что вы получаете в 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;
                }
            }
        }
    }
}
...