La entidad no se puede construir en una consulta LINQ to Entities

Hay un tipo de entidad llamada producto que es generado por el marco de la entidad. He escrito esta consulta

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products
           where p.CategoryID== categoryID
           select new Product { Name = p.Name};
}

El siguiente código arroja el siguiente error:

"La entidad o tipo complejo Shop.Product no se puede construir en una consulta LINQ to Entities"

var products = productRepository.GetProducts(1).Tolist();

Pero cuando lo uso en select plugar de select new Product { Name = p.Name};funciona correctamente.

¿Cómo puedo preformar una sección de selección personalizada?

No puede (y no debería poder) proyectar en una entidad asignada. Sin embargo, puede proyectar en un tipo anónimo o en un DTO :

public class ProductDTO
{
    public string Name { get; set; }
    // Other field you may need from the Product entity
}

Y su método devolverá una Lista de DTO.

public List<ProductDTO> GetProducts(int categoryID)
{
    return (from p in db.Products
            where p.CategoryID == categoryID
            select new ProductDTO { Name = p.Name }).ToList();
}

Puede proyectar en tipo anónimo, y luego de él a tipo de modelo

public IEnumerable<Product> GetProducts(int categoryID)
{
    return (from p in Context.Set<Product>()
            where p.CategoryID == categoryID
            select new { Name = p.Name }).ToList()
           .Select(x => new Product { Name = x.Name });
}

Editar : Voy a ser un poco más específico ya que esta pregunta llamó mucho la atención.

No puede proyectar directamente en el tipo de modelo (restricción de EF), por lo que no hay forma de evitarlo. La única forma es proyectar en tipo anónimo (primera iteración), y luego modelar el tipo (segunda iteración).

Tenga en cuenta también que cuando carga entidades parcialmente de esta manera, no se pueden actualizar, por lo que deben permanecer separadas, tal como están.

Nunca entendí completamente por qué esto no es posible, y las respuestas en este hilo no dan fuertes razones en su contra (principalmente hablando de datos parcialmente cargados). Es correcto que en el estado de carga parcial la entidad no se pueda actualizar, pero luego, esta entidad se desconectaría, por lo que no serían posibles los intentos accidentales de salvarlos.

Considere el método que utilicé anteriormente: todavía tenemos una entidad modelo parcialmente cargada como resultado. Esta entidad está separada.

Considere este posible código (deseo de existir):

return (from p in Context.Set<Product>()
        where p.CategoryID == categoryID
        select new Product { Name = p.Name }).AsNoTracking().ToList();

Esto también podría dar como resultado una lista de entidades separadas, por lo que no necesitaríamos hacer dos iteraciones. Un compilador sería inteligente al ver que se ha utilizado AsNoTracking (), lo que dará como resultado entidades separadas, por lo que podría permitirnos hacer esto. Sin embargo, si se omitió AsNoTracking (), podría lanzar la misma excepción que está lanzando ahora, para advertirnos que necesitamos ser lo suficientemente específicos sobre el resultado que queremos.

Hay otra forma en que encontré que funciona, tienes que construir una clase que se derive de tu clase de Producto y usarla. Por ejemplo:

public class PseudoProduct : Product { }

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products
           where p.CategoryID== categoryID
           select new PseudoProduct() { Name = p.Name};
}

No estoy seguro si esto está "permitido", pero funciona.

Aquí hay una manera de hacer esto sin declarar una clase adicional:

public List<Product> GetProducts(int categoryID)
{
    var query = from p in db.Products
            where p.CategoryID == categoryID
            select new { Name = p.Name };
    var products = query.ToList().Select(r => new Product
    {
        Name = r.Name;
    }).ToList();

    return products;
}

Sin embargo, esto solo se debe usar si desea combinar varias entidades en una sola entidad. La funcionalidad anterior (mapeo simple de producto a producto) se realiza así:

public List<Product> GetProducts(int categoryID)
{
    var query = from p in db.Products
            where p.CategoryID == categoryID
            select p;
    var products = query.ToList();

    return products;
}

