使用LINQ、Lambda表示式 、委託快速比較兩個集合，找出需要新增、修改、刪除的物件
摘要：
本文需要對C#裡的LINQ、Lambda 表示式 、委託有一定了解。
在工作中，經常遇到需要對比兩個集合的場景，如：
頁面集合資料修改，需要儲存到資料庫
全量同步上游資料到本系統資料庫
在這些場景中，需要識別出需要新增、更新、刪除的資料，由於每次應用是，需要...
本文需要對C#裡的LINQ、Lambda 表示式 、委託有一定了解。
在工作中，經常遇到需要對比兩個集合的場景，如：
- 頁面集合資料修改，需要儲存到資料庫
- 全量同步上游資料到本系統資料庫
在這些場景中，需要識別出需要新增、更新、刪除的資料，由於每次應用是，需要比較的物件型別不一致，因此寫了個相對通用的方法。這個過程中，需要理解的有以下2個核心概念：
- 唯一標識比較 : 如果兩個物件的唯一標識相等，則認為這兩個物件在業務上代表同一個東西（次要屬性是否相等暫不考慮）。
- 實體比較 ：表示兩個物件在業務是不是相等（唯一標識相等、次要屬性相等）。
程式碼示例如下：
void Main()
{
// 對比源集合
var source = GenerateStudent(1, 10000, 1000);
// 目標集合
var target = GenerateStudent(5000, 10000, 1000);
// 唯一標識比較
Func<Student, Student, bool> keyCompartor = (s, t) => s.Id == t.Id;
// 實體相等比較
Func<Student, Student, bool> entityCompartor = (s, t) => s.Id == t.Id && s.Name.Equals(t.Name) && s.Age == t.Age;
// 新增前準備
Func<Student, Student> insertAction = (s) =>
{
return new Student
{
Id = s.Id,
Name = s.Name,
Age = s.Age,
Operation = "Insert"
};
};
// 更新前準備
Func<Student, Student, Student> updateAction = (s, t) =>
{
t.Name = s.Name;
t.Age = s.Age;
t.Operation = "Update";
return t;
};
// 刪除前準備
Func<Student, Student> deleteAction = (t) =>
{
t.Operation = "Delete";
return t;
};
// 去掉相等物件
RemoveDuplicate(source, target, entityCompartor, (s1, s2) => s1.Id == s2.Id, keyCompartor);
// 需要新增的集合
var insertingStudents = GetInsertingEntities(source, target, keyCompartor, insertAction);
// 需要更新的集合
var updatingStudents = GetUpdatingEntities(source, target, keyCompartor, entityCompartor, updateAction);
// 需要刪除的集合
var deletingStudents = GetDeletingEntities(source, target, keyCompartor, deleteAction);
// 後續業務
// InsertStudents(insertingStudents);
// UpdateStudents(updatingStudents);
// DeleteStudents(deletingStudents);
}
// 集合去重
private void RemoveDuplicate<S, T>(List<S> source, List<T> target, Func<S, T, bool> entityCompartor,
Func<S, S, bool> sourceKeyCompartor, Func<S, T, bool> keyComportor)
{
var sameEntities = source.Where(s => target.Exists(t => entityCompartor(s, t))).ToList();
source.RemoveAll(s => sameEntities.Exists(s2 => sourceKeyCompartor(s, s2)));
target.RemoveAll(t => sameEntities.Exists(s => keyComportor(s, t)));
}
// 獲取需要新增的物件集合
private List<T> GetInsertingEntities<S, T>(List<S> source, List<T> target, Func<S, T, bool> keyComportor,
Func<S, T> insertAction)
{
var result = new List<T>();
foreach (var s in source)
{
var t = target.FirstOrDefault(x => keyComportor(s, x));
if (t == null)
{
// 目標集合中不存在，則新增
result.Add(insertAction(s));
}
}
return result;
}
// 獲取需要更新的物件集合
private List<T> GetUpdatingEntities<S, T>(List<S> source, List<T> target, Func<S, T, bool> keyComportor,
Func<S, T, bool> entityCompartor, Func<S, T, T> updateAction)
{
var result = new List<T>();
foreach (var s in source)
{
var t = target.FirstOrDefault(x => keyComportor(s, x));
if (t != null && !entityCompartor(s, t))
{
// 目標集合中存在，但是次要屬性不相等，則更新
result.Add(updateAction(s, t));
}
}
return result;
}
// 獲取需要刪除的物件集合
private List<T> GetDeletingEntities<S, T>(List<S> source, List<T> target,
Func<S, T, bool> keyComportor, Func<T, T> deleteAction)
{
var result = new List<T>();
foreach (var t in target)
{
var s = source.FirstOrDefault(x => keyComportor(x, t));
if (s == null)
{
// 源集合中存在，目標集合中需要刪除
result.Add(deleteAction(t));
}
}
return result;
}
// 隨機生成測試集合
private List<Student> GenerateStudent(int minId, int maxId, int maxNumber)
{
var r = new Random();
var students = new List<Student>();
for (int i = 0; i < maxNumber; i++)
{
students.Add(new Student
{
Id = r.Next(minId, maxId),
Name = $"name: {r.Next(1, 10)}",
Age = r.Next(6, 10)
});
}
return students.GroupBy(s => s.Id).Select(s => s.First()).ToList();
}
public class Student
{
public int Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public string Operation { get; set; }
}
例子中源集合與目標集合使用了相同的物件Student
，但實際使用中，兩者的型別可以不一樣，只要最終返回目標集合的型別就可以了。
上面是我對集合比較的一點心得，只滿足了小資料量的業務情景，並沒有在大資料量的情況下做過調優。在這裡也算是拋磚引玉，大家要是有更好的辦法，還希望不吝賜教。