Атрибут с действием/условием

Это не очень хорошая идея

Будет неоправданно сложно сделать что-то вроде того, что вы описываете, и результат не будет поддерживаться, даже если вам удастся это сделать.

Сложность связана с ограничениями на параметры атрибутов:

Параметры атрибутов ограничены постоянными значениями следующих типов:

• Скалярные типы (bool, byte, char, short, int, long, float и double)
• string
• System.Type
• перечисления
• object (должно быть постоянным значением одного из указанных выше типов)
• Одномерные массивы любого из вышеперечисленных типов

Очевидно, что единственный способ втиснуть предикат в любой из вышеперечисленных типов — это написать строку в стиле SQL, например

[Hide("foo = \"42\" && !bar")]
public object MyProperty { get; set; }

Затем вам нужно будет проанализировать эту строку во время выполнения, преобразовать ее в форму, пригодную для машинного использования, и решить, каким будет результат. И даже тогда было бы очень легко написать недопустимый предикат, поскольку строка полностью непрозрачна для компилятора.

Но есть альтернативы

Ваше предпринятое решение действительно пытается плыть против текущего - атрибуты не предназначены для инкапсуляции поведения во время выполнения. Вместо этого, почему бы просто не реализовать в вашем сериализуемом классе подходящий интерфейс? Например, вы можете начать с болотного стандарта

public interface IConditionalPropertySource
{
    bool IsPropertyApplicable(string propertyName);
}

class Test : IConditionalPropertySource
{
    public string SomeSetting { get; set; }

    public bool IsPropertyApplicable(string propertyName)
    {
        switch (propertyName)
        {
            case "SomeSetting":return DateTime.Now.DayOfWeek == DayOfWeek.Friday;
            default: return false;
        }
    }
}

Это сделает работу, но у нее есть некоторые недостатки:

1. Имена свойств не проверяются компилятором; как вызывающая сторона, так и реализация IsPropertyApplicable могут совершать ошибки (например, простые орфографические ошибки), которые не будут помечены.
2. Не сразу понятно, какие свойства являются условными, а какие нет, просто взглянув на их объявления.
3. Точная связь между свойствами и условиями несколько скрыта.

С безопасностью во время компиляции тоже

Если вышеперечисленное неудовлетворительно, вы можете улучшить его, устранив первые две проблемы и улучшив третью за небольшую стоимость времени выполнения. Идея основана на хорошо известном трюке для предоставления безопасность времени компиляции при обращении к именам свойств: вместо указания их в виде строки укажите их как выражения доступа к членам.

public interface IConditionalPropertySource<T>
{
    bool IsPropertyApplicable(Expression<Func<T, object>> expr);
}

Вы можете вызвать вышеуказанное как IsPropertyApplicable(o => o.SomeSetting) и получить "SomeSetting" в виде строки во время выполнения с помощью ((MemberExpression)expr.Body).Member.Name. Однако на самом деле мы не хотим работать с голой строкой в ​​любое время, потому что это будет означать, что проблема № 1, описанная выше, все еще существует.

Таким образом, вместо этого мы можем создать словарь, который сопоставляет выражения доступа к членам с логическими функциями, и предоставить компаратор равенства, который заменяет семантику равенства по умолчанию для выражений (ссылочное равенство) на равенство имени члена:

class Test : IConditionalPropertySource<Test>
{
    // Your properties here:
    public string SomeSetting { get; set; }

    // This is the equality comparer used for the dictionary below
    private class MemberNameComparer :
        IEqualityComparer<Expression<Func<Test, object>>>
    {
        public bool Equals(
            Expression<Func<Test, object>> lhs, 
            Expression<Func<Test, object>> rhs)
        {
            return GetMemberName(lhs).Equals(GetMemberName(rhs));
        }

        public int GetHashCode(Expression<Func<Test, object>> expr)
        {
            return GetMemberName(expr).GetHashCode();
        }

        private string GetMemberName(Expression<Func<Test, object>> expr)
        {
            return ((MemberExpression)expr.Body).Member.Name;
        }
    }

    // A dictionary that maps member access expressions to boolean functions
    private readonly IDictionary<Expression<Func<Test, object>>, Func<bool>> 
        conditions = new Dictionary<Expression<Func<Test, object>>, Func<bool>>
        (new MemberNameComparer())
        {
            // The "SomeSetting" property is only visible on Wednesdays
            { 
                self => self.SomeSetting, 
                () => DateTime.Now.DayOfWeek == DayOfWeek.Wednesday
            }
        };


    // This implementation is now trivial
    public bool IsPropertyApplicable(Expression<Func<Test, object>> expr)
    {
        return conditions[expr]();
    }
}

Это устраняет проблему № 1 (вы больше не можете ошибаться в именах свойств, компилятор это уловит) и улучшает № 3 (свойства и условия несколько более заметны). Он по-прежнему оставляет проблему № 2 нерешенной: вы не можете сказать, является ли SomeProperty условно видимым, просто взглянув на его объявление.

Однако вы можете расширить код, чтобы применить это во время выполнения:

• Украсьте условно видимые свойства пользовательским атрибутом
• Внутри конструктора перечислите все свойства класса, украшенные этим атрибутом, и все имена свойств, которые могут быть получены из ключей словаря.
• Рассматривать обе перечисленные коллекции как наборы
• Если наборы не равны, существует несоответствие между декорированными свойствами и свойствами, для которых определена логика условной видимости; бросить исключение

Как уже указывал @Jon, использование атрибутов - неправильный путь.

В моем случае наиболее удовлетворительным решением на данный момент является объявление другого свойства с суффиксом Hide, которое содержит код проверки условия и используется посредством отражения в ConfigWrapper для проверки добавления этого параметра или нет:

public SomeType SomeSetting1 { get; set; }

public SomeType SomeSetting2 { get; set; }
protected SomeType SomeSetting2Hide { get { return SomeSetting3 = 4 && SomeSettings4 < 100; } }

Этот параметр должен быть объявлен как protected (сначала я сделал глупую ошибку), чтобы скрыть его от общедоступных настроек.

И затем в оболочке конфигурации:

    public ConfigWrapper(object obj)
    {
        _original = obj;
        // copy all properites
        foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(obj))
        {
            // filter hideable attributes
            bool add = true;
            foreach (Attribute attribute in property.Attributes)
                if (attribute is Common.IHide && (attribute as Common.IHide).Hide)
                {
                    add = false;
                    break;
                }

            ////////////////////////

            // filter configurable via hide property properties
            var hide = obj.GetType().GetProperty(property.Name + "Hide", BindingFlags.Instance | BindingFlags.NonPublic);
            if (hide != null && (bool)hide.GetValue(obj, null))
                add = false;

            ///////////////////////

            // add
            if (add)
                _collection.Add(new ConfigDescriptor(property));
        }
    }

Вы можете посмотреть на этот фреймворк:

http://www.codeproject.com/Articles/415070/Dynamic-Type-Description-Framework-for-PropertyGri

У этого есть много динамических featuers.