C# 同时收集2个数据集的Linq

我有两份清单：

List<A> listA1 = GetFirstList();
List<A> listA2 = GetSecondList();

我正在做一些基于以下条件的事情

List<A> listA1 = GetFirstList();
List<A> listA2 = GetSecondList();
List<A> result = new List<A>();
for(int i = 0; i < listA1; i++)
{
    if(listA1[i].ModifiedDate != listA2[i].ModifiedDate)
    {
        result.Add(listA1[i]);
    }
}

但它将在

ListA1

和

ListA2

上迭代，但在第一种情况下，它只迭代一次

---

我的问题是，我可以通过保存其他集合的索引来执行

LINQ

？换句话说，我可以使

LINQ

比现在更优化吗？

您可以使用以下一个线性程序：

List<A> result = listA1.Where((t, i) => t.ModifiedDate != listA2[i].ModifiedDate).ToList();

List result=listA1.Where（（t，i）=>t.ModifiedDate！=listA2[i].ModifiedDate.ToList（）；

您可以使用

Enumerable.Zip

按索引链接两个序列：

List<A> result = listA1.Zip(listA2, (a1, a2) => new { a1, a2 })
    .Where(x => x.a1.ModifiedDate != x.a2.ModifiedDate)
    .Select(x => x.a1)
    .ToList();

List result=listA1.Zip（listA2，（a1，a2）=>new{a1，a2}）
.其中（x=>x.a1.ModifiedDate！=x.a2.ModifiedDate）
.选择（x=>x.a1）
.ToList（）；

---

即使两个序列都没有实现

IList

/

IList

，这也会起作用，因此无法通过索引访问项目。

您可以使用列表A1。除了（列表A2，cmp），cmp是一个IComparaer。比如：

void Main()
{
    List<A> listA1 = new List<A> {
       new A { Id=1, ModifiedDate=new DateTime(2016,1,1), Type="A"},
       new A { Id=2, ModifiedDate=new DateTime(2016,1,2), Type="A"},
       new A { Id=3, ModifiedDate=new DateTime(2016,1,3), Type="A"},
       new A { Id=4, ModifiedDate=new DateTime(2016,1,4), Type="A"},
    };
    List<A> listA2 = new List<A> {
       new A { Id=1, ModifiedDate=new DateTime(2016,1,1), Type="A"},
       new A { Id=2, ModifiedDate=new DateTime(2016,1,2), Type="A"},
       new A { Id=3, ModifiedDate=new DateTime(2016,1,3), Type="A"},
       new A { Id=4, ModifiedDate=new DateTime(2016,1,5), Type="A"},
       new A { Id=5, ModifiedDate=new DateTime(2016,1,6), Type="A"},
       new A { Id=6, ModifiedDate=new DateTime(2016,1,7), Type="A"},
    };

    var cmp = new AEqualityComparer();
    var result = listA1.Except(listA2, cmp);

    foreach (var item in result)
    {
        Console.WriteLine("Id:{0}, Date:{1}",item.Id, item.ModifiedDate);
    }
}

public class A
{
    public int Id { get; set; }
    public DateTime ModifiedDate { get; set; }
    public string Type { get; set; }
}

public class AEqualityComparer : IEqualityComparer<A>
{
    public bool Equals(A x, A y)
    {
        return x.Id == y.Id && x.ModifiedDate == y.ModifiedDate;
    }

    public int GetHashCode(A obj)
    {
        return obj.ToString().GetHashCode();
    }
}

