c# - 生成一个强类型代理，当一个属性设置为另一个属性时，它可以跟踪属性名称而不是值的变化

Question

设置:

public class Data
{
    public int A { get; set; }
    public int B { get; set; }
}

public class Runner
{
    public static void Run(Data data)
    {
        data.A = data.B;
        data.A = 1;
    }
}

class Program
{
    static void Main(string[] args)
    {
        var data = new Data() { A = 1, B = 2 };
        Runner.Run(data);
    }
}

问题:我需要在此处对属性名称而不是值实现更改跟踪。在 Runner.Run 的第一行 data.A = data.B 中，我需要以某种方式记录“A”被设置为“B”(字面上的属性names) 然后在下一行 data.A = 1 我需要记录“A”被设置为常量并说忘记它。

约束:

• 将一个属性设置为另一个需要记录的属性(例如 A = B)时
• 将属性设置为任何其他值(例如 A = 1 或 A = B * 2)时，需要忘记此更改(例如只记住 A)

假设这是正在使用的跟踪器合约:

void RecordChange(string setterName, string getterName);
void UnTrackChange(string setterName);

问题:我想以某种方式代理 Data 类，以便它仍然可以在界面代码中使用(例如 Runner - 是一大堆使用 Data) 包括强类型，它可以在不修改代码的情况下跟踪它的变化(例如，有很多地方像'data.A = data.B')。

有没有什么办法可以不求助于一些涉及 IL 生成的魔法？

已经调查/尝试过:

• PostSharp 拦截器/带拦截器的 CaSTLe.DynamicProxy - 仅靠这些无法提供帮助。我能从中得到的最多是在 setter 拦截器中有一个 data.B 的值，而不是 nameof(data.B)。
• 编译器服务 - 在这里找不到合适的东西 - 获取调用者的名字并没有真正帮助。
• Runtine 代码生成 - 类似于从 DynamicObject 继承的代理或使用 Relfection.Emit(可能是 TypeBuilder) - 我输掉了输入。

当前解决方案:

使用上述合约的 Tracker 实现并将其传递到后续的每个函数中。然后不用写 data.A = data.B 使用方法 tracker.SetFrom(x => x.A, x => x.B) - tracker 持有一个 Data instance 这样就可以了。但是在真实的代码库中，很容易遗漏某些东西，这只会降低代码的可读性。

Answer 1

这是我想出的最接近的解决方案。它并不完美，因为我仍然需要修改客户端代码中的所有契约/方法以使用新的数据模型，但至少所有逻辑都保持不变。

所以我愿意接受其他答案。

这是更新后的 Data 模型:

public readonly struct NamedProperty<TValue>
{
    public NamedProperty(string name, TValue value)
    {
        Name = name;
        Value = value;
    }

    public string Name { get; }
    public TValue Value { get; }

    public static implicit operator TValue (NamedProperty<TValue> obj)
        => obj.Value;

    public static implicit operator NamedProperty<TValue>(TValue value)
        => new NamedProperty<TValue>(null, value);
}

public interface ISelfTracker<T> 
    where T : class, ISelfTracker<T>
{
    Tracker<T> Tracker { get; set; }
}

public class NamedData : ISelfTracker<NamedData>
{
    public virtual NamedProperty<int> A { get; set; }
    public virtual NamedProperty<int> B { get; set; }

    public Tracker<NamedData> Tracker { get; set; }
}

基本上我已经复制粘贴了原始的 Data 模型，但更改了它的所有属性以了解它们的名称。

然后是跟踪器本身:

public class Tracker<T> 
    where T : class, ISelfTracker<T>
{
    public T Instance { get; }
    public T Proxy { get; }

    public Tracker(T instance)
    {
        Instance = instance;
        Proxy = new ProxyGenerator().CreateClassProxyWithTarget<T>(Instance, new TrackingNamedProxyInterceptor<T>(this));
        Proxy.Tracker = this;
    }

    public void RecordChange(string setterName, string getterName)
    {
    }

    public void UnTrackChange(string setterName)
    {
    }
}

CaSTLe.DynamicProxy 的拦截器:

public class TrackingNamedProxyInterceptor<T> : IInterceptor
    where T : class, ISelfTracker<T>
{
    private const string SetterPrefix = "set_";
    private const string GetterPrefix = "get_";

    private readonly Tracker<T> _tracker;

    public TrackingNamedProxyInterceptor(Tracker<T> proxy)
    {
        _tracker = proxy;
    }

    public void Intercept(IInvocation invocation)
    {
        if (IsSetMethod(invocation.Method))
        {
            string propertyName = GetPropertyName(invocation.Method);
            dynamic value = invocation.Arguments[0];

            var propertyType = value.GetType();
            if (IsOfGenericType(propertyType, typeof(NamedProperty<>)))
            {
                if (value.Name == null)
                {
                    _tracker.UnTrackChange(propertyName);
                }
                else
                {
                    _tracker.RecordChange(propertyName, value.Name);
                }

                var args = new[] { propertyName, value.Value };
                invocation.Arguments[0] = Activator.CreateInstance(propertyType, args);
            }
        }

        invocation.Proceed();
    }

    private string GetPropertyName(MethodInfo method)
        => method.Name.Replace(SetterPrefix, string.Empty).Replace(GetterPrefix, string.Empty);

    private bool IsSetMethod(MethodInfo method)
        => method.IsSpecialName && method.Name.StartsWith(SetterPrefix);

    private bool IsOfGenericType(Type type, Type openGenericType)
        => type.IsGenericType && type.GetGenericTypeDefinition() == openGenericType;
}

以及修改后的入口点:

static void Main(string[] args)
{
    var data = new Data() { A = 1, B = 2 };
    NamedData namedData = Map(data);
    var proxy = new Tracker<NamedData>(namedData).Proxy;
    Runner.Run(proxy);

    Console.ReadLine();
}

Map()函数实际上是将Data映射到NamedData填写属性名。