Otra forma simple :)

public IQueryable<Product> GetProducts(int categoryID)
{
    var productList = db.Products
        .Where(p => p.CategoryID == categoryID)
        .Select(item => 
            new Product
            {
                Name = item.Name
            })
        .ToList()
        .AsQueryable(); // actually it's not useful after "ToList()" :D

    return productList;
}

Puede usar esto y debería estar funcionando -> Debe usarlo toListantes de hacer la nueva lista usando select:

db.Products
    .where(x=>x.CategoryID == categoryID).ToList()
    .select(x=>new Product { Name = p.Name}).ToList(); 

En respuesta a la otra pregunta que se marcó como duplicado ( ver aquí ), descubrí una solución rápida y fácil basada en la respuesta de Soren:

data.Tasks.AddRange(
    data.Task.AsEnumerable().Select(t => new Task{
        creator_id   = t.ID,
        start_date   = t.Incident.DateOpened,
        end_date     = t.Incident.DateCLosed,
        product_code = t.Incident.ProductCode
        // so on...
    })
);
data.SaveChanges();

Nota: Esta solución solo funciona si tiene una propiedad de navegación (clave externa) en la clase Tarea (aquí llamada 'Incidente'). Si no tiene eso, puede usar una de las otras soluciones publicadas con "AsQueryable ()".

Puede resolver esto utilizando Objetos de transferencia de datos (DTO).

Estos son un poco como los modelos de vista en los que coloca las propiedades que necesita y puede asignarlos manualmente en su controlador o mediante el uso de soluciones de terceros como AutoMapper.

Con DTO's puedes:

• Hacer datos serializables (Json)
• Deshágase de las referencias circulares
• Reduzca el tráfico de red dejando propiedades que no necesita (ver modelo)
• Usar aplanamiento de objetos

He estado aprendiendo esto en la escuela este año y es una herramienta muy útil.

Si está utilizando Entity Framework, intente eliminar la propiedad de DbContext que usa su modelo complejo como Entity. Tuve el mismo problema al mapear varios modelos en un modelo de vista llamado Entity

public DbSet<Entity> Entities { get; set; }

Eliminar la entrada de DbContext corrigió mi error.

si está ejecutando Linq to Entityno puede usar el ClassTypecon newen el selectcierre de la consultaonly anonymous types are allowed (new without type)

mira este fragmento de mi proyecto

//...
var dbQuery = context.Set<Letter>()
                .Include(letter => letter.LetterStatus)
                .Select(l => new {Title =l.Title,ID = l.ID, LastModificationDate = l.LastModificationDate, DateCreated = l.DateCreated,LetterStatus = new {ID = l.LetterStatusID.Value,NameInArabic = l.LetterStatus.NameInArabic,NameInEnglish = l.LetterStatus.NameInEnglish} })
                               ^^ without type__________________________________________________________________________________________________________^^ without type

de usted agregó el new keywordcierre en Seleccionar incluso en el complex propertiesobtendrá este error

entonces removela ClassTypes from newpalabra clave en Linq to Entityconsultas ,,

porque se transformará en una instrucción sql y se ejecutará en SqlServer

así que cuando puedo usar new with typesen selectel cierre?

puedes usarlo si estás lidiando con LINQ to Object (in memory collection)

//opecations in tempList , LINQ to Entities; so we can not use class types in select only anonymous types are allowed
var tempList = dbQuery.Skip(10).Take(10).ToList();// this is list of <anonymous type> so we have to convert it so list of <letter>

//opecations in list , LINQ to Object; so we can use class types in select
list = tempList.Select(l => new Letter{ Title = l.Title, ID = l.ID, LastModificationDate = l.LastModificationDate, DateCreated = l.DateCreated, LetterStatus = new LetterStatus{ ID = l.LetterStatus.ID, NameInArabic = l.LetterStatus.NameInArabic, NameInEnglish = l.LetterStatus.NameInEnglish } }).ToList();
                                ^^^^^^ with type 

después de ejecutar ToListen la consulta se convirtió in memory collection para que podamos usar new ClassTypesen select

