C# 基于实体框架的最佳比较算法

我想知道，在创建历史记录和依赖项的同时，比较创建的多个对象并将其状态更改为非活动（已删除）的最佳方法是什么

这也意味着我在关系表（MarketCookies）中比较过去和现在的对象

我发现一个丑陋的解决方案是计算我改变了多少对象。
为此，让我们调用过去的项目：ListP
以及新项目：ListF

我将此方法分为三个步骤：

1-统计两份名单
2-查找列表F中不存在的ListP对象，并将其状态更改为非活动状态并进行更新
3-创建新对象并保存它们。

但是这个代码很难维护。。如何制作一个易于维护和保留功能的代码

市场模式：

 public class Market()
 {
    public ICollection<Cookie> Cookies {get; set;}
 }

代码：

public void UpdateMarket（市场，内部Id）
{
var ListP=MarketCookiesRepository.GetAll（）
.Where（x=>x.MarketID==Id&&Market.State！=“非活动”）.ToList（）；
var ListF=Market.Cookies.ToList（）；
int ListPCount=ListP.Count（）；
int ListFCount=ListF.Count（）；
如果（ListPCount>ListFCount）
{
ListP.Foreach（x=>
{
var ItemExists=ListF.Where（y=>y.Id==x.Id）.FirstOrDefault（）；
如果（ItemExists==null）
{
//删除对象
}
});
Foreach（x=>
{
var ItemExists=ListP.Where（y=>y.Id==x.Id）.FirstOrDefault（）；
如果（ItemExists==null）
{
//创建对象
}
});
}
else if（ListPCount
{
var ItemExists=ListP.Where（y=>y.Id==x.Id）.FirstOrDefault（）；
如果（ItemExists==null）
{
//创建对象
}
});
ListP.Foreach（x=>
{
var ItemExists=ListF.Where（y=>y.Id==x.Id）.FirstOrDefault（）；
如果（ItemExists==null）
{
//删除对象
}
});
}
else if（ListPCount==ListFCount）
{
ListP.Foreach（x=>
{
var ItemExists=ListF.Where（y=>y.Id==x.Id）.FirstOrDefault（）；
如果（ItemExists==null）
{
//删除对象
}
});
Foreach（x=>
{
var ItemExists=ListP.Where（y=>y.Id==x.Id）.FirstOrDefault（）；
如果（ItemExists==null）
{
//创建对象
}
});
}
}

如果没有这一点，就很难确定一个好的实现会是什么样子，更不用说“最好的”。但是，根据您的描述，似乎LINQ

Except（）

方法实际上可以很好地满足您的需求。例如：

public void UpdateMarket (Market Market, int Id)
{
    var ListP = MarketCookiesRepository.GetAll()
                .Where(x => x.MarketID == Id && Market.State != "Inactive").ToList();
    var ListF = Market.Cookies.ToList();

    foreach (var item in ListP.Except(ListF))
    {
        // set to inactive
    }

    foreach (var item in ListF.Except(ListP))
    {
        // create new object
    }
}

// General-purpose equality comparer implementation for convenience.
// Rather than declaring a new class for each time you want an
// IEqualityComparer<T>, just pass this class appropriate delegates
// to define the actual implementation desired.
class GeneralEqualityComparer<T> : IEqualityComparer<T>
{
    private readonly Func<T, T, bool> _equals;
    private readonly Func<T, int> _getHashCode;

    public GeneralEqualityComparer(Func<T, T, bool> equals, Func<T, int> getHashCode)
    {
        _equals = equals;
        _getHashCode = getHashCode;
    }

    public bool Equals(T t1, T t2)
    {
        return _equals(t1, t2);
    }

    public int GetHashCode(T t)
    {
        return _getHashCode(t);
    }
}

当然，这假设您的对象已经覆盖了

Equals（）

和

GetHashCode（）

。如果没有，您可以为上述内容提供自己的

IEqualityComparer

实现。例如：

public void UpdateMarket (Market Market, int Id)
{
    var ListP = MarketCookiesRepository.GetAll()
                .Where(x => x.MarketID == Id && Market.State != "Inactive").ToList();
    var ListF = Market.Cookies.ToList();

    foreach (var item in ListP.Except(ListF))
    {
        // set to inactive
    }

    foreach (var item in ListF.Except(ListP))
    {
        // create new object
    }
}

// General-purpose equality comparer implementation for convenience.
// Rather than declaring a new class for each time you want an
// IEqualityComparer<T>, just pass this class appropriate delegates
// to define the actual implementation desired.
class GeneralEqualityComparer<T> : IEqualityComparer<T>
{
    private readonly Func<T, T, bool> _equals;
    private readonly Func<T, int> _getHashCode;

    public GeneralEqualityComparer(Func<T, T, bool> equals, Func<T, int> getHashCode)
    {
        _equals = equals;
        _getHashCode = getHashCode;
    }

    public bool Equals(T t1, T t2)
    {
        return _equals(t1, t2);
    }

    public int GetHashCode(T t)
    {
        return _getHashCode(t);
    }
}

//为方便起见，实现了通用等式比较器。
//而不是每次需要一个新类时都声明一个新类
//IEqualityComparer，只需向该类传递适当的委托
//定义所需的实际实现。
类GeneralEqualityComparer:IEqualityComparer
{
私有只读函数_等于；
私有只读Func_getHashCode；
公共GeneralEqualityComparer（Func等于，Func getHashCode）
{
_相等=相等；
_getHashCode=getHashCode；
}
公共布尔等于（t1，t2）
{
返回_等于（t1，t2）；
}
公共整数GetHashCode（T）
{
返回_getHashCode（t）；
}
}

这样使用：

public void UpdateMarket (Market Market, int Id)
{
    var ListP = MarketCookiesRepository.GetAll()
                .Where(x => x.MarketID == Id && Market.State != "Inactive").ToList();
    var ListF = Market.Cookies.ToList();
    IEqualityComparer<Cookie> comparer = new GeneralEqualityComparer<Cookie>(
        (t1, t2) => t1.Id == t2.Id, t => t.Id.GetHashCode());

    foreach (var item in ListP.Except(ListF, comparer))
    {
        // set to inactive
    }

    foreach (var item in ListF.Except(ListP, comparer))
    {
        // create new object
    }
}

public void UpdateMarket（市场，内部Id）
{
var ListP=MarketCookiesRepository.GetAll（）
.Where（x=>x.MarketID==Id&&Market.State！=“非活动”）.ToList（）；
var ListF=Market.Cookies.ToList（）；
IEqualityComparer comparer=新的通用QualityComparer(
（t1，t2）=>t1.Id==t2.Id，t=>t.Id.GetHashCode（））；
foreach（列表中的var项，除（列表、比较器））
{
//设置为非活动
}
foreach（列表F中的var项目除外（列表P、比较器））
{
//创建新对象
}
}

查看集合，特别是包含和添加方法的集合。请看，您可以简单地执行except select语句，该语句具有相同的功能？还是我理解错了什么？

public void UpdateMarket (Market Market, int Id)
{
    var ListP = MarketCookiesRepository.GetAll()
                .Where(x => x.MarketID == Id && Market.State != "Inactive").ToList();
    var ListF = Market.Cookies.ToList();
    IEqualityComparer<Cookie> comparer = new GeneralEqualityComparer<Cookie>(
        (t1, t2) => t1.Id == t2.Id, t => t.Id.GetHashCode());

    foreach (var item in ListP.Except(ListF, comparer))
    {
        // set to inactive
    }

    foreach (var item in ListF.Except(ListP, comparer))
    {
        // create new object
    }
}