Solo los constructores e inicializadores sin parámetros son compatibles con LINQ to Entities

Tengo este error en esta expresión de 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();

¿Alguna idea de cómo resolver este problema? Intento con cualquier combinación de expresión ...: /

sin más información sobre 'Pagos', esto no ayuda mucho, pero suponiendo que desea crear un objeto de Pagos y establecer algunas de sus propiedades en función de los valores de las columnas:

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 aún desea utilizar su constructor para la inicialización y no las propiedades (a veces, este comportamiento es deseable para fines de inicialización), enumere la consulta llamando a ToList()o ToArray(), y luego use Select(…). Por lo tanto, usará LINQ to Collections y esa limitación de no poder llamar al constructor con parámetros enSelect(…) desaparecerá.

Entonces su código debería verse así:

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

Habiendo encontrado este error yo mismo, pensé que agregaría que si el Paymenttipo es a struct, también encontrarías el mismo error porquestruct tipos no admiten constructores sin parámetros.

En ese caso, la conversión Paymenta una clase y el uso de la sintaxis del inicializador del objeto resolverán el problema.

Si eres como yo y no quieres tener que llenar tus propiedades para cada consulta que estás creando, hay otra forma de resolver este problema.

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

En este punto, tiene un IQueryable que contiene un objeto anónimo. Si desea llenar su objeto personalizado con un constructor, simplemente puede hacer algo como esto:

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

Ahora su objeto personalizado (que toma dos objetos como parámetro) puede llenar sus propiedades según sea necesario.

Primero evitaría la solución con

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

Esto requiere un constructor vacío e ignora la encapsulación, por lo que está diciendo que Payments () es un pago válido sin ningún dato, sino que el objeto debe tener al menos un valor y probablemente otros campos obligatorios dependiendo de su dominio.

Es mejor tener un constructor para los campos obligatorios pero solo traer los datos necesarios:

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

Puede intentar hacer lo mismo, pero utilizando los métodos de extensión. ¿Cuál es el proveedor del uso de la base de datos?

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

Sólo ToList()el DbSetantes de la Selectdeclaración .. el actual DbSetse guarda como una consulta, no se ha cumplido todavía. Después de llamar ToList(), estás jugando con objetos, y luego puedes usar un constructor no predeterminado en la consulta.

No es la forma más eficiente en cuanto al tiempo de uso, pero es una opción en conjuntos pequeños.

sí, inténtalo así ...

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

esto renovará su objeto de pago utilizando un constructor sin parámetros y luego inicializará las propiedades que se enumeran dentro de las llaves { }

Además de los métodos mencionados anteriormente, también puede analizarlo como una colección Enumerable, de esta manera:

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

Esto también tiene el beneficio adicional de hacer la vida más fácil al construir un objeto anónimo, como este:

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

Sin embargo, al recordar que analizar una colección como Enumerable la lleva a la memoria, ¡puede requerir muchos recursos! Se debe tener precaución aquí.

Además, si desea utilizar un constructor con varios objetos para inicializar, es posible que obtenga un error si Linq no devuelve ningún valor.

Por lo tanto, es posible que desee hacer algo como esto:

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

Perdón por llegar tarde a la fiesta, pero después de encontrar esto , pensé que esto debería compartirse, ya que es la implementación más limpia, rápida y que también ahorra memoria que pude encontrar.

Adaptado a tu ejemplo, escribirías:

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

Las grandes ventajas aquí (como Damien Guard señaló en los comentarios en el enlace) son:

• Le ahorra el uso del patrón de inicialización en cada aparición.
• Uso vía var foo = createPayments(bar);así como el uso a través de myIQueryable.ToPayments () posible.

Tuve el mismo problema hoy y mi solución fue similar a la que Yoda enumeró, sin embargo, solo funciona con sintaxis fluida.

Adaptando mi solución a su código: agregué el siguiente método estático a la clase de objeto

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

y luego actualizó la consulta base a lo siguiente:

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

Esto es lógicamente equivalente a la solución de James Manning con la ventaja de impulsar la gran cantidad de inicialización de miembros al objeto de transferencia de datos / clase

Nota: Originalmente estaba usando nombres más descriptivos que "Initializer", pero después de revisar cómo lo estaba usando, descubrí que "Initilizer" era suficiente (al menos para mis propósitos).

Nota final:
después de llegar a esta solución, originalmente pensé que sería simple compartir el mismo código y adaptarlo para que funcione también para la sintaxis de Query. Ya no creo que ese sea el caso. Creo que si desea poder utilizar este tipo de construcción abreviada, necesitaría un método para cada fluido (consulta, fluido) como se describe anteriormente, que puede existir en la clase de objeto en sí.

Para la sintaxis de consulta, se requeriría un método de extensión (o algún método fuera de la clase base que se utiliza). (dado que la sintaxis de consulta quiere operar un IQueryable en lugar de T)

Aquí hay una muestra de lo que solía hacer que finalmente funcione para la sintaxis de consulta. (Yoda ya clavó esto, pero creo que el uso podría ser más claro porque no lo entendí al principio)

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

y el uso

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

Aunque es tarde para responder, aún podría ayudar a alguien en apuros. Dado que LINQ to entidades no admite las construcciones de objetos sin parámetros. Sin embargo, los métodos de proyección para IEnumerable .

Entonces, antes de la selección, simplemente convierta su IQueryable a IEnumerable utilizando este código:

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

Funcionará bien Sin embargo, por supuesto, perderá los beneficios de las consultas nativas.

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