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

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”（字面意思是属性名称），然后在下一行data.A = 1我需要记录那个“A”被设置为常数并说忘了它。

约束：

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

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

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

问题：我想以某种方式代理Data class 以便它仍然可以在接口代码中使用（例如Runner - 是一大堆使用Data的业务逻辑代码）包括强类型，它可以跟踪它的变化而无需修改代码（例如，有很多地方像'data.A = data.B'）。

有没有办法在不求助于我猜一些涉及 IL 生成的魔法的情况下做到这一点？

已经调查/尝试过：

• 带有拦截器的 PostSharp 拦截器/Castle.DynamicProxy - 仅此而已。 我能从中得到的最多是在 setter 拦截器中有一个data.B的值，而不是nameof(data.B) 。
• 编译器服务 - 在这里没有找到任何合适的东西 - 获取调用者的名字并没有真正帮助。
• Runtine 代码生成 - 类似于从 DynamicObject 继承的代理或使用 Relfection.Emit（可能是 TypeBuilder） - 我失去了打字。

当前解决方案：

使用上述合约的 Tracker 实现，并将其传递给未来的每个 function。 然后不要写data.A = data.B使用方法tracker.SetFrom(x => xA, x => xB) - tracker 持有一个Data实例，所以这是可行的。 但是在真实的代码库中，很容易遗漏一些东西，而且只会降低可读性。

Answer 1

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

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

这是更新的Data model：

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 model 但更改了它的所有属性以了解它们的名称。

然后是跟踪器本身：

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() function 实际上将Data映射到NamedData填充属性名称。