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

Question

I have two lists which I need to compare (carOptions and custOptions). Both of these lists are in my Customer class like below:

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 is an IEnumerable of CustomerDTO and then existingCarOptions and existingCustomerOptions is an IEnumerable<List<OptionDTO>>

In the method, I have a list of IEnumerable<OptionDTO> options that gets passed in. I then break this down into car or customer based on the Enum as below:

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

What I need to do is find which options are in one collection but no in the other.

I tried as below but getting an Error on the Except (I maybe need to create my own static method in that class) but I am not sure this is the best approach really?

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

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

Is it also quite a bit of code in the method - I could split it out into sperate methods if required but perhaps there is a simpler way I could achieve this?

Answer 1

If you want to compare two classes you can use 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();
        }

With using this you can ıdentify that What is the concept of equality for these classes.

Now we can find different values..

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

     List<OptionDTO> optionDiff;


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

    return optionDiff ;
}

Answer 2

I'm assuming OptionDTO has a property called Id , which uniquely identifies an option (you have to change the code accordingly if this is not the case), you may use HashSet s to quickly find unmatched OptionsDTO s, while keeping the overall time cost O(n) (where n is the max number of combined options).

Create the existing options sets:

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

Then you extract options missing in existing sets with:

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