Seuls les constructeurs et initialiseurs sans paramètre sont pris en charge dans LINQ to Entities

J'ai cette erreur dans cette expression linq:

var naleznosci = (from nalTmp in db.Naleznosci
                              where nalTmp.idDziecko == idDziec
                              select new Payments
                              (
                                  nalTmp.Dziecko.Imie,
                                  nalTmp.Dziecko.Nazwisko,
                                  nalTmp.Miesiace.Nazwa,
                                  nalTmp.Kwota,
                                  nalTmp.RodzajeOplat.NazwaRodzajuOplaty,
                                  nalTmp.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
                                  nalTmp.DataRozliczenia,
                                  nalTmp.TerminPlatnosci
                              )).ToList();

Une idée comment résoudre ce problème? J'essaye avec n'importe quelle combinaison d'expression ...: /

sans plus d'informations sur les `` paiements '', cela n'aide pas beaucoup, mais en supposant que vous souhaitiez créer un objet Payments et définir certaines de ses propriétés en fonction des valeurs de colonne:

var naleznosci = (from nalTmp in db.Naleznosci
                              where nalTmp.idDziecko == idDziec
                              select new Payments
                              {
                                  Imie = nalTmp.Dziecko.Imie,
                                  Nazwisko = nalTmp.Dziecko.Nazwisko,
                                  Nazwa= nalTmp.Miesiace.Nazwa,
                                  Kwota = nalTmp.Kwota,
                                  NazwaRodzajuOplaty = nalTmp.RodzajeOplat.NazwaRodzajuOplaty,
                                  NazwaTypuOplaty = nalTmp.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
                                  DataRozliczenia = nalTmp.DataRozliczenia,
                                  TerminPlatnosci = nalTmp.TerminPlatnosci,
                              }).ToList();

Si vous souhaitez toujours utiliser votre constructeur pour l'initialisation et non les propriétés (ce comportement est parfois souhaité à des fins d'initialisation), énumérez la requête en appelant ToList()ou ToArray(), puis utilisez Select(…). Ainsi, il utilisera LINQ to Collections et cette limitation de ne pas pouvoir appeler le constructeur avec des paramètres Select(…)disparaîtra.

Donc, votre code devrait ressembler à ceci:

var naleznosci = db.Naleznosci
                          .Where(nalTmp => nalTmp.idDziecko == idDziec)
                          .ToList() // Here comes transfer to LINQ to Collections.
                          .Select(nalImp => new Payments
                              (
                                  nalTmp.Dziecko.Imie,
                                  nalTmp.Dziecko.Nazwisko,
                                  nalTmp.Miesiace.Nazwa,
                                  nalTmp.Kwota,
                                  nalTmp.RodzajeOplat.NazwaRodzajuOplaty,
                                  nalTmp.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
                                  nalTmp.DataRozliczenia,
                                  nalTmp.TerminPlatnosci
                              ))
                          .ToList();

Ayant moi-même rencontré cette erreur, j'ai pensé ajouter que si le Paymenttype est a struct, vous rencontrerez également la même erreur car les structtypes ne prennent pas en charge les constructeurs sans paramètre.

Dans ce cas, la conversion Paymenten classe et l'utilisation de la syntaxe d'initialisation d'objet résoudront le problème.

Si vous êtes comme moi et que vous ne souhaitez pas avoir à renseigner vos propriétés pour chaque requête que vous créez, il existe un autre moyen de résoudre ce problème.

var query = from orderDetail in context.OrderDetails
            join order in context.Orders on order.OrderId equals orderDetail.orderId
            select new { order, orderDetail };

À ce stade, vous disposez d'un IQueryable contenant un objet anonyme. Si vous souhaitez remplir votre objet personnalisé avec un constructeur, vous pouvez simplement faire quelque chose comme ceci:

return query.ToList().Select(r => new OrderDetails(r.order, r.orderDetail));

Maintenant, votre objet personnalisé (qui prend deux objets comme paramètre) peut remplir vos propriétés selon vos besoins.

J'éviterais d'abord la solution avec

from ....
select new Payments
{
  Imie = nalTmp.Dziecko.Imie,
  ....
}

Cela nécessite un constructeur vide et ignore l'encapsulation, vous dites donc que new Payments () est un paiement valide sans aucune donnée, mais à la place, l'objet doit avoir au moins une valeur et probablement d'autres champs obligatoires en fonction de votre domaine.

Il est préférable d'avoir un constructeur pour les champs obligatoires mais de n'apporter que les données nécessaires:

from ....
select new
{
  Imie = nalTmp.Dziecko.Imie,
  Nazwisko = nalTmp.Dziecko.Nazwisko
  ....
}
.ToList() // Here comes transfer to LINQ to Collections.
.Select(nalImp => new Payments
 (
  nalTmp.Imie,//assume this is a required field
  ...........
  )
  {
     Nazwisko = nalTmp.Nazwisko //optional field
  })
