仅当第二个 TSource 不为 Null 时才联合集合

Question

我有以下 linq 语句：

List<Type> allTypes = group.GetTypes().Union(group2.GetTypes()).ToList();

当 group2 为 null 时可能会抛出 NullReferenceException

解决此问题的一种方法是在之前执行空检查，例如：

if (group2 != null)
{
    List<Type> allTypes = group.GetTypes().Union(group2.GetTypes()).ToList();
}
else 
{
   List<Type> allTypes = group.GetTypes();
}

但问题是我对不同类型有许多类似的分配，并且不想以这种方式为它们中的每一个执行 if 语句，但我宁愿将 null 检查放在一行中，例如：

 List<Type> allTypes = group.GetTypes().Union((if group2 != null)group2.GetTypes()).ToList();

但不确定如何使用 linq。

Answer 1

您在这里遇到的问题不是 TSource 为空；您要从中获取源的对象为 null (group2)。

您可以随时使用Enumerable.Empty 来保存您的神奇一号线。

List<Type> allTypes = group.GetTypes().Union(group2 != null ? group2.GetTypes() : Enumerable.Empty<Type>()).ToList();

或者您可以使用可重复使用的Union 重载：

public static IEnumerable<T> Union<T>(this IEnumerable<IEnumerable<T>> source)
{
    var set = new HashSet<T>();
    foreach (var s in source)
    {
       foreach (var item in s)
       {
           if (set.Add(item))
               yield return item;
       }
    }
}

然后你的代码变成：

var allTypes = new [] { group, group2 }.Where(x => x != null).Select(x => x.GetTypes()).Union().ToList();

这种方法的优点是可以有两个以上的序列形成一个联合。

Answer 2

这里你只需要一个方法来获取可以支持空参数的组的类型，因为你的不支持。这是一个非常简单的编写方法：

public static IEnumerable<Type> MyGetTypes(Group group)
{
    if(group == null)
        return Enumerable.Empty<Type>();
    else
        return group.GetTypes();
}

（如果你愿意，你可以把它变成一个扩展方法）

您现在可以将原始代码编写为：

var allTypes = MyGetTypes(group).Union(MyGetTypes(group2)).ToList();

---

如果我们愿意，我们也可以概括这一点，而不是让这个方法如此具体。

public static TResult Use<TSource, TResult>(TSource source,
    Func<TSource, TResult> selector,
    TResult defaultValue = default(TResult))
{
    if (source == null)
        return defaultValue;
    else
        return selector(source);
}

我们可以这样写：

var allTypes = group.GetTypes()
    .Union(group2.Use(g => g.GetTypes(), Enumerable.Empty<Type>()))
    .ToList();

---

当 C# 6.0 发布并且我们可以访问 ?. 运算符时，您还可以像这样编写代码：

var allTypes = group.GetTypes()
    .Union(group2?.GetTypes() ?? Enumerable.Empty<Type>())
    .ToList();

这允许空组传播到空类型集合，而不是抛出，然后允许用空集合替换空值，Union 将支持。这个运算符或多或少是我们 Use 方法的内置版本，但它允许我们避免使用 lambda，使其明显更加简洁。

Answer 3

我发现在一行中放置空检查的最佳方法是ternary operator。

List<Type> allTypes = group2 == null ? 
  group.GetTypes() 
  : group.GetTypes().Union(group2.GetTypes()).ToList();

Answer 4

对于这种情况，我通常会创建一个新的扩展方法。例如：

public static IEnumerable<T> SafeUnion<T>(
    this IEnumerable<T> source1, IEnumerable<T> source2)
{
    return source1 != null ?
        (source2 != null ? source1.Union(source2) : source1) : source2;
}

或在您的情况下最有意义的任何特定逻辑（上面将允许可枚举为空...例如，您可能只想允许第二个）。

一些脾气暴躁的人可能会觉得 OP 无法根据自己的需要调整这个想法。我认为他可能不会有任何问题，而且如果没有变量声明，我就无法准确显示它的样子。但它会是这样的bit：

public static List<Type> SafeUnion(this Group group1, Group group2)
{
    return (group2 != null ?
            group1.GetTypes().Union(group2.GetTypes()) : group1.GetTypes();
}

当然，Group 类型需要替换为这些变量的实际类型。此示例也不允许 group1 为空。如果需要的话，大概读者可以自己解决这个变化。