L'entité ne peut pas être construite dans une requête LINQ to Entities

Il existe un type d'entité appelé produit qui est généré par le framework d'entité. J'ai écrit cette requête

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

Le code ci-dessous renvoie l'erreur suivante:

"L'entité ou le type complexe Shop.Product ne peut pas être construit dans une requête LINQ to Entities"

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

Mais quand j'utilise select pau lieu de select new Product { Name = p.Name};cela fonctionne correctement.

Comment puis-je préformer une section de sélection personnalisée?

Vous ne pouvez pas (et ne devriez pas pouvoir) projeter sur une entité mappée. Vous pouvez cependant projeter sur un type anonyme ou sur un DTO :

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

Et votre méthode renverra une liste 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();
}

Vous pouvez projeter dans un type anonyme, puis à partir de celui-ci vers le type de modèle

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

Éditer : Je vais être un peu plus précis car cette question a attiré beaucoup d'attention.

Vous ne pouvez pas projeter directement dans le type de modèle (restriction EF), il n'y a donc aucun moyen de contourner cela. La seule façon est de projeter en type anonyme (1ère itération), puis de modéliser le type (2ème itération).

Sachez également que lorsque vous chargez partiellement des entités de cette manière, elles ne peuvent pas être mises à jour, elles doivent donc rester détachées telles quelles.

Je n'ai jamais complètement compris pourquoi cela n'est pas possible, et les réponses sur ce fil ne donnent pas de raisons solides contre cela (parlant principalement de données partiellement chargées). Il est exact que, dans un état partiellement chargé, l'entité ne peut pas être mise à jour, mais alors, cette entité serait détachée, de sorte que des tentatives accidentelles de les enregistrer ne seraient pas possibles.

Considérez la méthode que j'ai utilisée ci-dessus: nous avons toujours une entité de modèle partiellement chargée. Cette entité est détachée.

Considérez ce code (souhait d'exister) possible:

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

Cela pourrait également entraîner une liste d'entités détachées, nous n'aurions donc pas besoin de faire deux itérations. Un compilateur serait intelligent de voir que AsNoTracking () a été utilisé, ce qui entraînera des entités détachées, il pourrait donc nous permettre de le faire. Si, cependant, AsNoTracking () était omis, il pourrait lever la même exception qu'il lance maintenant, pour nous avertir que nous devons être suffisamment précis sur le résultat que nous voulons.

Il y a une autre façon dont j'ai trouvé que ça marche, vous devez construire une classe qui dérive de votre classe Product et l'utiliser. Par exemple:

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

Je ne sais pas si cela est "autorisé", mais cela fonctionne.

Voici une façon de procéder sans déclarer de classe supplémentaire:

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

Cependant, cela ne doit être utilisé que si vous souhaitez combiner plusieurs entités en une seule entité. La fonctionnalité ci-dessus (cartographie simple de produit à produit) se fait comme suit:

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

Vous pouvez l'utiliser et cela devrait fonctionner -> Vous devez utiliser toListavant de créer la nouvelle liste en utilisant select:

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

En réponse à l'autre question qui a été marquée comme doublon ( voir ici ), j'ai trouvé une solution rapide et facile basée sur la réponse 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();

Remarque: Cette solution ne fonctionne que si vous avez une propriété de navigation (clé étrangère) sur la classe Task (appelée ici «Incident»). Si vous ne l'avez pas, vous pouvez simplement utiliser l'une des autres solutions publiées avec "AsQueryable ()".

Vous pouvez résoudre ce problème en utilisant des objets de transfert de données (DTO).

Ce sont un peu comme des modèles de vue où vous mettez les propriétés dont vous avez besoin et vous pouvez les mapper manuellement dans votre contrôleur ou en utilisant des solutions tierces comme AutoMapper.

Avec les DTO, vous pouvez:

• Rendre les données sérialisables (Json)
• Débarrassez-vous des références circulaires
• Réduisez le trafic réseau en laissant les propriétés dont vous n'avez pas besoin (viewmodelwise)
• Utiliser l'aplatissement des objets

J'ai appris cela à l'école cette année et c'est un outil très utile.

Si vous utilisez le framework Entity, essayez de supprimer la propriété de DbContext qui utilise votre modèle complexe en tant qu'entité. J'ai eu le même problème lors du mappage de plusieurs modèles dans un modèle de vue nommé Entity

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

La suppression de l'entrée de DbContext a corrigé mon erreur.

si vous exécutez, Linq to Entityvous ne pouvez pas utiliser le ClassTypeavec newdans la selectfermeture de la requêteonly anonymous types are allowed (new without type)

regardez cet extrait de mon projet

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

vous avez ajouté la new keywordfermeture dans Select même sur le complex propertiesvous obtiendrez cette erreur

donc removele ClassTypes from newmot - clé sur les Linq to Entityrequêtes ,,

car il sera transformé en instruction sql et exécuté sur SqlServer

alors quand puis-je l'utiliser new with typesà la selectfermeture?

vous pouvez l'utiliser si vous avez affaire à 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 

après avoir exécuté ToListsur requête, il est devenu in memory collection que nous pouvons utiliser new ClassTypesdans certains

Dans de nombreux cas, la transformation n'est pas nécessaire. Pensez à la raison pour laquelle vous voulez fortement taper List et évaluez si vous voulez simplement les données, par exemple, dans un service Web ou pour les afficher. Peu importe le type. Vous avez juste besoin de savoir comment le lire et vérifier qu'il est identique aux propriétés définies dans le type anonyme que vous avez défini. C'est le scénario optimun, car quelque chose dont vous n'avez pas besoin de tous les champs d'une entité, et c'est la raison pour laquelle le type anonyme existe.

Une façon simple de procéder est la suivante:

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

Il ne vous permettra pas de mapper à nouveau sur Product car c'est votre table que vous interrogez. Vous avez besoin d'une fonction anonyme, vous pouvez ensuite l'ajouter à un ViewModel, ajouter chaque ViewModel à un List<MyViewModel>et les renvoyer. C'est une légère digression, mais j'inclus des mises en garde sur la gestion des dates annulables car elles sont difficiles à gérer, au cas où vous en auriez. C'est ainsi que je l'ai géré.

J'espère que vous avez ProductViewModel:

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

J'ai un cadre d'injection de dépendances / référentiel où j'appelle une fonction pour récupérer mes données. En utilisant votre article comme exemple, dans votre appel de fonction Controller, cela ressemblerait à ceci:

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

Dans la classe de référentiel:

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 retour dans le contrôleur, vous faites:

 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>

ajoutez seulement AsEnumerable ():

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

vous pouvez ajouter AsEnumerable à votre collection comme suit:

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