.ToList();

Vous pouvez essayer de faire de même, mais en utilisant les méthodes d'extension. Quel est le fournisseur de l'utilisation de la base de données?

var naleznosci = db.Naleznosci
                          .Where<TSource>(nalTmp => nalTmp.idDziecko == idDziec)
                          .Select<TSource, TResult>(
                             delegate(TSource nalTmp) { return new Payments
                             (
                                 nalTmp.Dziecko.Imie,
                                 nalTmp.Dziecko.Nazwisko,
                                 nalTmp.Miesiace.Nazwa,
                                 nalTmp.Kwota,
                                 nalTmp.RodzajeOplat.NazwaRodzajuOplaty,
                                 nalTmp.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
                                 nalTmp.DataRozliczenia,
                                 nalTmp.TerminPlatnosci
                             ); })
                          .ToList();

Juste ToList()l' DbSetavant la Selectdéclaration .. le réel DbSetest enregistré comme une requête, ce n'est pas remplie encore. Après avoir appelé, ToList()vous jouez avec des objets, puis vous pouvez utiliser un constructeur autre que celui par défaut dans la requête.

Ce n'est pas le moyen le plus efficace en termes de temps d'utilisation, mais c'est une option sur les petits ensembles.

oui, essayez-le comme ça ...

var naleznosci = (from nalTmp in db.Naleznosci
                              where nalTmp.idDziecko == idDziec
                              select new Payments()
                              {
                                  Dziecko.Imie,
                                  Dziecko.Nazwisko,
                                  Miesiace.Nazwa,
                                  Kwota,
                                  RodzajeOplat.NazwaRodzajuOplaty,
                                  RodzajeOplat.TypyOplat.NazwaTypuOplaty,
                                  DataRozliczenia,
                                  TerminPlatnosci
                              }).ToList();

cela réinitialisera votre objet de paiement à l'aide d'un constructeur sans paramètre, puis initialisera les propriétés répertoriées à l'intérieur des accolades. { }

En plus des méthodes susmentionnées, vous pouvez également l'analyser en tant que collection Enumerable, comme ceci:

(from x in table
....
).AsEnumerable()
.Select(x => ...)

Cela a également l'avantage supplémentaire de rendre la vie plus facile lors de la construction d'un objet anonyme, comme ceci:

 (from x in tableName
select x.obj)
.Where(x => x.id != null)
.AsEnumerable()
.Select(x => new {
   objectOne = new ObjectName(x.property1, x.property2),
   parentObj = x
})
.ToList();

Rappelez-vous, cependant, que l'analyse d'une collection comme Enumerable la tire en mémoire, donc elle peut être gourmande en ressources! La prudence doit être utilisée ici.

De plus, si vous souhaitez utiliser un constructeur avec plusieurs objets à initialiser, vous risquez d'obtenir une erreur si aucune valeur n'est renvoyée par Linq.

Vous voudrez peut-être faire quelque chose comme ceci:

(from x in table_1
   join y in table_2
   on x.id equals y.id
   select new {
   val1 = x,
   val2 = y
})
.DefaultIfEmpty()
.ToList()
.Select(a => new Val_Constructor(a.val1 != null ? a.val1 : new Val_1_Constructor(),
                            a.val2 != null ? a.val2 : new Val_2_Constructor()))
.ToList();

Désolé d'être en retard à la fête, mais après avoir trouvé cela , j'ai pensé que cela devrait être partagé car c'est l'implémentation la plus propre, la plus rapide et la plus économiseuse de mémoire que j'ai pu trouver.

Adapté à votre exemple, vous écririez:

public static IQueryable<Payments> ToPayments(this IQueryable<Naleznosci> source)
{
  Expression<Func<Naleznosci, Payments>> createPayments = naleznosci => new Payments
  {
    Imie = source.Dziecko.Imie,
    Nazwisko = source.Dziecko.Nazwisko,
    Nazwa= source.Miesiace.Nazwa,
    Kwota = source.Kwota,
    NazwaRodzajuOplaty = source.RodzajeOplat.NazwaRodzajuOplaty,
    NazwaTypuOplaty = source.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
    DataRozliczenia = source.DataRozliczenia,
    TerminPlatnosci = source.TerminPlatnosci,
  };

  return source.Select(createPayments);
}

