查找不在两个列表中的值的最佳方法C＃

Question

我有两个列表需要比较（carOptions和custOptions）。 这两个列表都在我的Customer类中，如下所示：

public class CustomerDTO
{
    public int CustomerId { get; set; }
    //other props removed for brevity
    public List<OptionDTO> SelectedCarOptions { get; set; }
    public List<OptionDTO> SelectedCustomerOptions { get; set; }
} 

        var existingData = _myRepository.GetDataByCustomer(customerId, year);

        var existingCarOptions = existingData.Select(f => f.SelectedCarOptions);
        var existingCustomerOptions = existingData.Select(f => f.SelectedCustomerOptions);

existingData是CustomerDTO的IEnumerable，然后existingCarOptions和existingCustomerOptions是IEnumerable<List<OptionDTO>>

在该方法中，我有一个IEnumerable<OptionDTO>的IEnumerable<OptionDTO>选项列表。然后，我根据枚举将其分为汽车或客户，如下所示：

        var newCarOptions = options.Where(o => o.OptionTypeID == OptionType.CarOptions);
        var newCustomerOptions = options.Where(o => o.OptionTypeID == OptionType.CustomerOptions).ToList();

我需要做的是找到哪些选项在一个集合中，而在其他集合中则没有。

我尝试如下，但在Except上遇到错误（我可能需要在该类中创建自己的静态方法），但是我不确定这是否是最好的方法吗？

        if (existingCarOptions.Count() != newCarOptions.Count())
        {
            //var test = newCarOptions.Except(existingCarOptions);
        }

        if (existingCustomerOptions.Count() != newCustomerOptions.Count())
        {
            //var test2 = newCustomerOptions.Except(existingCustomerOptions);
        }

方法中是否还包含大量代码-如果需要，我可以将其拆分为单独的方法，但是也许有一种更简单的方法可以实现此目的？

Answer 1

如果要比较两个类，可以使用IEqualityComparer

 public class OptionComparer : IEqualityComparer<OptionDTO>
    {
        public bool Equals(OptionDTO x, OptionDTO y)
        {
            if (object.ReferenceEquals(x, y))
            {
                return true;
            }
            if (object.ReferenceEquals(x, null) ||
                object.ReferenceEquals(y, null))
            {
                return false;
            }
            return x.OptionTypeID == y.OptionTypeID ;
        }

        public int GetHashCode(OptionDTO obj)
        {
            if (obj == null)
            {
                return 0;
            }
            return obj.OptionTypeID.GetHashCode();
        }

使用此方法，您可以确定这些类的相等概念是什么。

现在我们可以找到不同的值。

 public List<OptionDTO>CalculateDiffBetweenLists(List<OptionDTO> left, List<OptionDTO> right){

     List<OptionDTO> optionDiff;


    optionDiff = left.Except(right, new OptionComparer ()).ToList();

    return optionDiff ;
}

Answer 2

我假设OptionDTO具有一个名为Id的属性，该属性唯一地标识一个选项（如果不是这种情况，则必须相应地更改代码），可以使用HashSet来快速查找不匹配的OptionsDTO ，同时保持整体时间成本O(n) （其中n是组合选项的最大数量）。

创建现有的选项集：

var existingCarOptions = existingData.SelectMany(d => d.SelectedCarOptions).Select(o => o.Id);
var existingCustomerOptions = existingData.SelectMany(d => d.SelectedCustomerOptions).Select(o => o.Id);

var existingCarOptionsIds = new HashSet<int>(existingCarOptions);
var existingCustomerOptionsIds = new HashSet<int>(existingCustomerOptions );

然后，使用以下命令提取现有集中缺少的选项：

var unmatchedCarOptions = newCarOptions.Where(o => !existingCarOptionsIds.Contains(o.Id));
var unmatchedCustomerOptions = newCustomerOptions.Where(o => !existingCustomerOptionsIds.Contains(o.Id));