Return TEntity in Expression<Func<TEntity, TResult>>

Question

I have a method which passing an optional/default parameter in Expression Tree like below:

Task<TResult> GetSingleAsync<TResult>(Expression<Func<TEntity, TResult>> selector = null);

What I'm supposed to do is, check when calling above method with ignoring the selector parameter, assign TResult as TEntity to selector inside my method, basically something like selector = (TEntity) => TEntity, so I am trying with below implementation

public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{
     private readonly DbSet<TEntity> _collection;

     public async Task<TResult> GetSingleAsync<TResult>(Expression<Func<TEntity, TResult>> selector = null)
     {
          IQueryable<TEntity> query = this._collection;

          if (selector == null) selector = (entity) => default(TResult);

          return await query.Select(selector).SingleOrDefaultAsync();
     }
}

when I call the function like GetSingleAsync<User>() which ignore the default parameter selector, However, the selector = x => default(TResult) shows selector as null, Is there any way to return the TEntity as TResult when assign value to the selector? I've tried all ways like below but failed as well

// error: cannot implicitly convert type 'TEntity' to 'TResult'
if (selector == null) selector = x => x;
if (selector == null) selector = x => TEntity;
if (selector == null) selector = x => (default)TEntity;
if (selector == null) selector = x => (TResult)x;
if (selector == null) selector = x => x as TResult;

Answer 1

I think you may have a few options here depending on what your requirements are.

• You could try casting the incoming TEntity to a TResult. This would require a type constraint on TResult and a kinda messy one at that.
• You could check to see if TEntity is of the type TResult and if it is, you return the casted type. Otherwise return the default TResult. This one wouldn't require the type constraint and I think that might be the best you could get without the constraint.
• You could ditch the default parameter value all together and overload the function. Personally, I think this would be your best bet.

Here's examples of the options I listed above:

Option 1: Casting with type constraint.

public async Task<TResult> GetSingleAsync<TResult, TNewEntity>(Expression<Func<TNewEntity, TResult>> selector = null)
where TNewEntity: TEntity, TResult
{
   IQueryable<TNewEntity> query = this._collection;

   if (selector == null) selector = entity => (TResult) entity;

   return await query.Select(selector).SingleOrDefaultAsync();
}

Here you see the ugly type constraint that I was talking about. You have to introduce a new type in order to enforce that your class constraint is of type TResult.

Option 2: Type check and cast.

public async Task<TResult> GetSingleAsync<TResult>(Expression<Func<TEntity, TResult>> selector = null)
{
    IQueryable<TNewEntity> query = this._collection;

    // I would use pattern matching here if I could, but unfortunately it looks like
    // expression trees cannot have pattern matching so we have to box then cast.
    if (selector == null) selector = entity =>  entity is TResult ? (TResult)(object) entity : default(TResult);


    return await query.Select(selector).SingleOrDefaultAsync();
}

With this, it will attempt to cast the entity to the correct type but if it can't it will return the default for TResult which will be null if its a reference type. This will still incur the same problem you were having before, but, in the cases where the cast succeeds, it could be what you want.

Option 3: Overload the method.

// New method with no selector. Notice the return type is now TEntity
public async Task<TEntity> GetSingleAsync(){
    return GetSingleAsync(x => x); // This now works because TResult is TEntity.
}

// Original method, but now it requires the selector
public async Task<TResult> GetSingleAsync<TResult>(Expression<Func<TEntity, TResult>> selector)
{
    IQueryable<TNewEntity> query = this._collection;
    return await query.Select(selector).SingleOrDefaultAsync();
}

Personally, this seems like the option that you are wanting and the one that I would use. It essentially has the same functionality as the default parameter but now requires that, if the selector is not provided, the query will return TEntity. However, I don't know all the constraints of your problem or if the default parameter is required.

Note: this is similar to what LINQ does with optional selectors. Here's the source for a few of the ToDictionary extensions:

public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) {
    return ToDictionary<TSource, TKey, TSource>(source, keySelector, IdentityFunction<TSource>.Instance, comparer);
}

public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) {
    return ToDictionary<TSource, TKey, TElement>(source, keySelector, elementSelector, null);
}

Notice how they're passing in the identity function for the elementSelector and every TElement is essentially just replaced by TSource in the first method.

Conclusion:

There may be other options that aren't listed here but these are the best ones that I could come up with. I tested to see if these would compile, but have not ran any of them.