8

我正在设置一个ViewModel具有许多属性的 WPF 应用程序。这些都是非常重复的，我想知道是否有办法摆脱这种情况。这是一处房产的样子，我有大约 8-10 处房产。

public string Name
{
    get
    {
        return this.name;
    }

    set
    {
        if (this.name != value)
        {
            this.name = value;
            this.RaisePropertyChanged("Name");
        }
    }
}
4

4 回答 4

5

如果您的要求很简单，我的建议是去第三方。这是一个已解决的问题，感谢一些聪明的人......

您可以编写代码的最简单的方法是INotifyPropertyChanged完全删除实现，并以最小的方式编写属性，如下所示：

public string Name { get; set; }

然后将Fody.PropertyChanged添加到您的项目（位于NuGet[ImplementPropertyChanged]上）并使用该属性标记您的类。

Fody 将在编译期间执行一些巧妙的 IL 魔术，以神奇的方式实现接口和所有样板代码 - 这意味着您编写的代码尽可能简单，最终结果正是您想要的。

请注意，如果您在代码中的其他地方依赖INotifyPropertyChanged接口（也就是说，如果您在代码或类似代码中手动附加到事件），您可能希望以不同的方式使用 Fody，因为 IDE 不会意识到您已经实现了接口. 幸运的是，Fody 也会在其他场景中自动实现（例如：INotifyPropertyChanged在类中实现，而 Fody 默认情况下也会在您的属性中实现事件引发）。

于 2013-10-22T10:23:23.613 回答
2

提到的线程确实包含答案，但您需要进行一些挖掘。我将展示我在那里找到的两个最佳答案。

第一种解决方案是实现一个 ViewModelBase 类，将 set 方法封装到模板方法中，并使用 lamda 表达式检索属性名称，因此重构不会破坏属性名称字符串。

public class ViewModelBase: INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }

    protected virtual void OnPropertyChanged<T>(Expression<Func<T>> selectorExpression)
    {
        if (selectorExpression == null)
            throw new ArgumentNullException("selectorExpression");
        var body = selectorExpression.Body as MemberExpression;
        if (body == null)
            throw new ArgumentException("The body must be a member expression");
        OnPropertyChanged(body.Member.Name);
    }

    protected bool SetField<T>(ref T field, T value, Expression<Func<T>> selectorExpression)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return false;
        field = value;
        OnPropertyChanged(selectorExpression);
        return true;
    }
}

用法：

class ViewModel : DataBase
{
    private String _prop1;
    public String Prop1
    {
        get { return _prop1; }
        set
        {
            SetField(ref _prop1, value, () => Prop1);
        }
    }
}

第二种解决方案使用 Dictionary 将属性存储在基类中。这样我们就不需要传入旧值，因为它保存在基类中，并且我们不需要创建成员字段来保存属性的值。我最喜欢这个解决方案：

public abstract class ViewModelBase : INotifyPropertyChanged
{
    private readonly Dictionary<string, object> _propertyValueStorage;

    #region Constructor

    protected ViewModelBase()
    {
        this._propertyValueStorage = new Dictionary<string, object>();
    }

    #endregion

    protected void SetValue<T>(Expression<Func<T>> property, T value)
    {
        var lambdaExpression = property as LambdaExpression;

        if (lambdaExpression == null)
        {
            throw new ArgumentException("Invalid lambda expression", "Lambda expression return value can't be null");
        }

        var propertyName = this.getPropertyName(lambdaExpression);
        var storedValue = this.getValue<T>(propertyName);

        if (object.Equals(storedValue, value)) return;

        this._propertyValueStorage[propertyName] = value;
        this.OnPropertyChanged(propertyName);
    }

    protected T GetValue<T>(Expression<Func<T>> property)
    {
        var lambdaExpression = property as LambdaExpression;

        if (lambdaExpression == null)
        {
            throw new ArgumentException("Invalid lambda expression", "Lambda expression return value can't be null");
        }

        var propertyName = this.getPropertyName(lambdaExpression);
        return getValue<T>(propertyName);
    }

    private T getValue<T>(string propertyName)
    {
        object value;
        if (_propertyValueStorage.TryGetValue(propertyName, out value))
        {
            return (T)value;
        }
        return default(T);

    }

    private string getPropertyName(LambdaExpression lambdaExpression)
    {
        MemberExpression memberExpression;

        if (lambdaExpression.Body is UnaryExpression)
        {
            var unaryExpression = lambdaExpression.Body as UnaryExpression;
            memberExpression = unaryExpression.Operand as MemberExpression;
        }
        else
        {
            memberExpression = lambdaExpression.Body as MemberExpression;
        }

        return memberExpression.Member.Name;
    }

    #region < INotifyPropertyChanged > Members

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        if (this.PropertyChanged != null)
        {
            this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    #endregion

}

用法是：

public class ViewModel : ViewModelBase
{
    public String Prop1
    {
        get { return GetValue(() => Prop1); }
        set { SetValue(() => Prop1, value); }
    }
    public bool Bool1
    {
        get { return GetValue(() => Bool1); }
        set { SetValue(() => Bool1, value); }
    }

解决方案 1 基于https://stackoverflow.com/a/1316566/2259878和https://stackoverflow.com/a/1316566/2259878

解决方案 2 基于http://dotnet-forum.de/blogs/thearchitect/archive/2012/11/01/die-optimale-implementierung-des-inotifypropertychanged-interfaces.aspx

于 2013-10-22T05:56:23.067 回答
0

我的解决方案接近于 uncletall 的解决方案，但在使用上有一些变化

    private static readonly Properties<MainWindowViewModel> _properties = new Properties<MainWindowViewModel>();

    public static Property TextProperty = _properties.Create(_ => _.Text);
    private string _text;
    public string Text
    {
        get { return _text; }
        set { SetProperty(ref _text, value, TextProperty); }
    }

XAML：

<Label Grid.Row="1" Content="{Model:PropertyBinding  {x:Static Model:MainWindowViewModel.TextProperty}}" Width="200"/>

此示例的好处是在编译时检查更改。完整示例链接

于 2013-10-22T10:08:49.630 回答
0

这取决于需求，如果所有属性都用于相同的目的意味着像name1，name2，name3.....name10，比如列出10个人的名字，然后放入另一个类并绑定类类型的集合到您的 xaml 中的项目控制。或者简单地绑定字符串的 ObservableCollection

但是，如果每个属性都有自己的用途，那就无法避免，因为属性只不过是保存不同值的变量。每个属性都有自己的意图，并且对每个属性的操作在视图模型中会有所不同，具体取决于逻辑

于 2013-10-22T02:40:27.773 回答