在 LINQ 中如何检查一个列表中内部列表的所有字段与另一个列表中内部列表的所有字段？

Question

这是我的模型：

class A
{
    public string Value { get; set; }
    public int? bId { get; set; }
    public B b { get; set; }
}
class B
{
    public int Id { get; set; }
    public List<A> aList { get; set; }
    public B ()
    {
        aList = new List<A>();
    }
}

现在在我的程序中，我有两个 b 对象，并且想要比较 b 类型中 a 的两个列表。

我有两个 b 列表：

bool checkingDuplicatedObjects(List<B> b1, List<B> b2)
{
    List<B> q = new List<B>();
    if (b1.Count != b2.Count)
        return false;
    for (var i = 0; i < b1.Count; i++)
    {
        var x = b1[i];
        var y = b2[i];
        q = (from n1 in x.aList
             from n2 in y.aList
             where n1.Value == n2.Value
             select x).ToList();
    }
    if (q.Count() > 0)
        return true;
    else
        return false;
}

但我认为这段代码不完全符合逻辑。 你能帮我吗？

Answer 1

我在这里猜测了一点，但我想这可能就是你想要的：

 static bool checkingDuplicatedObjects(List<B> b1, List<B> b2)
 {
     var a = b1.SelectMany(x => x.aList.Select(y => y.Value));
     var b = b2.SelectMany(x => x.aList.Select(y => y.Value));

     return !a.Except(b).Concat(b.Except(a)).Any();
 }

Answer 2

好的，有很多方法可以做到这一点

    bool CheckDup(List<B> b1, List<B> b2)
    {

        if (b1.Count != b2.Count)
        {
            return false;
        }

        for (int i = 0; i < b1.Count; i++)
        {
            B x = b1[i];
            B y = b2[i];

            var c = x.aList.Select(al => al.Value).ToList();
            var d = y.aList.Select(al => al.Value).ToList();

            bool isEqual = c.SequenceEqual(d);

            if (!isEqual)
            {
                return false;
            }
        }

        return true;
    }

但是我们可以通过将 IEqualityComparer<> 添加到 A 来使其看起来更好

class A: IEqualityComparer<A>
{
    public string Value { get; set; }
    public int? bId { get; set; }
    public B b { get; set; }

    public bool Equals(A? a1, A? a2)
    {
        return a1?.Value == a2?.Value;
    }

    public int GetHashCode(A a)
    {
        throw new NotImplementedException();
    }
}

方法现在看起来像这样

    bool CheckDup(List<B> b1, List<B> b2)
    {

        if (b1.Count != b2.Count)
        {
            return false;
        }

        for (int i = 0; i < b1.Count; i++)
        {
            B x = b1[i];
            B y = b2[i];

            bool isEqual = x.aList.SequenceEqual(y.aList);

            if (!isEqual)
            {
                return false;
            }
        }

        return true;
    }

或者我们可以更加疯狂，将接口添加到 B

class B : IEqualityComparer<B>
{
    public int Id { get; set; }
    public List<A> aList { get; set; }
    public B()
    {
        aList = new List<A>();
    }


    public bool Equals(B? b1, B? b2)
    {
        return b1.aList.SequenceEqual(b2.aList);
    }
    public int GetHashCode(B b)
    {
        throw new NotImplementedException();
    }
}

这样进一步缩短了方法

bool CheckDup(List<B> b1, List<B> b2)
{

    if (b1.Count != b2.Count)
    {
        return false;
    }


    bool eq = b1.SequenceEqual(b2);

    return eq;
}