LINQ to Entities仅支持无参数构造函数和初始化程序

我在此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();

知道如何解决这个问题吗？我尝试用表达的任何组合...：/

没有有关“付款”的更多信息，这无济于事，但是假设您要创建一个Payments对象并根据列值设置其某些属性：

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

如果您仍想使用构造函数进行初始化而不是使用属性（有时出于初始化目的需要此行为），请通过调用ToList()或来枚举查询ToArray()，然后使用Select(…)。因此，它将使用LINQ to Collections以及无法使用参数调用构造函数的局限性Select(…)将消失。

因此，您的代码应如下所示：

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

我本人刚刚遇到此错误，我想我要补充一点，如果Payment类型是a struct，那么您也会遇到相同的错误，因为struct类型不支持无参数构造函数。

在这种情况下，转换Payment为类并使用对象初始化器语法将解决此问题。

如果您像我一样，并且不想为正在构建的每个查询填充属性，则可以使用另一种方法来解决此问题。

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

此时，您具有一个包含匿名对象的IQueryable。如果要使用构造函数填充自定义对象，则可以执行以下操作：

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

现在，您的自定义对象（将两个对象作为参数）可以根据需要填充属性。

首先，我会避免使用

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

这需要一个空的构造函数，并且忽略封装，因此您说的是new Payments（）是没有任何数据的有效付款，但是该对象必须至少具有一个值，并且可能还取决于您的域，并且具有其他必填字段。

最好有一个用于必填字段的构造函数，但只带所需的数据：

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

您可以尝试执行相同的操作，但是要使用扩展方法。数据库使用的提供者是什么？

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

只是ToList()在DbSet中前Select声明..实际DbSet保存为一个查询，它尚未完成。调用后，ToList()您正在处理对象，然后可以在查询中使用非默认构造函数。

这不是使用时间上最有效的方法，但是在小型设备上是一个选择。

是的，尝试这样。

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

这将使用无参数构造函数来创建您的Payment对象，然后初始化花括号内列出的属性 { }

除了上述方法之外，您还可以将其解析为Enumerable集合，如下所示：

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

这还有一个额外的好处，就是在构建匿名对象时使生活更轻松，例如：

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

但是请记住，将集合解析为Enumerable会将其拉入内存，因此可能会占用大量资源！在此应谨慎使用。

另外，如果要使用具有多个对象的构造函数进行初始化，则如果Linq不返回任何值，则可能会出错。

因此，您可能需要执行以下操作：

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

很抱歉参加聚会晚了，但是我发现了这一点之后，我认为应该共享它，因为它是我可以找到的最干净，最快，也节省内存的实现。

根据您的示例，您将编写：

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

这里的最大优势（如Damien Guard在链接的评论中指出的那样）是：

• 使您避免在每次出现时都使用初始化模式。
• 可以通过var foo = createPayments(bar);和通过myIQueryable.ToPayments（）使用。

今天我遇到了同样的问题，我的解决方案与Yoda列出的解决方案相似，但是它仅适用于流利的语法。

使我的解决方案适应您的代码：我向对象类添加了以下静态方法

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

然后将基本查询更新为以下内容：

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

从逻辑上讲，这等效于James Manning的解决方案，其优点是将成员初始化的膨胀推到类/数据传输对象上

注意：最初，我使用的是比“ Initializer”更具有描述性的名称，但是在回顾我的用法之后，我发现“ Initilizer”就足够了（至少出于我的目的）。

最后说明：
提出此解决方案后，我本来以为共享相同的代码并使之适用于查询语法也很简单。我不再相信情况会如此。我认为，如果您希望能够使用这种速记类型，则需要为上述每个（查询，流利）流利语言提供一个方法，该方法可以存在于对象类本身中。

对于查询语法，将需要扩展方法（或所使用的基类之外的某些方法）。（因为查询语法要操作IQueryable而不是T）

这是我最终使它适用于查询语法的示例。（Yoda已对此进行了详细说明，但我认为用法可能会更清楚，因为一开始我没有得到它）

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

和用法

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

尽管回答晚了，它仍然可以帮助陷入困境的人。由于LINQ to实体不支持无参数对象构造。但是，IEnumerable的投影方法。

因此，在选择之前，只需将IQueryable转换为使用以下代码 IEnumerable：

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

它将正常工作。但是，它当然会失去本机查询的好处。

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