Question

I need help finding the most efficient way to merge two in-memory collections with LINQ-to-Objects. In my case, it’s not a simple join or concat because certain items need to be excluded based on a property value.

Let’s use the following example (not very realistic, but it illustrates what I need):

public abstract class Person
{
    public String Name { get; set; }
}

public class Employee : Person
{
    public DateTime? TerminationDate { get; set; }
}

public class Customer : Person
{
    ...
}

Note, an Employee may also be a Customer.

I have a list of Employees and a list of Customers and want to generate a list of all Persons following these rules:

1. All Customers that are not also Employees
2. All Employees that are not also Customer AND are not terminated (TerminationDate == null)
3. All Persons that are both Customers and Employees AND are not terminated (TerminationDate == null)

What’s the most efficient way to accomplish this?

Answer 1

While not necessarily incorrect, James’ example is a bit more complicated that I was hoping for and is incomplete as I need a single list as the end result.

Not sure this is the best solution, either, but here’s what I came up with so far:

public abstract class Person
{
    public String Name { get; set; }

    public override Boolean Equals(Object other)
    {
        var otherPerson = other as Person;

        if (otherPerson == null)
            return false;

        return Name.Equals(otherPerson.Name, StringComparison.OrdinalIgnoreCase);
    }
}

public class Employee : Person
{
    public DateTime? TerminationDate { get; set; }
}

public class Customer : Person
{
    ...
}


public class People
{
    private IEnumerable<Customer> Customers;
    private IEnumerable<Employee> Employees;

    public IEnumerable<Person> GetCurrentPeople()
    {
        // Find all customers that are not employees
        var onlyCustomers = Customers.Except(Employees);

        // We only want employees that have not been terminated
        var currentEmployees = Employees.Where(e => e.TerminationDate == null);

        // Find all customers that are also employees
        var customerAndEmployees = currentEmployees.Intersect(Customers);

        // Now deal with employees that are not customers
        var onlyEmployees = currentEmployees.Except(Customers);

        // Join the lists together
        var mergedRules = onlyCustomers.Concat(onlyEmployees).Concat(customerAndEmployees);

        return mergedRules;
    }
}