MVVM 模型应该是什么样的？

发布于 2024-11-07 11:40:29 字数 266 浏览 0 评论 0 原文

您好，我有 3 个关于 MVVM 模型的问题。

有没有办法绕过冗余的 PropertyChanged("PropName");
将 POCO 对象包装到 WPF 的最佳方法是什么 INotifyPropertyChanged, IDataErrorInfo
我应该如何与（WPfWrapers - POCO）在 ViewModel 内 - 通过强制转换或属性...

谢谢。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

心清如水 2024-11-14 11:40:29

这里有 3 个答案：

您可以找到引发 PropertyChanged 事件的替代方案，而无需在 .NET 社区。然而，它们都有其他缺点（例如性能）。
最好的方法是直接在模型中实现 INotifyPropertyChanged 和 IDataErrorInfo。这并不总是可能的。如果您需要包装模型类，那么您可能会查看 DataModel 概念。
我不确定我是否理解了最后一个问题，但这是一个答案。 ViewModel 或 DataModel 应直接与模型交互。但这些类不应该以直接的方式与视图交互。对于此类场景，请使用接口（例如 IView）。

更多信息可在此处找到：WPF 应用程序框架 (WAF)

回复收藏 0 原文

[浮城] 2024-11-14 11:40:29

是的，您可以使用 Lamdba 表达式来完成此操作。但这会花费一些处理器时间（进行一些快速测量：这种方法比使用字符串常量慢大约 200 倍。在频繁使用的 POCO 上使用表达式时请记住这一点）：

私有字符串 ExtractPropertyName( Expression> propertyExpresssion )
{
    if ( 属性表达式 == null )
    {
        抛出新的ArgumentNullException（“propertyExpression”）；
    }

    var memberExpression = propertyExpression.Body as MemberExpression;
    if ( 成员表达式 == null )
    {
        throw new ArgumentException( "该表达式不是成员访问表达式。", "propertyExpression" );
    }

    var property = memberExpression.Member as PropertyInfo;
    if ( 属性 == null )
    {
        throw new ArgumentException( "成员访问表达式未访问属性。", "propertyExpression" );
    }

    if ( !property.DeclaringType.IsAssignableFrom( this.GetType( ) ) )
    {
        throw new ArgumentException( "引用的属性属于不同类型。", "propertyExpression" );
    }

    var getMethod = property.GetGetMethod( true );
    if ( getMethod == null )
    {
        // 这不应该发生 - 表达式会在到达这么远之前拒绝该属性
        throw new ArgumentException( "引用的属性没有 get 方法。", "propertyExpresssion" );
    }

    if ( getMethod.IsStatic )
    {
        throw new ArgumentException( "引用的属性是静态属性。", "propertyExpression" );
    }

    返回memberExpression.Member.Name；
}

私有字符串 myProperty；
公共字符串我的财产
{
    得到
    {
        归还我的财产；
    }
    放
    {
        我的属性=值；
        this.RaisePropertyChanged( ( ) => MyProperty );
    }
}

protected void RaisePropertyChanged( Expression> propertyExpression )
{
    var 属性名称 = ExtractPropertyName( 属性表达式 );
    this.RaisePropertyChanged( propertyName );
}

我认为您不这样做必须包装它们（除了创建相应的视图模型之外）。 POCO 用作模型，接口由视图模型实现。
当您不包装 POCO 时，这个问题就已经过时了。

Yes, you can do this with a Lamdba expression. But this will cost some processor time (made some quick measurements: this approach is around 200 times slower than using the the string constant. Keep this in mind when using the expression on highly frequented POCOs):

private string ExtractPropertyName<T>( Expression<Func<T>> propertyExpresssion )
{
    if ( propertyExpresssion == null )
    {
        throw new ArgumentNullException( "propertyExpresssion" );
    }

    var memberExpression = propertyExpresssion.Body as MemberExpression;
    if ( memberExpression == null )
    {
        throw new ArgumentException( "The expression is not a member access expression.", "propertyExpresssion" );
    }

    var property = memberExpression.Member as PropertyInfo;
    if ( property == null )
    {
        throw new ArgumentException( "The member access expression does not access a property.", "propertyExpresssion" );
    }

    if ( !property.DeclaringType.IsAssignableFrom( this.GetType( ) ) )
    {
        throw new ArgumentException( "The referenced property belongs to a different type.", "propertyExpresssion" );
    }

    var getMethod = property.GetGetMethod( true );
    if ( getMethod == null )
    {
        // this shouldn't happen - the expression would reject the property before reaching this far
        throw new ArgumentException( "The referenced property does not have a get method.", "propertyExpresssion" );
    }

    if ( getMethod.IsStatic )
    {
        throw new ArgumentException( "The referenced property is a static property.", "propertyExpresssion" );
    }

    return memberExpression.Member.Name;
}

private string myProperty;
public string MyProperty
{
    get
    {
        return myProperty;
    }
    set
    {
        myProperty = value;
        this.RaisePropertyChanged( ( ) => MyProperty );
    }
}

protected void RaisePropertyChanged<T>( Expression<Func<T>> propertyExpression )
{
    var propertyName = ExtractPropertyName( propertyExpression );
    this.RaisePropertyChanged( propertyName );
}

I think you don't have to wrap them (besides creating a coresponding view model). The POCOs are used as model and the interfaces are implemented by the viewmodel.
This question is obsolete when you don't wrap the POCOs.