以类型安全的方式处理 PropertyChanged

Question

有很多文章介绍如何使用反射和 LINQ 以类型安全的方式引发 PropertyChanged 事件，而不使用字符串。

但是有没有办法以类型安全的方式使用 PropertyChanged 事件呢？目前，我正在这样做

void model_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    switch (e.PropertyName)
    {
        case "Property1":
            ...
        case "Property2":
            ...

        ....               
    }
}

有没有办法避免在 switch 语句中硬编码字符串来处理不同的属性？一些类似的基于 LINQ 或基于反射的方法？

Answer 1

对于 C# 6.0，您可以使用 nameof。您还可以引用类的属性，而无需创建该类的实例。

void model_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    switch (e.PropertyName)
    {
        case nameof(ClassName.Property1):
            ...
        case nameof(ClassName.Property2):
            ...

        ....               
    }
}

Answer 2

让我们声明一个可以将 lambda 表达式转换为 Reflection PropertyInfo 对象的方法 (取自我的回答）：

public static PropertyInfo GetProperty<T>(Expression<Func<T>> expr)
{
    var member = expr.Body as MemberExpression;
    if (member == null)
        throw new InvalidOperationException("Expression is not a member access expression.");
    var property = member.Member as PropertyInfo;
    if (property == null)
        throw new InvalidOperationException("Member in expression is not a property.");
    return property;
}

然后让我们用它来获取属性的名称：

void model_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    if (e.PropertyName == GetProperty(() => Property1).Name)
    {
        // ...
    }
    else if (e.PropertyName == GetProperty(() => Property2).Name)
    {
        // ...
    }
}

不幸的是你不能使用 switch 语句，因为属性名称不再是编译时常量。

Answer 3

我最近提出的一个解决方案是将事件调度逻辑封装到一个专用的类中。

该类有一个名为 Handle 的公共方法，它与 PropertyChangedEventHandler 委托具有相同的签名，这意味着它可以订阅任何类的 PropertyChanged 事件实现 INotifyPropertyChanged 接口。

该类接受委托，就像大多数 WPF 实现中经常使用的 DelegateCommand 一样，这意味着无需创建子类即可使用它。

该类如下所示：

public class PropertyChangedHandler
{
    private readonly Action<string> handler;
    private readonly Predicate<string> condition;
    private readonly IEnumerable<string> properties;

    public PropertyChangedHandler(Action<string> handler, 
        Predicate<string> condition, IEnumerable<string> properties)
    {
        this.handler = handler;
        this.condition = condition;
        this.properties = properties;
    }

    public void Handle(object sender, PropertyChangedEventArgs e)
    {
        string property = e.PropertyName ?? string.Empty;

        if (this.Observes(property) && this.ShouldHandle(property))
        {
            handler(property);
        }
    }

    private bool ShouldHandle(string property)
    {
        return condition == null ? true : condition(property);
    }

    private bool Observes(string property)
    {
        return string.IsNullOrEmpty(property) ? true :
            !properties.Any() ? true : properties.Contains(property);
    }
}

然后，您可以像这样注册属性更改事件处理程序：

var eventHandler = new PropertyChangedHandler(
    handler: p => { /* event handler logic... */ },
    condition: p => { /* determine if handler is invoked... */ },
    properties: new string[] { "Foo", "Bar" }
);

aViewModel.PropertyChanged += eventHandler.Handle;

PropertyChangedHandler 负责检查 PropertyChangedEventArgs 的 PropertyName并确保通过正确的属性更改来调用handler。

请注意，PropertyChangedHandler 还接受谓词，以便可以有条件地分派处理程序委托。该类还允许您指定多个属性，以便单个处理程序可以一次性绑定到多个属性。

这可以使用一些扩展方法轻松扩展，以实现更方便的处理程序注册，这允许您创建事件处理程序并在单个方法调用中订阅 PropertyChanged 事件，并使用表达式而不是字符串指定属性实现看起来像这样的东西：

aViewModel.OnPropertyChanged(
    handler: p => handlerMethod(),
    condition: p => handlerCondition,
    properties: aViewModel.GetProperties(
        p => p.Foo,
        p => p.Bar,
        p => p.Baz
    )
);

这基本上是说，当 Foo、Bar 或 Baz 属性更改 handlerMethodhandlerCondition 为 true，则将调用 >。

提供了 OnPropertychanged 方法的重载来满足不同的事件注册要求。

例如，如果您想要注册一个为任何属性更改事件调用并且始终执行的处理程序，您可以简单地执行以下操作：

aViewModel.OnPropertyChanged(p => handlerMethod());

例如，如果您想要注册一个始终执行但仅针对单个事件的处理程序具体属性更改您可以执行以下操作：

aViewModel.OnPropertyChanged(
    handler: p => handlerMethod(),
    properties: aViewModel.GetProperties(p => p.Foo)
);

我发现这种方法在编写 WPF MVVM 应用程序时非常有用。想象一下，您有一个场景，当三个属性中的任何一个发生更改时，您希望使命令无效。使用普通方法，您必须执行以下操作：

void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)
{
    switch (e.PropertyName)
    {
        case "Foo":
        case "Bar":
        case "Baz":
            FooBarBazCommand.Invalidate();
            break;
        ....               
    }
}

如果更改任何 viewModel 属性的名称，您将需要记住更新事件处理程序以选择正确的属性。

使用上面指定的 PropertyChangedHandler 类，您可以通过以下方式获得相同的结果：

aViewModel.OnPropertyChanged(
    handler: p => FooBarBazCommand.Invalidate(),
    properties: aViewModel.GetProperties(
        p => p.Foo,
        p => p.Bar,
        p => p.Baz
    )
);

现在它具有编译时安全性，因此如果重命名任何 viewModel 属性，程序将无法编译。

Answer 4

Josh Smith 的 MVVM Foundation 包含一个 PropertyObserver 类，可以执行您想要的操作。

Answer 5

我通过组合命令模式和一些表达式逻辑来避免这种切换。您将案例操作封装在命令中。
我将使用模型视图控制器结构来说明这一点。 想法是相同的

现实世界代码 - WinForms，但当在模型中设置 Tree 属性时，示例在视图中加载树的

。 自定义 ICommand

void Execute();
string PropertyName  { get;  }

具体命令

 public TreeChangedCommand(TreeModel model, ISelectTreeView selectTreeView,Expression<Func<object>> propertyExpression )
    {
        _model = model;
        _selectTreeView = selectTreeView;

        var body = propertyExpression.Body as MemberExpression;
        _propertyName = body.Member.Name;

    }

构造函数控制器

 //handle notify changed event from model
  _model.PropertyChanged += _model_PropertyChanged;
  //init commands
  commands = new List<ICommand>();
  commands.Add(new TreeChangedCommand(_model,_mainView,()=>_model.Tree));

propertyChanged 处理程序

void _model_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
    //find the corresponding command and execute it. (instead of the switch)
    commands.FirstOrDefault(cmd=>cmd.PropertyName.Equals(e.PropertyName)).Execute();
}