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>选项列表。然后我根据Enum将其分解为汽车或客户，如下所示：

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

该方法中是否还有相当多的代码 - 如果需要，我可以将其拆分为sperate方法，但也许有一种更简单的方法可以达到这个目的？

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的属性，该属性唯一标识一个选项（如果不是这样，你必须相应地更改代码），你可以使用{{1} } s快速找到不匹配的HashSet，同时保持总时间成本OptionsDTO（其中n是组合选项的最大数量）。

创建现有选项集：

O(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 );

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

2 个答案: