Question

我在stackoverflow上看了很多类似的问题，但我还没有看到与我的问题完全匹配。

我需要比较两个＆＃34;嵌套列表列表＆＃34;并捕捉差异。一个是＆＃34; old＆＃34;列表和另一个是＆＃34;新＆＃34;名单。比较嵌套列表时，如果所有NESTED列表项（MyObject.Ids）按顺序存在于两个列表中，则可以认为它们相等（您可以假设嵌套的MyObject.Ids列表已经排序且没有排序一式两份）。 MyObject.Id和MyObject.Name属性在相等比较中没有考虑，但它们仍然是MyObject的重要元数据，不应该丢失。

我不是在寻找一个平等的布尔指标。相反，我需要创建三个新列表来捕获旧列表和新列表之间的差异（例如，已添加的项目列表，已删除的项目列表以及两个列表中都存在的项目列表）。 / p>

以下是一些代码的示例，它完全符合我的要求！我想知道的是如何使这更短/更好/更简单（切掉其中一个for循环将是一个良好的开端）。为了使事情更棘手，请假设您不能对MyObject类进行任何更改或使用任何自定义Equals / IEqualityComparer等实现。

public class MyObject
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public List<Guid> Ids { get; set; }
}

...

// Get the list of existing objects (assume this returns some populated list)

List<MyObject> existingObjects = GetExistingObjects();

// Create a list of updated objects

List<MyObject> updatedObjects = new List<MyObject>()
{
    new MyObject()
    {
        Ids = new List<Guid>() { new Guid("48af3cb9-945a-4ab9-91e4-7ee5765e5304"), new Guid("54b5128a-cf53-436c-9d88-2ef7abd15140") }
    },

    new MyObject()
    {
        Ids = new List<Guid>() { new Guid("0485382f-8f92-4a71-9eba-09831392ceb9"), new Guid("3d8b98df-caee-41ce-b802-2f0c5f9742de") }
    }
};

// Do the comparison and capture the differences

List<MyObject> addedObjects = new List<MyObject>();
List<MyObject> removedObjects = new List<MyObject>();
List<MyObject> sameObjects = new List<MyObject>();

foreach (MyObject obj in updatedObjects)
{
    if (existingObjects.Any(list => list.Ids.SequenceEqual(obj.Ids)))
    {
        sameObjects.Add(obj);
        continue;
    }

    addedObjects.Add(obj);
}

foreach (MyObject obj in existingObjects)
{
    if (!updatedObjects.Any(list => list.Ids.SequenceEqual(obj.Ids)))
    {
        removedObjects.Add(obj);
    }
}

Answer 1

这里有点短（由于消除了第二个循环）而且好一点（由于消除了第二个循环中包含的无效搜索）。由于循环中包含的无效搜索，仍然存在O（N ^ 2）时间复杂度。

var addedObjects = new List<MyObject>();
var removedObjects = new List<MyObject>(existingObjects);
var sameObjects = new List<MyObject>();
foreach (var newObject in updatedObjects)
{
    int index = removedObjects.FindIndex(oldObject => oldObject.Ids.SequenceEqual(newObject.Ids));
    if (index < 0)
        addedObjects.Add(newObject);
    else
    {
        removedObjects.RemoveAt(index);
        sameObjects.Add(newObject);
    }
}

更新：更短，但IMO肯定不会更好（事实上性能更差）版本

var addedObjects = updatedObjects.Where(newObject => !existingObjects.Any(oldObject => oldObject.Ids.SequenceEqual(newObject.Ids))).ToList();
var removedObjects = existingObjects.Where(oldObject => !updatedObjects.Any(newObject => newObject.Ids.SequenceEqual(oldObject.Ids))).ToList();
var sameObjects = updatedObjects.Where(newObject => !addedObjects.Any(addedObject => addedObject.Ids.SequenceEqual(newObject.Ids))).ToList();

如果MyObject没有定义自定义相等比较，即使用默认引用相等，则最后一行可以替换为更短且性能更好的

var sameObjects = updatedObjects.Except(addedObjects);

Answer 2

您可以在Linq中使用 Intersect 和除功能
使用Intersect，您将获得现有对象，
除了你将获得新的对象。

MSDN以外的例子：

double[] numbers1 = { 2.0, 2.1, 2.2, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

比较两个嵌套列表列表并返回添加/更改/删除的项目

2 个答案: