Создание универсального селектора/установщика свойств на C#, если вы знаете тип только во время выполнения

Прежде всего: Вы утверждаете, что сигнатура метода — void Patch<T, U>(string id, Expression<Func<T, TProperty>> fieldPath, TProperty value), где T и TProperty — значимые параметры, но U — это параметр, на который нет ссылок: я предполагаю, что U должно быть TProperty.

Теперь, я думаю, вам нужен метод расширения для вызова метода Patch, указывающий цель PropertyInfo или указав ее имя вместе с объявляющим типом. Эти две альтернативы — минимум для построения ожидаемого Expression<T, TProperty>.

Взгляните на следующий код:

Вероятное исходное определение класса (при условии, что описанный метод Patch исходит из интерфейса):

public interface IPatcher
{
    void Patch<T, TProperty>(string id, Expression<Func<T, TProperty>> fieldPath, TProperty value);
}
public class PatcherClass : IPatcher
{
    public void Patch<T, TProperty>(string id, Expression<Func<T, TProperty>> fieldPath, TProperty value)
    {
    }
}

Класс расширения

public static partial class IPatcherExtensions
{
    // Represents a callback to a convenient compiled method
    private delegate void PatchCallback(IPatcher self, string id, object? value);

    // Creates an instance of PatchCallback
    private static PatchCallback CreatePatchCallback(PropertyInfo info)
    {
        var parSelf = Expression.Parameter(typeof(IPatcher), "self");
        var parId = Expression.Parameter(typeof(string), "id");
        var parValue = Expression.Parameter(typeof(object), "value");

        var parTarget = Expression.Parameter(info.DeclaringType, "target");
        var exprGetter = Expression.Lambda(typeof(Func<,>).MakeGenericType(info.DeclaringType, info.PropertyType), Expression.Property(parTarget, info), parTarget);

        var exprValue = Expression.Convert(parValue, info.PropertyType);
        var body = Expression.Call(parSelf, nameof(IPatcher.Patch), new Type[] { info.DeclaringType, info.PropertyType }, parId, exprGetter, exprValue);

        var lambda = Expression.Lambda<PatchCallback>(body, parSelf, parId, parValue);

        return lambda.Compile();
    }

    // Caches PatchCallback instances for specific PropertyInfos
    private static readonly ConcurrentDictionary<PropertyInfo, PatchCallback> CacheForPropertyInfo = new();
    public static void Patch(this IPatcher self, string id, PropertyInfo info, object? value)
    {
        var callback = CacheForPropertyInfo.GetOrAdd(info, CreatePatchCallback);
        callback(self, id, value);
    }

    // Caches PatchCallback instances for pairs of Type/property names
    private static readonly ConcurrentDictionary<(Type TargetType, string PropertyName), PatchCallback> CacheForTypeAndPropertyName = new();
    public static void Patch(this IPatcher self, string id, Type targetType, string propertyName, object? value)
    {
        var callback = CacheForTypeAndPropertyName.GetOrAdd((targetType, propertyName), Factory);
        callback(self, id, value);
        static PatchCallback Factory((Type TargetType, string PropertyName) key)
        {
            var (targetType, propertyName) = key;
            var info = targetType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            Debug.Assert(info is not null);
            return CreatePatchCallback(info);
        }
    }
}

Пример использования:

IPatcher patcher = new PatcherClass();

// original
patcher.Patch<MyClass, string>("some_id", x => x.Id, "someValue");

// with type and property name
var declaringType = typeof(MyClass);
var propertyName = nameof(MyClass.Id);
patcher.Patch("some_id", declaringType, propertyName, "someValue");

// with property info
var propertyInfo = typeof(MyClass).GetProperty(nameof(MyClass.Id), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
patcher.Patch("some_id", propertyInfo, "someValue");

Обратите внимание, что здесь нет никаких проверок работоспособности или обнаружения ошибок: их следует реализовать для перехвата любых недопустимых пар PropertyInfo или Тип/имя.