Somente construtores e inicializadores sem parâmetros são suportados no LINQ to Entities

Eu tenho esse erro nesta expressão 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();

Alguma idéia de como resolver esse problema? Eu tento com qualquer combinação de expressão ...: /

sem mais informações sobre 'Pagamentos', isso não ajuda muito, mas suponha que você queira criar um objeto Pagamentos e definir algumas de suas propriedades com base nos valores da coluna:

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

Se você ainda deseja usar seu construtor para inicialização e não propriedades (às vezes esse comportamento é desejado para fins de inicialização), enumere a consulta chamando ToList()or ToArray()e, em seguida, use Select(…). Assim, ele usará o LINQ to Collections e a limitação de não poder chamar o construtor com parâmetros in Select(…)desaparecerá.

Portanto, seu código deve ser algo como isto:

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

Tendo acabado de encontrar esse erro, pensei em acrescentar que, se o Paymenttipo for a struct, você também encontrará o mesmo erro, porque os structtipos não suportam construtores sem parâmetros.

Nesse caso, a conversão Payment para uma classe e o uso da sintaxe do inicializador de objetos resolverão o problema.

Se você é como eu e não deseja preencher suas propriedades para cada consulta que está criando, existe outra maneira de resolver esse problema.

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

Neste ponto, você tem um IQueryable contendo um objeto anônimo. Se você deseja preencher seu objeto personalizado com um construtor, basta fazer algo assim:

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

Agora, seu objeto personalizado (que aceita dois objetos como parâmetro) pode preencher suas propriedades conforme necessário.

Primeiro eu evitaria a solução com

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

Isso requer um construtor vazio e ignora o encapsulamento. Portanto, você está dizendo que novo Payments () é um pagamento válido sem dados, mas o objeto deve ter pelo menos um valor e provavelmente outros campos obrigatórios, dependendo do seu domínio.

É melhor ter um construtor para os campos obrigatórios, mas apenas trazer os dados necessários:

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

Você pode tentar fazer o mesmo, mas usando os métodos de extensão. Qual é o provedor do banco de dados usado?

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

Apenas ToList()o DbSetantes da Selectdeclaração .. o real DbSeté guardada como uma consulta, não é ainda preenchidas. Após chamar ToList()você está jogando com objetos e, em seguida, você pode usar um construtor não padrão na consulta.

Não é a maneira mais eficiente em termos de tempo de uso, mas é uma opção em aparelhos pequenos.

sim, tente assim ....

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

isso atualizará seu objeto Payment usando um construtor sem parâmetros e inicializará as propriedades listadas dentro dos chavetas { }

Além dos métodos mencionados acima, você também pode analisá-lo como uma coleção Enumerable, assim:

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

Isso também tem o benefício adicional de facilitar a vida ao criar um 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();

Lembrando, no entanto, que a análise de uma coleção como Enumerable a armazena na memória, para que possa consumir muitos recursos! Cuidado deve ser usado aqui.

Além disso, se você desejar usar um construtor com vários objetos para inicializar, poderá receber um erro se nenhum valor for retornado pelo Linq.

Então, você pode querer fazer algo assim:

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

Desculpe por chegar atrasado à festa, mas depois de encontrar isso , achei que deveria ser compartilhado, pois é a implementação mais limpa, rápida e também de economia de memória que pude encontrar.

Adaptado ao seu exemplo, você escreveria:

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

As grandes vantagens aqui (como Damien Guard apontou nos comentários no link) são:

• Protege você de usar o padrão de inicialização em cada ocorrência.
• É var foo = createPayments(bar);possível usar o uso via myIQueryable.ToPayments ().

Hoje eu tinha o mesmo problema e minha solução era semelhante à listada pela Yoda, no entanto, ela funciona apenas com sintaxe fluente.

Adaptando minha solução ao seu código: Adicionei o seguinte método estático à classe 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
        };
    }

e atualizou a consulta base para o seguinte:

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

Isso é logicamente equivalente à solução de James Manning, com a vantagem de empurrar o inchaço da inicialização do membro para o objeto de transferência de classe / dados

Nota: Originalmente, eu estava usando nomes mais descritivos que "Initializer", mas depois de revisar como o estava usando, descobri que "Initilizer" era suficiente (pelo menos para meus propósitos).

Nota final:
Depois de criar esta solução, eu originalmente pensava que seria simples compartilhar o mesmo código e adaptá-lo ao trabalho para a sintaxe de consulta também. Não acredito mais que seja esse o caso. Eu acho que se você quiser usar esse tipo de construção abreviada, precisará de um método para cada fluente (consulta, fluente), conforme descrito acima, que possa existir na própria classe de objeto.

Para a sintaxe da consulta, seria necessário um método de extensão (ou algum método fora da classe base). (como a sintaxe da consulta deseja operar um IQueryable em vez de T)

Aqui está um exemplo do que eu usei para finalmente fazer com que isso funcionasse para a sintaxe da consulta. (Yoda já acertou em cheio, mas acho que o uso pode ser mais claro porque não o compreendi a princípio)

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

e o uso

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

Embora seja tarde para responder, ainda pode ajudar alguém em perigo. Desde o LINQ para entidades, não há suporte para construções de objetos sem parâmetros. No entanto, os métodos de projeção para IEnumerable .

Portanto, antes da seleção, basta converter seu IQueryable para IEnumerable usando este código:

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

Vai funcionar bem. No entanto, é claro, perderá os benefícios das 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; }
        ...
}