1

我需要两个相似对象（C#）之间的绑定：

public class TypeA
{
     public int I;
     public string S;
}

public class TypeB
{
     public IntField I;
     public StringField S;
}

当 TypeA 中的字段发生更改时，我需要更新 TypeB 中的匹配字段。

IntField 是一个具有 int 类型的 Value 字段的对象，因此更新 TypeB 可以写为：

bInstance.I.Value = aInstance.I;

如果我理解正确，如果我使用 INotifyPropertyChanged 将 TypeB 绑定到 TypeA，它将导致样板：

aInstance.PropertyChanged += (sender, args) =>
{
    if (args.PropertyName == "I")
        this.I.Value = sender.I;
    if (args.PropertyName == "S")
        this.S.Value = sender.S;
};

还：

  • 我可以访问这两种类型的代码，我宁愿不更改 TypeB。
  • 我有大约 15 对类型，例如 TypeA 和 TypeB - 我想避免样板文件。
  • 性能非常重要，因此反射不是首选选项。
  • 也许静态反射是一种选择？我听说过，但我不确定：
    • 如何在没有样板的情况下使用它。
    • 它的表现。
    • 将它用于相同类型对的不同实例（即 a1Instance->b1Instance、a2Intance->b2Instance 等）。

编辑：

IntField 是一个类。它用于系统中存在的另一种类型的数据绑定（复杂，整个系统都依赖于此）。它继承自表示通用可绑定字段的类。这是其中的一部分：

public class IntField : GeneralField
{
    private int _value;
    public int Value
    {
        get { return _value; }
        set
        {
            IsDirty = true;
            _value = value;
        }
    }

    // ... a couple of abstract method implementations go here (setting _value, and getting value in a non-type specific way)
}
4

1 回答 1

1

如果您不想要大量的手动编码，那么基于反射或基于元编程的东西将是您最好的选择。例如：

static void Entwine(INotifyPropertyChanged source, object target)
{
    source.PropertyChanged += (sender,args) =>
    {
        var prop = target.GetType().GetProperty(args.PropertyName);
        if(prop != null)
        {
            var field = prop.GetValue(target) as GeneralField;
            if(field != null)
            {
                var newVal = source.GetType().GetProperty(args.PropertyName)
                                   .GetValue(source);
                field.SetValue(newVal); // <=== some method on GeneralField
            }
        }
    };
}

在许多情况下这会很好，但如果反射确实是一个问题，FastMember 之类的工具可以提供帮助：

static void Entwine(INotifyPropertyChanged source, object target)
{
    var sourceAccessor = ObjectAccessor.Create(source);
    var targetAccessor = ObjectAccessor.Create(target);
    source.PropertyChanged += (sender, args) =>
    {
        var field = targetAccessor[args.PropertyName] as GeneralField;
        if (field != null)
        {
            var newVal = sourceAccessor[args.PropertyName];
            field.SetValue(newVal);
        }
    };
}

这比反射快得多——它使用了很多技巧来避免痛苦。这只是需要类似的东西：

abstract class GeneralField
{
    // ...
    public abstract void SetValue(object value);
}
class Int32Field : GeneralField
{
    // ...
    public override void SetValue(object value)
    {
        Value = (int)value;
    }
}

当然还有你的INotifyPropertyChanged实现，例如：

public class TypeA : INotifyPropertyChanged
{
    private int i;
    private string s;
    public int I
    {
        get { return i; }
        set { SetField(ref i, value); }
    }
    public string S
    {
        get { return s; }
        set { SetField(ref s, value); }
    }
    private void SetField<T>(ref T field, T value,
        [CallerMemberName]string propertyName = null)
    {
        if (!EqualityComparer<T>.Default.Equals(field, value))
        {
            field = value;
            var handler = PropertyChanged;
            if (handler != null) handler(
                this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}
于 2013-06-25T08:39:19.547 回答