void Main（）
{
listA1=新列表{
新的A{Id=1，ModifiedDate=new DateTime（2016,1,1），Type=“A”}，
新的A{Id=2，ModifiedDate=new DateTime（2016,1,2），Type=“A”}，
新的A{Id=3，ModifiedDate=new DateTime（2016,1,3），Type=“A”}，
新的A{Id=4，ModifiedDate=new DateTime（2016,1,4），Type=“A”}，
};
listA2=新列表{
新的A{Id=1，ModifiedDate=new DateTime（2016,1,1），Type=“A”}，
新的A{Id=2，ModifiedDate=new DateTime（2016,1,2），Type=“A”}，
新的A{Id=3，ModifiedDate=new DateTime（2016,1,3），Type=“A”}，
新的A{Id=4，ModifiedDate=new DateTime（2016,1,5），Type=“A”}，
新的A{Id=5，ModifiedDate=new DateTime（2016,1,6），Type=“A”}，
新的A{Id=6，ModifiedDate=new DateTime（2016,1,7），Type=“A”}，
};
var cmp=新的AEqualityComparer（）；
var结果=列表A1。除了（列表A2，cmp）；
foreach（结果中的var项目）
{
WriteLine（“Id:{0}，日期：{1}”，item.Id，item.ModifiedDate）；
}
}
公共A类
{
公共int Id{get；set；}
公共日期时间修改日期{get；set；}
公共字符串类型{get；set；}
}
公共类AEqualityComparer:IEqualityComparer
{
公共布尔等于（A x，A y）
{
返回x.Id==y.Id&&x.ModifiedDate==y.ModifiedDate；
}
公共int GetHashCode（一个obj）
{
返回obj.ToString（）.GetHashCode（）；
}
}

@cfrozendath不正确，这是假设性代码，不适合代码审查。在建议迁移之前，请先了解站点的主题。@syb0rg这是如何假设的？@cfrozendath有关详细信息，请参阅此。相关章节包括“它已被剥夺了所有上下文”和“问题基于真实故事-换句话说，它是虚构的假设代码”@cfrozendath类型名

A

是一个强有力的指示器。此外，代码被非常精简到只处理手头的问题这一事实意味着，这不是使其成为一行程序所需的实际代码（尤其是在更大的上下文中）@阿德里亚尼福托德：这是一种说法。如果人们能够以可读的方式阅读，为什么我要强迫他们滚动呢？你不需要在这里跟踪索引，它不再是相同的代码了是的，我不需要。此代码不受相同ITERM数量和顺序的假设。对我来说，这是一个危险的假设。在现实生活中，只比较日期而不考虑Id是不现实的（与特殊情况有很大的矛盾）。有两个缺点。如果第二个集合较小，并且需要实现

IList

@TimSchmelter的集合类型，则引发异常。我还惊讶于获得接受标记。请注意，OP声明：假设：两个列表包含相同数量的项目，并且他使用

list

作为输入（实现了

IList

，不是吗？）

List<A> result = listA1.Zip(listA2, (a1, a2) => new { a1, a2 })
    .Where(x => x.a1.ModifiedDate != x.a2.ModifiedDate)
    .Select(x => x.a1)
    .ToList();

void Main()
{
    List<A> listA1 = new List<A> {
       new A { Id=1, ModifiedDate=new DateTime(2016,1,1), Type="A"},
       new A { Id=2, ModifiedDate=new DateTime(2016,1,2), Type="A"},
       new A { Id=3, ModifiedDate=new DateTime(2016,1,3), Type="A"},
       new A { Id=4, ModifiedDate=new DateTime(2016,1,4), Type="A"},
    };
    List<A> listA2 = new List<A> {
       new A { Id=1, ModifiedDate=new DateTime(2016,1,1), Type="A"},
       new A { Id=2, ModifiedDate=new DateTime(2016,1,2), Type="A"},
       new A { Id=3, ModifiedDate=new DateTime(2016,1,3), Type="A"},
       new A { Id=4, ModifiedDate=new DateTime(2016,1,5), Type="A"},
       new A { Id=5, ModifiedDate=new DateTime(2016,1,6), Type="A"},
       new A { Id=6, ModifiedDate=new DateTime(2016,1,7), Type="A"},
    };

    var cmp = new AEqualityComparer();
    var result = listA1.Except(listA2, cmp);

    foreach (var item in result)
    {
        Console.WriteLine("Id:{0}, Date:{1}",item.Id, item.ModifiedDate);
    }
}

public class A
{
    public int Id { get; set; }
    public DateTime ModifiedDate { get; set; }
    public string Type { get; set; }
}

public class AEqualityComparer : IEqualityComparer<A>
{
    public bool Equals(A x, A y)
    {
        return x.Id == y.Id && x.ModifiedDate == y.ModifiedDate;
    }

    public int GetHashCode(A obj)
    {
        return obj.ToString().GetHashCode();
    }
}