C# Linq对象枚举

我是linq的新手。我敢肯定，由于缺乏经验，我错过了一些东西

问题是： 我使用linq查询对象并返回可枚举的Acct对象

where o.Diff=0

如果尝试枚举结果，则会出现错误

无法将System.Collections.Generic.KeyValuePair“2[Acct]”类型的对象强制转换为“Acct”

问题是： 如何从Linq查询返回可枚举的Acct对象

提前谢谢

public class AcctSum
{
  string ID;
  Decimal Amt1;
  Decimal Amt2;
  Decimal Diff;
  ArrayList<AcctDet> lines;
}

public class AcctInfo
{
  Dictionary<string,AcctSum> acct

  //code that adds the data...
  public iEnumerable Discrepancies()
  {
    var results = (from Acct a in acct
                   where a.Diff != 0
                   select a).AsEnumerable<Acct>();
    foreach (var result in results)//at runtime this generates an error

    {
    }                                    
    return results.GetEnumerator();
  }
}

公共类科目
{
字符串ID；
十进制Amt1；
十进制Amt2；
十进制差分；
阵列列表线；
}
公共类账户
{
字典帐户
//添加数据的代码。。。
公共iEnumerable差异（）
{
var结果=（来自会计科目中的会计科目a
其中a.Diff！=0
选择a）.AsEnumerable（）；
foreach（var result in results）//在运行时，这会生成一个错误
{
}                                    
返回结果。GetEnumerator（）；
}
}

好吧，它的b/c账户是一个字典（这是一个IEnumerable，iirc，隐藏在引擎盖下。将您的源代码从账户更改为账户。值

好吧，它的b/c账户是一个字典（这是一个IEnumerable，iirc，位于引擎盖下。将源代码从acct更改为acct.Values

当您迭代

acct

时，每个项都是字典中的一个键/值对。假设

acct

对象是每对中的值，您将得到所有非零帐户，如下所示：

from a in acct.Values
where a.Diff != 0
select a

var results = from acctSum value in acct.Values
              where acctSum.Diff != 0
              select acctSum;

---

当您在

acct

上迭代时，每个项目都是字典中的一个键/值对。假设

acct

对象是每个对中的值，您将得到所有非零帐户，如下所示：

from a in acct.Values
where a.Diff != 0
select a

var results = from acctSum value in acct.Values
              where acctSum.Diff != 0
              select acctSum;

---

问题是，当您迭代字典时，您正在将每个项转换为Acct，而实际上，字典中的每个项都是KeyValuePair。请尝试以下操作：

from KeyValuePair<string,AcctSum> acctKVP in acct // assuming acct is of type Dictionary<string,AcctSum>
where acctKvp.Value.Diff != 0

来自acct//中的KeyValuePair acctKVP//假设acct是Dictionary类型
其中acctKvp.Value.Diff！=0

问题在于，当您迭代字典时，您正在将每个项目转换为Acct，而实际上，字典中的每个项目都是一个KeyValuePair。请尝试以下操作：

from KeyValuePair<string,AcctSum> acctKVP in acct // assuming acct is of type Dictionary<string,AcctSum>
where acctKvp.Value.Diff != 0

来自acct//中的KeyValuePair acctKVP//假设acct是Dictionary类型
其中acctKvp.Value.Diff！=0

首先，返回类型应该是IEnumerator，而不是IEnumerable。 其次，acct包含键值对的集合，因此必须对键值运行查询（在本例中）

void Main（）
{
var acctInfo=新acctInfo（）；
会计信息差异（）；
}
公共类科目
{
字符串ID；
十进制Amt1；
十进制Amt2；
公共十进制差异；
阵列列表线；
}
公共类账户
{
公共IEnumerator（）
{
var acct=新字典
{{1，新AcctSum（）{Diff=0.0M}}，{2，新AcctSum（）{Diff=1.0M}}；
var results=（来自会计值中的会计科目a，其中a.Diff！=0选择a）；
foreach（var result in results）//在运行时，这会生成一个错误
{
}
返回结果。GetEnumerator（）；
}
}

首先，返回类型应该是IEnumerator，而不是IEnumerable。 其次，acct包含键值对的集合，因此必须对键值运行查询（在本例中）

void Main（）
{
var acctInfo=新acctInfo（）；
会计信息差异（）；
}
公共类科目
{
字符串ID；
十进制Amt1；
十进制Amt2；
公共十进制差异；
阵列列表线；
}
公共类账户
{
公共IEnumerator（）
{
var acct=新字典
{{1，新AcctSum（）{Diff=0.0M}}，{2，新AcctSum（）{Diff=1.0M}}；
var results=（来自会计值中的会计科目a，其中a.Diff！=0选择a）；
foreach（var result in results）//在运行时，这会生成一个错误
{
}
返回结果。GetEnumerator（）；
}
}

正如其他人所说，听起来您希望迭代值，而不是键/值对

这意味着您可以使用如下查询：

from a in acct.Values
where a.Diff != 0
select a

var results = from acctSum value in acct.Values
              where acctSum.Diff != 0
              select acctSum;

但就我个人而言，在这种情况下，我不会麻烦使用查询表达式。我只会使用扩展方法：

var results = acct.Values.Where(acctSum => acctSum.Diff != 0);

现在，就返回类型而言，我强烈怀疑您希望返回

IEnumerable

，而不是

IEnumerator

或

IEnumerator

。因此，您可能需要：

public IEnumerable<AcctSum> Discrepancies()
{
    return acct.Values.Where(acctSum => acctSum.Diff != 0);
}

public IEnumerable差异（）
{
返回acct.Values.Where（acctSum=>acctSum.Diff！=0）；
}

或者，您可能希望“具体化”查询—一次性获得所有结果，然后返回这些结果（而不是返回可以延迟迭代的查询）。例如：

public IEnumerable<AcctSum> Discrepancies()
{
    return acct.Values.Where(acctSum => acctSum.Diff != 0).ToList();
}

public IEnumerable差异（）
{
返回acct.Values.Where（acctSum=>acctSum.Diff！=0.ToList（）；
}

特别是，通过具体化查询，您允许调用方在迭代这些结果时修改

acct

——如果他们在迭代原始查询时尝试这样做，他们将得到一个异常

---

您还需要更改您的

AcctSum

类，因为

ArrayList

在.NET中不是泛型类型。您是否打算使用

List

？

正如其他人所说，听起来您想迭代的是值，而不是键/值对

这意味着您可以使用如下查询：

from a in acct.Values
where a.Diff != 0
select a

var results = from acctSum value in acct.Values
              where acctSum.Diff != 0
              select acctSum;

但就我个人而言，在这种情况下，我不会麻烦使用查询表达式。我只会使用扩展方法：

var results = acct.Values.Where(acctSum => acctSum.Diff != 0);

现在，就返回类型而言，我强烈怀疑您希望返回

IEnumerable

，而不是

IEnumerator

或

IEnumerator

。因此，您可能需要：

public IEnumerable<AcctSum> Discrepancies()
{
    return acct.Values.Where(acctSum => acctSum.Diff != 0);
}

public IEnumerable差异（）
{
返回acct.Values.Where（acctSum=>acctSum.Diff！=0）；
}

或者您可能希望“具体化”查询—一次性获得所有结果，并返回这些结果（而不是