比较一个最佳列表是否是C＃中另一个列表的子集的最佳方法

Question

I have the below two classes:

public class FirstInner
{
    public int Id { get; set; }
    public string Type { get; set; }
    public string RoleId { get; set; }
}
public class SecondInner
{
    public int Id { get; set; }
    public string Type { get; set; }            
}

Again, there are lists of those types inside the below two classes:

public class FirstOuter
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Title { get; set; }
    public List<FirstInner> Inners { get; set; }
}
public class SecondOuter
{
    public int Id { get; set; }
    public string Name { get; set; }         
    public List<SecondInner> Inners { get; set; }
}

Now, I have list of FirstOuter and SecondOuter . I need to check if FirstOuter list is a subset of SecondOuter list.

Please note:

1. The names of the classes cannot be changed as they are from different systems.
2. Some additional properties are present in FirstOuter but not in SecondOuter . When comparing subset, we can ignore their presence in SecondOuter .
3. No.2 is true for FirstInner and SecondInner as well.
4. List items can be in any order--- FirstOuterList[1] could be found in SecondOuterList[3] , based on Id, but inside that again need to compare that FirstOuterList[1].FirstInner[3] , could be found in SecondOuterList[3].SecondInner[2] , based on Id.

I tried Intersect, but that is failing as the property names are mismatching. Another solution I have is doing the crude for each iteration, which I want to avoid.

Should I convert the SecondOuter list to FirstOuter list, ignoring the additional properties?

---

Basically, here is a test data:

var firstInnerList = new List<FirstInner>();
firstInnerList.Add(new FirstInner
{
    Id = 1,
    Type = "xx",
    RoleId = "5"
});
var secondInnerList = new List<SecondInner>();
secondInner.Add(new SecondInner
{
    Id = 1,
    Type = "xx"
});
var firstOuter = new FirstOuter 
{
    Id = 1,
    Name = "John",
    Title = "Cena",
    Inners = firstInnerList
}
var secondOuter = new SecondOuter
{
    Id = 1,
    Name = "John",
    Inners = secondInnerList,
}
var firstOuterList = new List<FirstOuter> { firstOuter };
var secondOuterList = new List<SecondOuter> { secondOuter };

Need to check if firstOuterList is part of secondOuterList (ignoring the additional properties).

Answer 1

So the foreach way that I have is:

foreach (var item in firstOuterList)
        {
            var secondItem = secondOuterList.Find(so => so.Id == item.Id);
            //if secondItem is null->throw exception
            if (item.Name == secondItem.Name)
            {
                foreach (var firstInnerItem in item.Inners)
                {
                    var secondInnerItem = secondItem.Inners.Find(sI => sI.Id == firstInnerItem.Id);
                    //if secondInnerItem is null,throw exception
                    if (firstInnerItem.Type != secondInnerItem.Type)
                    {
                        //throw exception
                    }
                }
            }
            else
            {
                //throw exception
            }
        }
        //move with normal flow

Please let me know if there is any better approach.

Answer 2

First, do the join of firstOuterList and secondOuterList

bool isSubset = false;
var firstOuterList = new List<FirstOuter> { firstOuter };
var secondOuterList = new List<SecondOuter> { secondOuter };

var jointOuterList = firstOuterList.Join(
      secondOuterList,
      p => new { p.Id, p.Name },
      m => new { m.Id, m.Name },
      (p, m) => new { FOuterList = p, SOuterList = m }
);

if(jointOuterList.Count != firstOuterList.Count)
{
      isSubset = false;
      return;
}

foreach(var item in jointOuterList)
{
      var jointInnerList = item.firstInnerList.Join(
                 item.firstInnerList,
                 p => new { p.Id, p.Type },
                 m => new { m.Id, m.type },
                 (p, m) => p.Id
      );

      if(jointInnerList.Count != item.firstInnerList.Count)
      {
                isSubset = false;
                return;
      }
}

Note: I am assuming Id is unique in its outer lists. It means there will not be multiple entries with same id in a list. If no, then we need to use group by in above query

Answer 3

I think to break the question down..

• We have two sets of Ids, the Inners and the Outers.
• We have two instances of those sets, the Firsts and the Seconds.
• We want Second's inner Ids to be a subset of First's inner Ids.
• We want Second's outer Ids to be a subset of First's outer Ids.

If that's the case, these are a couple of working test cases:

    [TestMethod]
    public void ICanSeeWhenInnerAndOuterCollectionsAreSubsets()
    {
        HashSet<int> firstInnerIds = new HashSet<int>(GetFirstOuterList().SelectMany(outer => outer.Inners.Select(inner => inner.Id)).Distinct());
        HashSet<int> firstOuterIds = new HashSet<int>(GetFirstOuterList().Select(outer => outer.Id).Distinct());
        HashSet<int> secondInnerIds = new HashSet<int>(GetSecondOuterList().SelectMany(outer => outer.Inners.Select(inner => inner.Id)).Distinct());
        HashSet<int> secondOuterIds = new HashSet<int>(GetSecondOuterList().Select(outer => outer.Id).Distinct());

        bool isInnerSubset = secondInnerIds.IsSubsetOf(firstInnerIds);
        bool isOuterSubset = secondOuterIds.IsSubsetOf(firstOuterIds);

        Assert.IsTrue(isInnerSubset);
        Assert.IsTrue(isOuterSubset);
    }

    [TestMethod]
    public void ICanSeeWhenInnerAndOuterCollectionsAreNotSubsets()
    {
        HashSet<int> firstInnerIds = new HashSet<int>(GetFirstOuterList().SelectMany(outer => outer.Inners.Select(inner => inner.Id)).Distinct());
        HashSet<int> firstOuterIds = new HashSet<int>(GetFirstOuterList().Select(outer => outer.Id).Distinct());
        HashSet<int> secondInnerIds = new HashSet<int>(GetSecondOuterList().SelectMany(outer => outer.Inners.Select(inner => inner.Id)).Distinct());
        HashSet<int> secondOuterIds = new HashSet<int>(GetSecondOuterList().Select(outer => outer.Id).Distinct());

        firstInnerIds.Clear();
        firstInnerIds.Add(5);
        firstOuterIds.Clear();
        firstOuterIds.Add(5);

        bool isInnerSubset = secondInnerIds.IsSubsetOf(firstInnerIds);
        bool isOuterSubset = secondOuterIds.IsSubsetOf(firstOuterIds);

        Assert.IsFalse(isInnerSubset);
        Assert.IsFalse(isOuterSubset);
    }

   private List<FirstOuter> GetFirstOuterList()  { ... }

   private List<SecondOuter> GetSecondOuterList()  { ... }