具有动作/条件的属性

这不是个好主意

像你描述的那样做是不合理的困难,即使你成功做到了,结果也无法维持。

困难源于对属性参数的限制:

属性参数限制为 以下类型:

• 标量类型(bool、byte、char、short、int、long、float和double)
• string
• System.Type
• 枚举
• object (必须是上述类型之一的常量值)
• 任何上述类型的一维数组

很明显,将谓词压缩到上述任何类型中的唯一方法是编写一个字符串a-la 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. 财产和条件之间的确切关系有点隐蔽。

也具有编译时安全性

如果上述情况不令人满意,可以通过消除前两个问题并以较小的运行时成本改进第三个问题来进行改进。这个想法基于 well-known trick to provide compile-time safety 当引用属性名时:将它们指定为成员访问表达式,而不是将其指定为字符串。

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(财产和条件更加明显)。它仍然没有解决第二个问题:你无法判断 SomeProperty 仅通过查看其声明即可有条件地看到。

但是,您可以扩展代码以在运行时强制执行:

• 用自定义属性装饰有条件可见的财产
• 在构造函数内部,枚举用该属性修饰的类的所有财产以及可以从字典键派生的所有属性名
• 将两个枚举集合视为集合
• 如果集合不相等,则已修饰的财产与已定义条件可见性逻辑的属性之间存在不匹配;抛出异常

正如@Jon已经指出的,使用属性不是正确的方法。

在我的例子中,到目前为止最令人满意的解决方案是声明另一个带有后缀的属性 Hide ,包含条件检查代码,通过 ConfigWrapper 要检查是否添加此设置,请执行以下操作:

public SomeType SomeSetting1 { get; set; }

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

此设置必须声明为 protected (起初我做了一个 stupid mistake ),将其自身隐藏在公共设置中。

然后在配置包装器中:

    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

这有许多动态特征。