LINQ to Entities solo admite la conversión de tipos primitivos o de enumeración de EDM con la interfaz IEntity

Tengo el siguiente método de extensión genérico:

public static T GetById<T>(this IQueryable<T> collection, Guid id) 
    where T : IEntity
{
    Expression<Func<T, bool>> predicate = e => e.Id == id;

    T entity;

    // Allow reporting more descriptive error messages.
    try
    {
        entity = collection.SingleOrDefault(predicate);
    }
    catch (Exception ex)
    {
        throw new InvalidOperationException(string.Format(
            "There was an error retrieving an {0} with id {1}. {2}",
            typeof(T).Name, id, ex.Message), ex);
    }

    if (entity == null)
    {
        throw new KeyNotFoundException(string.Format(
            "{0} with id {1} was not found.",
            typeof(T).Name, id));
    }

    return entity;
}

Desafortunadamente, Entity Framework no sabe cómo manejar el predicateya que C # convirtió el predicado a lo siguiente:

e => ((IEntity)e).Id == id

Entity Framework lanza la siguiente excepción:

No se puede convertir el tipo 'IEntity' para escribir 'SomeEntity'. LINQ to Entities solo admite la conversión de tipos primitivos o de enumeración de EDM.

¿Cómo podemos hacer que Entity Framework funcione con nuestra IEntityinterfaz?

Pude resolver esto agregando la classrestricción de tipo genérico al método de extensión. Sin embargo, no estoy seguro de por qué funciona.

public static T GetById<T>(this IQueryable<T> collection, Guid id)
    where T : class, IEntity
{
    //...
}

Algunas explicaciones adicionales sobre el class"arreglo".

Esta respuesta muestra dos expresiones diferentes, una con y otra sin where T: classrestricción. Sin la classrestricción tenemos:

e => e.Id == id // becomes: Convert(e).Id == id

y con la restricción:

e => e.Id == id // becomes: e.Id == id

Estas dos expresiones son tratadas de manera diferente por el marco de la entidad. Al observar las fuentes de EF 6 , se puede encontrar que la excepción proviene de aquí, verValidateAndAdjustCastTypes() .

Lo que sucede es que EF intenta IEntityconvertir algo que tenga sentido en el mundo del modelo de dominio, sin embargo, falla al hacerlo, por lo que se lanza la excepción.

La expresión con la classrestricción no contiene el Convert()operador, no se prueba la conversión y todo está bien.

Todavía queda abierta la pregunta, ¿por qué LINQ crea diferentes expresiones? Espero que algún asistente de C # pueda explicar esto.

Entity Framework no admite esto de forma inmediata, pero una ExpressionVisitorque traduce la expresión se escribe fácilmente:

private sealed class EntityCastRemoverVisitor : ExpressionVisitor
{
    public static Expression<Func<T, bool>> Convert<T>(
        Expression<Func<T, bool>> predicate)
    {
        var visitor = new EntityCastRemoverVisitor();

        var visitedExpression = visitor.Visit(predicate);

        return (Expression<Func<T, bool>>)visitedExpression;
    }

    protected override Expression VisitUnary(UnaryExpression node)
    {
        if (node.NodeType == ExpressionType.Convert && node.Type == typeof(IEntity))
        {
            return node.Operand;
        }

        return base.VisitUnary(node);
    }
}

Lo único que tendrá que hacer es convertir el predicado pasado usando la expresión visitante de la siguiente manera:

public static T GetById<T>(this IQueryable<T> collection, 
    Expression<Func<T, bool>> predicate, Guid id)
    where T : IEntity
{
    T entity;

    // Add this line!
    predicate = EntityCastRemoverVisitor.Convert(predicate);

    try
    {
        entity = collection.SingleOrDefault(predicate);
    }

    ...
}

Otro enfoque, menos flexible, es hacer uso de DbSet<T>.Find:

// NOTE: This is an extension method on DbSet<T> instead of IQueryable<T>
public static T GetById<T>(this DbSet<T> collection, Guid id) 
    where T : class, IEntity
{
    T entity;

    // Allow reporting more descriptive error messages.
    try
    {
        entity = collection.Find(id);
    }

    ...
}

Tuve el mismo error pero un problema similar pero diferente. Estaba tratando de crear una función de extensión que devolviera IQueryable, pero los criterios de filtro se basaron en la clase base.

Finalmente encontré la solución que era para que mi método de extensión llamara .Select (e => e como T) donde T es la clase secundaria ye es la clase base.

los detalles completos están aquí: Cree la extensión IQueryable <T> usando la clase base en EF