Comment utiliser LINQ, les expressions Lambda et les délégués pour comparer rapidement deux collections et rechercher des objets qui doivent être ajoutés, modifiés ou supprimés (code joint)

Le contenu de cet article explique comment utiliser LINQ, les expressions Lambda et les délégués pour comparer rapidement deux collections et découvrir les objets qui doivent être ajoutés, modifiés et supprimés (avec du code). . Les amis dans le besoin peuvent s'y référer, j'espère que cela vous sera utile.

Au travail, nous rencontrons souvent des scénarios où nous devons comparer deux collections, tels que :

1. Les données de la collection de pages sont modifiées et doivent être enregistrées dans la base de données

2. Synchroniser toutes les données en amont avec la base de données du système

Dans ces scénarios, il est nécessaire d'identifier les données qui doivent être ajoutées, mises à jour , et supprimé, car chaque application est, Les types d'objets qui doivent être comparés sont incohérents, j'ai donc écrit une méthode relativement générale. Dans ce processus, vous devez comprendre les deux concepts fondamentaux suivants :

1. Comparaison d'ID unique : Si les ID uniques de deux objets sont égaux, les deux objets sont considérés comme égaux. Les objets représentent la même chose en termes commerciaux (la question de savoir si les attributs secondaires sont égaux n'est pas encore prise en compte).

2. Comparaison d'entités : Indique si deux objets sont égaux en entreprise (les identifiants uniques sont égaux, les attributs secondaires sont égaux).

L'exemple de code est le suivant :

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; }
}

Dans l'exemple, la collection source et la collection cible utilisent le même objetStudent, mais en réalité utilisez, les types des deux peuvent être différents, à condition que le type de la collection cible soit finalement renvoyé.

Ce qui précède est mon expérience en matière de comparaison de collections. Il ne répond qu'au scénario commercial d'un petit volume de données et n'a pas été ajusté dans le cas d'un grand volume de données. Cela peut être considéré comme un point de départ. Si quelqu'un a une meilleure solution, j'espère qu'il pourra me donner quelques conseils.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!