C# What is the best practice to pass a parameter as method argument to both get AND set data from a generic class

Question

I'm fairly new to extension methods and i was wanting to make something very generic to re-order any type of list of an Entity Framework DbSet<TEntity>. To do so, i'd need to precise what property the entity is using as it's "Order" field. The most elegant way that was working for me was by using the property name (string) as the argument to then use it to get the PropertyInfo.

public static void OrderList<TModel>(this List<TModel> list, string propertyName)
{
  PropertyInfo property = typeof(TModel).GetProperty(propertyName);
  list.OrderList(property);
}

public static void OrderList<TModel>(this List<TModel> list, PropertyInfo property)
{
  var order = (int)list.Min(x => property.GetValue(x));
  list.ForEach(x => { property.SetValue(x, order++); });
}

// Called this way:
myList.OrderList(nameof(Class.OrderProperty));

The thing is that i'm not much of a fan of the whole "nameof(Class.Property)"... Would there be a better way to do so? I tried to use Func<TModel, int> property because i REALLY like how you call these list.function(x => x.Property), i really think it's the easiest one to understand. But I've come to learn that you can only get data from this, to set data i'd have to use an "Action" delegate to also set data, but then i'd have to enter the same property twice and it's not helping much... Only other option i can think of is using System.Linq.Expressions but i'm very unfamiliar with those and have no idea how to use them or even if it could solve my problem...

Hope this made sense and thank you for taking the time to read this!

Answer 1

Here's how I would do it with Expression<T>:

public static void OrderList<TModel>(this IList<TModel> list, Expression<Func<TModel, int>> propertyExpression) 
    where TModel : notnull
    => list.OrderList(propertyExpression, i => ++i);
public static void OrderList<TModel>(this IList<TModel> list, Expression<Func<TModel, uint>> propertyExpression) 
    where TModel : notnull
    => list.OrderList(propertyExpression, i => ++i);
public static void OrderList<TModel>(this IList<TModel> list, Expression<Func<TModel, long>> propertyExpression) 
    where TModel : notnull
    => list.OrderList(propertyExpression, i => ++i);
public static void OrderList<TModel>(this IList<TModel> list, Expression<Func<TModel, ulong>> propertyExpression) 
    where TModel : notnull
    => list.OrderList(propertyExpression, i => ++i);

public static void OrderList<TModel, TProperty>(
    this IList<TModel> list,
    Func<object?, object?> getMember,
    Action<object?, object?> setMember,
    Func<TProperty, TProperty> increment)

    where TModel: notnull
    where TProperty : struct, IComparable<TProperty>
{
    TProperty order = list.Min(item => (TProperty)getMember(item)!);

    for (int i = 0; i < list.Count; i++)
    {
        // 'for' (as opposed to 'foreach'),
        // 'object item' (as opposed to 'TModel item'),
        // and list[i] = (TModel)item;
        // are needed, otherwise the method will not work for structs!

        object item = list[i];

        setMember(item, order);
        order = increment(order);

        // .IsValueType is a compile time constant, no checking at runtime occurs
        if (typeof(TModel).IsValueType)
        {
            list[i] = (TModel)item;
        }
    }
}

public static void OrderList<TModel, TProperty>(
    this IList<TModel> list, 
    Expression<Func<TModel, TProperty>> propertyExpression,
    Func<TProperty, TProperty> increment)

    where TModel : notnull
    where TProperty : struct, IComparable<TProperty>
{
    if(propertyExpression is null)
        throw new ArgumentNullException(nameof(propertyExpression));

    if (propertyExpression.NodeType != ExpressionType.Lambda)
        throw new ArgumentException($"{nameof(propertyExpression)} must be a lambda expression", nameof(propertyExpression));

    if(propertyExpression.Body is not MemberExpression memberExp)
        throw new ArgumentException(
            $"{nameof(propertyExpression)} must be an expression which accesses (reads) a field or a property", 
            nameof(propertyExpression));
    
    if(propertyExpression.Parameters.Single().Name != (memberExp.Expression as ParameterExpression)?.Name)
        throw new ArgumentException(
            $@"{nameof(propertyExpression)} must access a field or a property on the ""{typeof(TModel).Name}"" argument",
            nameof(propertyExpression));
    

    var memberInfo = memberExp.Member;

    if(memberInfo 
        is not FieldInfo
        {
            IsInitOnly: false,
            IsLiteral: false
        }
        and not PropertyInfo
        {
            CanRead: true,
            CanWrite: true
        })
    {
        throw new ArgumentException(
            $@"The field or property {nameof(propertyExpression)} accesses must be readable and writable",
            nameof(propertyExpression));
    }

    Func<object?, object?> getMember;
    Action<object?, object?> setMember;

    if (memberInfo is FieldInfo fieldInfo)
    {
        getMember = fieldInfo.GetValue;
        setMember = fieldInfo.SetValue;
    }
    else if (memberInfo is PropertyInfo propertyInfo)
    {
        getMember = propertyInfo.GetValue;
        setMember = propertyInfo.SetValue;
    }
    else throw new NotImplementedException($"{nameof(MemberInfo)} object has an unexpected type {memberInfo.GetType().Name}");

    list.OrderList(getMember, setMember, increment);
}