Detecting and casting Linq expressions accordingly

Question

I wrote an extension method to make it easier to add multi-column indexes in EF 8 (.NET 8) as follows:

public static IndexBuilder<TEntityType> HasIndexUnique<TEntityType>
(
    this EntityTypeBuilder<TEntityType> builder,
    string indexName,
    IEnumerable<Expression<Func<TEntityType, object?>>> includeExpressions
) where TEntityType : class
{
    if ((includeExpressions is null) || (!includeExpressions.Any()))
    {
        var currentMethod = MethodBase.GetCurrentMethod();
        throw (new Exception($@"The method [{currentMethod?.DeclaringType?.FullName}.{currentMethod?.Name}] was called without any [{nameof(includeExpressions)}]."));
    }

    var propertyNames = includeExpressions
        .Select
        (
            e =>
            // Casting issue depending on what was sent in.
            ((MemberExpression) ((UnaryExpression) e.Body).Operand).Member.Name
        )
        .ToArray();

    var indexBuilder = builder
        .HasIndex
        (
            propertyNames,
            $@"{indexName}"
        )
        .IsUnique(unique: true);

    return (indexBuilder);
}

The built-in overloads of the EntityTypeBuilder<TEntityType>.HasIndex are string based (which I think is clunky). The overloads that support an Expression syntax only allow one column. The above method works like a charm and makes the calling code much easier to read.

builder
    .HasIndexUnique
    (
        "Index_IndexName_Unique",
        e => e.ModelId,
        e => e.ModelEntityPrincipleId,
        e => e.ModelEntityDependentId,
        e => e.ModelEntityBridgeId
    );

In the example above, all properties passed in are of type Int64. When I try to send in a String property, the expression cast fails.

builder.HasIndexUnique("Index_IndexName_Unique", e => e.Name);

// Exception at this line:
((MemberExpression) ((UnaryExpression) e.Body).Operand).Member.Name
System.InvalidCastException: 'Unable to cast object of type 'System.Linq.Expressions.PropertyExpression' to type 'System.Linq.Expressions.UnaryExpression'.'

How can I detect and handle properties of different types in order to cast them correctly? I already anticipate a few data types as follows and that should suffice:

Int64, String, DateTime, Object, Byte []

I would appreciate a solution, but would also like to understand what makes an expression Unary or Property or other types that I have not explored.

EDIT:

public partial class ModelEntityRelationship:
    IEntity<ModelEntityRelationship>
{
    public virtual long Id { get; set; }
    public virtual string Name { get; set; }

    public virtual long ModelId { get; set; }
    public virtual Model Model { get; set; }

    public virtual long ModelEntityPrincipleId { get; set; }
    public virtual ModelEntity ModelEntityPrinciple { get; set; } = new();

    public virtual long ModelEntityDependentId { get; set; }
    public virtual ModelEntity ModelEntityDependent { get; set; } = new();

    public virtual long? ModelEntityBridgeId { get; set; }
    public virtual ModelEntity? ModelEntityBridge { get; set; }
}

I am including the source Entity class to clarify my source of confusion. All property declarations are identical except their data types. So why would the expression type change from Unary to Property when sending in Int64 and String objects respectively?

Answer 1

I would suggest to create extension method which removes not needed convert, which is added by casting to object value types.

public static class ExpressionExtensions
{
    [return: NotNullIfNotNull(nameof(ex))]
    public static Expression? UnwrapConvert(this Expression? ex)
    {
        if (ex == null)
            return null;

        switch (ex.NodeType)
        {
            case ExpressionType.ConvertChecked :
            case ExpressionType.Convert        :
            {
                var unaryExpression = (UnaryExpression)ex;
                if (unaryExpression.Method == null)
                    return unaryExpression.Operand.UnwrapConvert();
                break;
            }
        }

        return ex;
    }
}

So in your case you can simple cast to MemberExpression

((MemberExpression)e.Body.UnwrapConvert()).Member.Name