最简单的方式形成两个对象列表的联合(包含Int和字符串值)

好的，那么你有一些东西的序列，在你的例子中，"某事"将是Company，它不覆盖object.Equals或object.HashCode。

所以，像这样的一个新的扩展，可能是有用的

public static IEnumerable<T> Union(
    this IEnumerable<T> source,
    IEqualityComparer<T> comparer,
    params IEnumerable<T>[] others)
{
    if (comparer == null)
    {
        comparer = EqualityComparer<T>.Default;
    }
    var result = source.Distinct(comparer); 
    foreach(var o in source)
    {
        if (o == null)
        {
            continue;
        }
        result = result.Union(o, comparer);
    }
    return result;
}

要使这个和其他使用IEqualityComparer的函数易于使用，可以将这个类添加到代码中，

public class EqualityComparerImproved<T> : EqaulityComparer<T>
{
    private readonly Func<T, T> equalityComparison;
    private readonly Func<T, int> hashGenerator;
    private EqualityComparerImproved(
             Func<T, T> equalityComparison,
             Func<T, int> hashGenerator)
    {
        this.equalityComparison = equalityComparison;
        this.hashGenerator = hashGenerator;
    }
    public static EqualityComparerImproved<T> Create
             Func<T, T> equalityComparison,
             Func<T, int> hashGenerator)
    {
         if (equalityComparison == null)
         {
             throw new ArgumentNullException("equalityComparison");
         }
         if (hashGenerator == null)
         {
             throw new ArgumentNullException("hashGenerator");
         }
         return new EqualityComparerImproved<T>(
             equalityComparison,
             hashGenerator);
    }
    public override bool Equals(T x, T y)
    {
        return this.equalityComparison(x, y);
    }
    public override int GetHashCode(T obj)
    {
        return this.hashGenerator(obj);
    }
}

一旦这两段代码(诚然很长)就位，你就可以执行

var output = list1.Union(
    EqualityComparerImproved<Company>.Create(
        (x, y) => x.companyNo == y.companyNo && x.Name == y.Name,
        (obj) =>
            {
                unchecked // Overflow is fine, just wrap
                {
                    int hash = 17;
                    hash = hash * 23 + obj.companyNo;
                    hash = hash * 23 + obj.Name.GetHashCode();
                    return hash;
                }
            },
    list2,
    list3,
    list4,
    list5);

或者如果companyNo是唯一键，

var output = list1.Union(
    EqualityComparerImproved<Company>.Create(
        (x, y) => x.companyNo == y.companyNo,
        (obj) => obj.companyNo),
    list2,
    list3,
    list4,
    list5);

。

与Habib的解决方案类似，但更简洁和完整。

int[] userIDs = new[] { userID1, userID2, userID3, userID4, userID5 };
IEnumerable<Company> distinctCompanies =
    from companyList in userIDs.Select(CompanyList.GetList)
    from company in companyList
    group company by company.companyNo into companiesWithSameNo
    select companiesWithSameNo.First();
CompanyList finalList = new CompanyList();
finalList.AddRange(distinctCompanies);

您可能在CompanyList中也有一个直接接受IEnumerable<Company>的构造函数，因此您可以直接在那里传递distinctCompanies。

您可以使用GroupBy或Union来删除重复项…(我认为)工会可以使路线更清晰，但两者都可以…缺点是，你还需要一个自定义的IEqualityComparer在这种情况下，因为等于你的公司对象将返回false(因为他们是不同的实例)…另一种选择是让您的Company类实现IEqualityComparer，并将我实现该接口的代码复制到您的Company类中。

// Union gives you a unique list if it knows how to compare the objects properly
var companyEqualityComparer = new CompanyEqualityComparer();
foreach (var companyList in new List<List<Company>>(){list2, list3, list4, list5})
{
    combinedList = combinedList.Union(companyList, companyEqualityComparer);
}
// Order your output list
var finalList = combinedList.OrderBy(c => c.companyNo).ToList();

定义你的companyqualitycomparer…

// CompanyEqualityComparer which is needed since your companies are different instances
public class CompanyEqualityComparer : IEqualityComparer<Company>
{
    public bool Equals(Company x, Company y)
    {
        return x.companyNo.Equals(y.companyNo);
    }
    public int GetHashCode(Company obj)
    {
        return obj.companyNo.GetHashCode();
    }
}

我想你需要这样的东西:

List<Company> inputList = //Get your input List
List<Company> outputList = inputList.GroupBy(r => r.companyNo)
                                    .Select(grp => new Company
                                        {
                                            companyNo = grp.Key,
                                            Name = grp.First().Name,
                                        })
                                    .OrderBy(r=> r.companyNo)
                                    .ToList();