Question

如果你知道附属属性是什么，那么想象一下你需要完全提供2个或更多的属性（here就是一个例子）并且只有在所有这些属性被设置的情况下才会发生。

这听起来像向我调用带参数的方法，因此很简单。

有没有人尝试过这样的事情？我想象它可以用这种丑陋的解决方法解决我当前的问题（具有10倍的3属性）：

<TextBox local:DynamicBinding.Property1="{Binding IsCheckedPath}"
         local:DynamicBinding.Source1="{Binding IsCheckedSource}"
         local:DynamicBinding.Target1="IsChecked"
         local:DynamicBinding.Property2="{Binding WidthPath}"
         local:DynamicBinding.Source2="{Binding WidthSource}"
         local:DynamicBinding.Target2="Width"
         local:DynamicBinding.Property3="{Binding TextPath"
         local:DynamicBinding.Source3="{Binding TextSource}"
         local:DynamicBinding.Target3="Text" ... />

理想情况下，我喜欢这样的事情

<TextBox IsChecked="{Binding Path={Binding IsCheckedPath}, Source={Binding IsCheckedSource}}"
         Width="{Binding Path={Binding WidthPath}, Source={Binding WidthSource}}"
         Text="{Binding Path={Binding TextPath}, Source={Binding TextSource}}"

或者甚至更简短，任何想法？

Answer 1

好的，所以不要理想的绑定

Text="{Binding Path={Binding MyText}, Source={Binding MySource}}"

我建议使用开关属性

Text="{Binding BindingMyText}"

可以使用ViewModel 访客实现（它看起来更复杂，但它的目的是为了使非法国家无法代表）

internal abstract class IPropVisitor<A>
{
    internal abstract A bindingMyText(ModelA source);
    internal abstract void bindingMyText(ModelA source, A val);
    internal abstract A bindingMyText(ModelB source);
    internal abstract void bindingMyText(ModelB source, A val);
}

internal class ViewModelVisitor : IPropVisitor<string>, INotifyPropertyChanged
{
    internal ViewModelVisitor(ModelSource model)
    {
        modelSource = model;
        BindingMyText = "Test!";
    }
    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }
    override internal string bindingMyText(ModelA source)
    {
        return source.MyTextA;
    }
    override internal void bindingMyText(ModelA source, string val)
    {
        source.MyTextA = val;
    }
    override internal string bindingMyText(ModelB source)
    {
        return source.MyTextB;
    }
    override internal void bindingMyText(ModelB source, string val)
    {
        source.MyTextB = val;
    }
    private ModelSource modelSource;
    public ModelSource ModelSource
    {
        get { return modelSource; }
        set
        {
            modelSource = value;
            OnPropertyChanged("ModelSource");
            OnPropertyChanged("BindingMyText");
        }
    }
    public string BindingMyText
    {
        get
        {
            return modelSource.accept(this); 
        }
        set
        {
            modelSource.accept(this, value);
            OnPropertyChanged("BindingMyText");
        }
    }
}

和许多不同的模型来源

public abstract class ModelSource : ViewModelBase
{
    abstract internal A accept<A>(IPropVisitor<A> visitor);
    abstract internal void accept<A>(IPropVisitor<A> visitor, A val);
}

class ModelA : ModelSource
{
    private string myTextA;
    public string MyTextA
    {
        get { return myTextA; }
        set {
            myTextA = value;
            OnPropertyChanged("MyTextA");
        }
    }

    internal override A accept<A>(IPropVisitor<A> visitor)
    {
        return visitor.bindingMyText(this);
    }
    internal override void accept<A>(IPropVisitor<A> visitor, A val)
    {
        visitor.bindingMyText(this, val);
    }

}

class ModelB : ModelSource
{
    private string myTextB;
    public string MyTextB
    {
        get { return myTextB; }
        set
        {
            myTextB = value;
            OnPropertyChanged("MyTextB");
        }
    }
    internal override A accept<A>(IPropVisitor<A> visitor)
    {
        return visitor.bindingMyText(this);
    }

    internal override void accept<A>(IPropVisitor<A> visitor, A val)
    {
        visitor.bindingMyText(this, val);
    }
}

请注意，这只是基本的想法，因此它实际上是一个初始草案，并不打算自动适合任何特定的上下文...

带参数的附加方法

1 个答案: