L'entità non può essere costruita in una query LINQ to Entities

Esiste un tipo di entità chiamato prodotto che viene generato dal framework di entità. Ho scritto questa domanda

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

Il codice seguente genera il seguente errore:

"L'entità o il tipo complesso Shop.Product non può essere costruito in una query LINQ to Entities"

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

Ma quando uso select pinvece di select new Product { Name = p.Name};esso funziona correttamente.

Come posso preformare una sezione di selezione personalizzata?

Non è possibile (e non si dovrebbe essere in grado di) proiettare su un'entità mappata. Tuttavia, è possibile proiettare su un tipo anonimo o su un DTO :

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

E il tuo metodo restituirà un elenco di DTO.

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

È possibile proiettare in un tipo anonimo e quindi da esso al tipo di modello

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 });
}

Modifica : sarò un po 'più specifico poiché questa domanda ha suscitato molta attenzione.

Non è possibile proiettare direttamente nel tipo di modello (restrizione EF), quindi non è possibile aggirare il problema. L'unico modo è proiettare in tipo anonimo (1a iterazione), quindi in tipo modello (2a iterazione).

Si noti inoltre che quando si caricano parzialmente le entità in questo modo, non possono essere aggiornate, quindi devono rimanere staccate, così come sono.

Non ho mai capito del tutto perché questo non è possibile e le risposte su questo thread non danno forti ragioni contro di esso (soprattutto parlando di dati parzialmente caricati). È corretto che l'entità di stato parzialmente caricata non possa essere aggiornata, ma quindi questa entità verrebbe staccata, quindi non sarebbero possibili tentativi accidentali di salvarle.

Considera il metodo che ho usato sopra: abbiamo ancora un'entità modello parzialmente caricata come risultato. Questa entità è distaccata.

Considera questo (possibile esistere) codice possibile:

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

Ciò potrebbe anche comportare un elenco di entità distaccate, quindi non avremmo bisogno di fare due iterazioni. Un compilatore sarebbe intelligente nel vedere che AsNoTracking () è stato utilizzato, il che si tradurrà in entità distaccate, quindi potrebbe permetterci di farlo. Se, tuttavia, AsNoTracking () fosse omesso, potrebbe lanciare la stessa eccezione che sta lanciando ora, per avvertirci che dobbiamo essere abbastanza specifici sul risultato che vogliamo.

C'è un altro modo in cui ho scoperto che funziona, devi creare una classe che deriva dalla tua classe di Prodotto e usarla. Per esempio:

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};
}

Non sono sicuro se questo è "consentito", ma funziona.

Ecco un modo per farlo senza dichiarare la classe adizionale:

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;
}

Tuttavia, questo deve essere utilizzato solo se si desidera combinare più entità in una singola entità. La funzionalità di cui sopra (semplice mappatura da prodotto a prodotto) viene eseguita in questo modo:

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;
}

Un altro modo semplice :)

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;
}

Puoi usarlo e dovrebbe funzionare -> Devi usare toListprima di creare il nuovo elenco usando select:

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

In risposta all'altra domanda che è stata contrassegnata come duplicata ( vedi qui ) ho trovato una soluzione semplice e veloce basata sulla risposta di 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: questa soluzione funziona solo se si dispone di una proprietà di navigazione (chiave esterna) sulla classe Task (qui chiamata "Incidente"). Se non lo possiedi, puoi semplicemente utilizzare una delle altre soluzioni pubblicate con "AsQueryable ()".

È possibile risolvere questo problema utilizzando Data Transfer Objects (DTO).

Questi sono un po 'come i modelli di visualizzazione in cui inserisci le proprietà di cui hai bisogno e puoi mapparle manualmente nel controller o utilizzando soluzioni di terze parti come AutoMapper.

Con DTO puoi:

• Rendi i dati serializzabili (Json)
• Sbarazzarsi di riferimenti circolari
• Riduci il traffico di rete lasciando le proprietà che non ti servono (viewmodelwise)
• Usa l'appiattimento degli oggetti

L'ho imparato a scuola quest'anno ed è uno strumento molto utile.

Se si utilizza Entity framework, provare a rimuovere la proprietà da DbContext che utilizza il modello complesso in quanto Entity I ha avuto lo stesso problema durante la mappatura di più modelli in un modello di visualizzazione denominato Entity

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

La rimozione della voce da DbContext ha corretto il mio errore.

se stai eseguendo Linq to Entitynon puoi usare il ClassTypecon newnella selectchiusura della queryonly anonymous types are allowed (new without type)

guarda questo frammento del mio progetto

//...
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

di voi ha aggiunto la new keywordchiusura Seleziona anche complex propertiesse si ottiene questo errore

quindi removela ClassTypes from newparola chiave sulle Linq to Entityquery ,,

perché verrà trasformato in istruzione sql ed eseguito su SqlServer

quindi quando posso usare new with typesalla selectchiusura?

puoi usarlo se hai a che fare 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 

dopo che ho eseguito la ToListquery è diventato in memory collection così possiamo usarlo new ClassTypesin select

In molti casi, la trasformazione non è necessaria. Pensa per il motivo per cui desideri fortemente l'Elenco e valuta se desideri solo i dati, ad esempio in un servizio Web o per visualizzarli. Non importa il tipo. Hai solo bisogno di sapere come leggerlo e verificare che sia identico alle proprietà definite nel tipo anonimo che hai definito. Questo è lo scenario ottimale, causa qualcosa che non ti serve tutti i campi di un'entità, e questo è il motivo per cui esiste un tipo anonimo.

Un modo semplice è farlo:

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

Non ti permetterà di mappare di nuovo sul Prodotto poiché quella è la tua tabella su cui stai interrogando. È necessaria una funzione anonima, quindi è possibile aggiungerla a un ViewModel e aggiungere ogni ViewModel a un List<MyViewModel>e restituirli. È una leggera digressione, ma includo avvertenze sulla gestione di date nulle perché sono un dolore alla schiena da affrontare, nel caso in cui tu ne abbia. È così che l'ho gestito.

Spero che tu abbia un ProductViewModel:

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

Ho un framework di iniezione / repository di dipendenze in cui chiamo una funzione per acquisire i miei dati. Usando il tuo post come esempio, nella tua chiamata alla funzione Controller, sarebbe simile al seguente:

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

Nella classe repository:

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;
    }

Di nuovo nel controller, fai:

 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>

aggiungi solo AsEnumerable ():

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

puoi aggiungere AsEnumerable alla tua raccolta come il seguente:

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