Les grands avantages ici (comme l'a souligné Damien Guard dans les commentaires sur le lien) sont:

• Vous évite d'utiliser le modèle d'initialisation à chaque occurrence.
• Utilisation via var foo = createPayments(bar);ainsi que via myIQueryable.ToPayments () possible.

J'ai eu le même problème aujourd'hui et ma solution était similaire à celle répertoriée par Yoda, mais elle ne fonctionne qu'avec une syntaxe fluide.

Adapter ma solution à votre code: j'ai ajouté la méthode statique suivante à la classe d'objets

    /// <summary>
    /// use this instead of a parameritized constructor when you need support
    /// for LINQ to entities (fluent syntax only)
    /// </summary>
    /// <returns></returns>
    public static Func<Naleznosci, Payments> Initializer()
    {
        return n => new Payments
        {
             Imie = n.Dziecko.Imie,
             Nazwisko = n.Dziecko.Nazwisko,
             Nazwa = n.Miesiace.Nazwa,
             Kwota = n.Kwota,
             NazwaRodzajuOplaty = n.RodzajeOplat.NazwaRodzajuOplaty,
             NazwaTypuOplaty = n.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
             DataRozliczenia = n.DataRozliczenia,
             TerminPlatnosc = n.TerminPlatnosci
        };
    }

puis a mis à jour la requête de base comme suit:

var naleznosci = (from nalTmp in db.Naleznosci
    where nalTmp.idDziecko == idDziec
    select new Payments.Initializer());

Ceci est logiquement équivalent à la solution de James Manning avec l'avantage de pousser le gonflement de l'initialisation des membres vers l'objet de transfert de classe / données

Remarque: À l'origine, j'utilisais des noms plus descriptifs que "Initializer" mais après avoir examiné comment je l'utilisais, j'ai trouvé que "Initilizer" était suffisant (du moins pour mes besoins).

Note finale:
Après avoir proposé cette solution, je pensais à l'origine qu'il serait simple de partager le même code et de l'adapter pour qu'il fonctionne également pour la syntaxe de requête. Je ne pense plus que ce soit le cas. Je pense que si vous voulez pouvoir utiliser ce type de construction abrégée, vous auriez besoin d'une méthode pour chaque (requête, fluent) fluide comme décrit ci-dessus qui peut exister dans la classe d'objets elle-même.

Pour la syntaxe de requête, une méthode d'extension (ou une méthode en dehors de la classe de base utilisée) serait requise. (puisque la syntaxe de requête veut faire fonctionner un IQueryable plutôt que T)

Voici un exemple de ce que j'ai utilisé pour que cela fonctionne enfin pour la syntaxe de requête. (Yoda l'a déjà cloué mais je pense que l'utilisation pourrait être plus claire car je ne l'ai pas compris au début)

/// <summary>
/// use this instead of a parameritized constructor when you need support
/// for LINQ to entities (query syntax only)
/// </summary>
/// <returns></returns>
public static IQueryable<Payments> Initializer(this IQueryable<Naleznosci> source)
{
    return source.Select(
        n => new Payments
        {
            Imie = n.Dziecko.Imie,
            Nazwisko = n.Dziecko.Nazwisko,
            Nazwa = n.Miesiace.Nazwa,
            Kwota = n.Kwota,
            NazwaRodzajuOplaty = n.RodzajeOplat.NazwaRodzajuOplaty,
            NazwaTypuOplaty = n.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
            DataRozliczenia = n.DataRozliczenia,
            TerminPlatnosc = n.TerminPlatnosci
    };
}

et l'utilisation

var naleznosci = (from nalTmp in db.Naleznosci
    where nalTmp.idDziecko == idDziec
    select nalTmp).Initializer().ToList();

Bien qu'il soit tard pour répondre, cela pourrait encore aider une personne en détresse. Depuis LINQ aux entités ne prend pas en charge les constructions d'objets sans paramètre. Cependant, les méthodes de projection pour IEnumerable .

Donc, avant la sélection, convertissez simplement votre IQueryable en IEnumerable en utilisant ce code:

var result = myContext.SomeModelClass.AsEnumerable().Select(m => m.ToString());

Cela fonctionnera très bien. Cependant, il perdra bien sûr les avantages des requêtes natives.

IQueryable<SqlResult> naleznosci = (from nalTmp in db.Naleznosci
                              where nalTmp.idDziecko == idDziec
                              select new Payments
                              {
                                  Imie = nalTmp.Dziecko.Imie,
                                  Nazwisko = nalTmp.Dziecko.Nazwisko,
                                  Nazwa= nalTmp.Miesiace.Nazwa,
                                  Kwota = nalTmp.Kwota,
                                  NazwaRodzajuOplaty =                          nalTmp.RodzajeOplat.NazwaRodzajuOplaty,
                              NazwaTypuOplaty = nalTmp.RodzajeOplat.TypyOplat.NazwaTypuOplaty,
                              DataRozliczenia = nalTmp.DataRozliczenia,
                              TerminPlatnosci = nalTmp.TerminPlatnosci,
                          });
Repeater1.DataSource  = naleznosci.ToList(); 
Repeater1.DataBind();


public class SqlResult
{
        public string Imie { get; set; }
        public string Nazwisko { get; set; }
        ...
}