En muchos casos, la transformación no es necesaria. Piense por la razón por la que desea escribir la lista, y evalúe si solo desea los datos, por ejemplo, en un servicio web o para mostrarlos. No importa el tipo. Solo necesita saber cómo leerlo y verificar que sea idéntico a las propiedades definidas en el tipo anónimo que definió. Ese es el escenario óptimo, porque algo no necesita todos los campos de una entidad, y esa es la razón por la que existe el tipo anónimo.

Una manera simple es hacer esto:

IEnumerable<object> list = dataContext.Table.Select(e => new { MyRequiredField = e.MyRequiredField}).AsEnumerable();

No le permitirá volver a mapear en Producto ya que esa es su tabla que está consultando. Necesita una función anónima, luego puede agregarla a un ViewModel y agregar cada ViewModel a unList<MyViewModel> y devolverlos. Es una ligera digresión, pero incluyo advertencias sobre el manejo de fechas anulables porque es un problema difícil de manejar, en caso de que tenga alguna. Así es como lo manejé.

Espero que tengas un ProductViewModel:

public class ProductViewModel
{
    [Key]
    public string ID { get; set; }
    public string Name { get; set; }
}

Tengo un marco de inyección / repositorio de dependencia donde llamo a una función para tomar mis datos. Usando su publicación como ejemplo, en su llamada a la función Controlador, se vería así:

int categoryID = 1;
var prods = repository.GetProducts(categoryID);

En la clase de repositorio:

public IEnumerable<ProductViewModel> GetProducts(int categoryID)
{
   List<ProductViewModel> lstPVM = new List<ProductViewModel>();

   var anonymousObjResult = from p in db.Products
                            where p.CategoryID == categoryID 
                            select new
                            {
                                CatID = p.CategoryID,
                                Name = p.Name
                            };

        // NOTE: If you have any dates that are nullable and null, you'll need to
        // take care of that:  ClosedDate = (DateTime?)p.ClosedDate ?? DateTime.Now

        // If you want a particular date, you have to define a DateTime variable,
        // assign your value to it, then replace DateTime.Now with that variable. You
        // cannot call a DateTime.Parse there, unfortunately. 
        // Using 
        //    new Date("1","1","1800"); 
        // works, though. (I add a particular date so I can edit it out later.)

        // I do this foreach below so I can return a List<ProductViewModel>. 
        // You could do: return anonymousObjResult.ToList(); here
        // but it's not as clean and is an anonymous type instead of defined
        // by a ViewModel where you can control the individual field types

        foreach (var a in anonymousObjResult)
        {                
            ProductViewModel pvm = new ProductViewModel();
            pvm.ID = a.CatID;  
            pvm.Name = a.Name;
            lstPVM.Add(rvm);
        }

        // Obviously you will just have ONE item there, but I built it 
        // like this so you could bring back the whole table, if you wanted
        // to remove your Where clause, above.

        return lstPVM;
    }

De vuelta en el controlador, haces:

 List<ProductViewModel> lstProd = new List<ProductViewModel>();

 if (prods != null) 
 {
    // For setting the dates back to nulls, I'm looking for this value:
    // DateTime stdDate = DateTime.Parse("01/01/1800");

    foreach (var a in prods)
    {
        ProductViewModel o_prod = new ReportViewModel();
        o_prod.ID = a.ID;
        o_prod.Name = a.Name;
       // o_prod.ClosedDate = a.ClosedDate == stdDate ? null : a.ClosedDate;
        lstProd.Add(o_prod);
    }
}
return View(lstProd);  // use this in your View as:   @model IEnumerable<ProductViewModel>

solo agregue AsEnumerable ():

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products.AsEnumerable()
           where p.CategoryID== categoryID
           select new Product { Name = p.Name};
}

Puede agregar AsEnumerable a su colección de la siguiente manera:

public IQueryable<Product> GetProducts(int categoryID)
{
    return from p in db.Products.AsEnumerable()
           where p.CategoryID== categoryID
           select new Product { Name = p.Name};
}