In LINQ to Entities werden nur parameterlose Konstruktoren und Initialisierer unterstützt

Ich habe diesen Fehler in diesem linq-Ausdruck:

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

Irgendeine Idee, wie man dieses Problem löst? Ich versuche es mit einer beliebigen Ausdruckskombination ...: /

Ohne weitere Informationen zu "Zahlungen" hilft dies nicht viel. Vorausgesetzt, Sie möchten ein Zahlungsobjekt erstellen und einige seiner Eigenschaften basierend auf Spaltenwerten festlegen:

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

Wenn Sie Ihren Konstruktor weiterhin für die Initialisierung und nicht für Eigenschaften verwenden möchten (manchmal ist dieses Verhalten für Initialisierungszwecke erwünscht), führen Sie die Abfrage auf, indem Sie ToList()oder aufrufen ToArray(), und verwenden Sie dann Select(…). Daher wird LINQ to Collections verwendet und die Einschränkung, dass Konstruktoren mit Parametern in nicht aufgerufen werden könnenSelect(…) verschwindet.

Ihr Code sollte also ungefähr so ​​aussehen:

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

Nachdem ich diesen Fehler gerade selbst festgestellt habe, dachte ich, ich würde hinzufügen, dass wenn der PaymentTyp a ist struct, Sie auch auf denselben Fehler stoßen würden, da structTypen keine parameterlosen Konstruktoren unterstützen.

In diesem Fall Paymentwird das Problem durch Konvertieren in eine Klasse und Verwenden der Objektinitialisierersyntax behoben.

Wenn Sie wie ich sind und nicht für jede Abfrage, die Sie erstellen, Ihre Eigenschaften auffüllen müssen, gibt es eine andere Möglichkeit, dieses Problem zu lösen.

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

Zu diesem Zeitpunkt haben Sie eine IQueryable, die ein anonymes Objekt enthält. Wenn Sie Ihr benutzerdefiniertes Objekt mit einem Konstruktor füllen möchten, können Sie einfach Folgendes tun:

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

Jetzt kann Ihr benutzerdefiniertes Objekt (das zwei Objekte als Parameter verwendet) Ihre Eigenschaften nach Bedarf füllen.

Zuerst würde ich die Lösung mit vermeiden

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

Dies erfordert einen leeren Konstruktor und ignoriert die Kapselung, sodass Sie sagen, dass new Payments () eine gültige Zahlung ohne Daten ist. Stattdessen muss das Objekt abhängig von Ihrer Domain mindestens einen Wert und wahrscheinlich andere erforderliche Felder haben.

Es ist besser, einen Konstruktor für erforderliche Felder zu haben, aber nur die erforderlichen Daten mitzubringen:

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

Sie können versuchen, dasselbe zu tun, aber die Erweiterungsmethoden verwenden. Was ist der Anbieter der Datenbanknutzung?

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

Nur ToList()die DbSetvor der SelectAnweisung .. die tatsächliche DbSetwird als Abfrage gespeichert, es ist noch nicht erfüllt. Nach dem Aufruf spielen ToList()Sie mit Objekten und können dann einen nicht standardmäßigen Konstruktor in der Abfrage verwenden.

Nicht die effizienteste Art der Nutzungsdauer, aber eine Option für kleine Sets.

yeh, versuch es so ....

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

Dadurch wird Ihr Zahlungsobjekt mithilfe eines parameterlosen Konstruktors neu erstellt und anschließend die Eigenschaften initialisiert, die in geschweiften Klammern aufgeführt sind { }

Zusätzlich zu den oben genannten Methoden können Sie es auch als Enumerable-Sammlung analysieren, z. B.:

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

Dies hat auch den zusätzlichen Vorteil, dass das Leben beim Erstellen eines anonymen Objekts wie folgt erleichtert wird:

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

Denken Sie jedoch daran, dass das Parsen einer Sammlung als Enumerable sie in den Speicher zieht, sodass sie ressourcenintensiv sein kann! Hier ist Vorsicht geboten.

Wenn Sie zum Initialisieren einen Konstruktor mit mehreren Objekten verwenden möchten, wird möglicherweise eine Fehlermeldung angezeigt, wenn Linq keine Werte zurückgibt.

Vielleicht möchten Sie so etwas tun:

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

Sorry für die Verspätung der Partei, aber ich nach dem Auffinden dieser , dachte ich, dass dies geteilt werden sollte, da es die sauberste, schnellste und auch speichersparendste Implementierung ist, die ich finden konnte.

An Ihr Beispiel angepasst würden Sie schreiben:

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

Die großen Vorteile hier (wie Damien Guard in den Kommentaren unter dem Link hervorhob) sind:

• Verhindert, dass Sie bei jedem Auftreten ein Initialisierungsmuster verwenden.
• Nutzung über var foo = createPayments(bar);sowie Nutzung über myIQueryable.ToPayments () möglich.

Ich hatte heute das gleiche Problem und meine Lösung ähnelte der von Yoda aufgelisteten, funktioniert jedoch nur mit fließender Syntax.

Anpassen meiner Lösung an Ihren Code: Ich habe der Objektklasse die folgende statische Methode hinzugefügt

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

und aktualisierte dann die Basisabfrage auf Folgendes:

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

Dies entspricht logischerweise der Lösung von James Manning mit dem Vorteil, dass das Aufblähen der Elementinitialisierung auf das Klassen- / Datenübertragungsobjekt übertragen wird

Hinweis: Ursprünglich verwendete ich aussagekräftigere Namen als "Initializer", aber nachdem ich überprüft hatte, wie ich ihn verwendete, stellte ich fest, dass "Initilizer" ausreichend war (zumindest für meine Zwecke).

Schlussbemerkung:
Nachdem ich diese Lösung entwickelt hatte, dachte ich ursprünglich, es wäre einfach, denselben Code zu teilen und diesen anzupassen, um auch für die Abfragesyntax zu funktionieren. Ich glaube nicht mehr, dass dies der Fall ist. Ich denke, wenn Sie in der Lage sein möchten, diese Art der Kurzschriftkonstruktion zu verwenden, benötigen Sie eine Methode für jede (Abfrage, fließend) fließend wie oben beschrieben, die in der Objektklasse selbst vorhanden sein kann.

Für die Abfragesyntax wäre eine Erweiterungsmethode (oder eine Methode außerhalb der verwendeten Basisklasse) erforderlich. (da die Abfragesyntax eher ein IQueryable als ein T betreiben möchte)

Hier ist ein Beispiel dessen, was ich verwendet habe, um dies endlich für die Abfragesyntax zum Laufen zu bringen. (Yoda hat das bereits verstanden, aber ich denke, die Verwendung könnte klarer sein, weil ich es zuerst nicht verstanden habe.)

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

und die Verwendung

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

Obwohl es spät ist zu antworten, könnte es dennoch jemandem in Not helfen. Da LINQ to-Entitäten die parameterlosen Objektkonstruktionen nicht unterstützen. Die Projektionsmethoden für IEnumerable sind jedoch .

Konvertieren Sie also vor der Auswahl einfach Ihr IQueryable mit diesem Code in IEnumerable :

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

Es wird gut funktionieren. Es wird jedoch natürlich die Vorteile nativer Abfragen verlieren.

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