Question

我在创建对象之前设置了多个变量，我想检查是否有任何变量为null，如果有任何变量则显示错误。有没有办法将它合并到foreach循环中？

例如。

Var Var1 = blah1;
Var Var2 = blah2;
Var Var3 = blah3;
Var Var4 = blah4;
Var Var5 = blah5;

foreach(var above, if any is null)
Errmessage

提前致谢

Answer 1

我个人会对每个变量进行单独检查。对于多次验证检查的“错误消息”是一个坏主意。

这样做的主要原因是您的“错误消息”应该是ArgumentNullException，它应该提供正确的参数名称。每个变量都会有所不同。即使您使用自定义异常，提供有关哪个变量未正确指定的信息也值得额外编码。

话虽这么说，如果你想这样做，你可以使用：

var Var1 = blah1;
var Var2 = blah2;
var Var3 = blah3;
var Var4 = blah4;
var Var5 = blah5;

if ( (new object[] {Var1, Var2, Var3, Var4, Var5}).Any(v => v==null))
    throw new Exception("Your error here");

Answer 2

将它们放在IEnumerable中，例如数组

foreach(var v in new object[] { var1, var2, .... }){
 if(v == null) {
   Errmessage...
 }
}

Answer 3

将它们放入object列表并循环遍历：

List<object> list = new List<object>();
list.add(Var1);
list.add(Var2);
// etc.

foreach(object obj in list)
{
    if(obj == null) //message
}

Answer 4

我的第一个倾向是不使用单独的变量，而是使用一个词典：

var dict = new Dictionary<string, object>();

dict["var1"] = blah1;
// etc.

foreach(var value in dict.Values)
{
    if(value == null)
        throw new Exception(errorMessage);
}

Answer 5

一种方法是在列表中跟踪它们，然后遍历列表：

List<object> objects = new ....;

Var Var1 = blah1;  objects.add(Var1)...
Var Var2 = blah2;  ...
Var Var3 = blah3;  ...
Var Var4 = blah4;  ...
Var Var5 = blah5;  ...

foreach(var objRef, in objects)
    if( objRef == null )
       Errmessage; break ?

Answer 6

如果您的变量数量将来可能会发生变化并且您不想手动列出所有这些变量，那么我建议您使用：

using System.Reflection;

class MyClass{
    var Var1;
    var Var2;
    ...
    var infos = typeof(MyClass).GetFields();
    foreach(var info in infos)
    {
        if(info.GetValue(this)==null) ShowErrorMessage(info.Name);
    }
}

注意：您可以使用GetMembers或GetProperties替换GetFields ......

Answer 7

将所有这些变量放入列表中。然后，您可以根据需要循环遍历它们。

Answer 8

为了获得＆＃34;如果有的话＃34;你所遵循的语义，你可以创建一个静态类，如下所示（我把它放在我的TypeExtensions命名空间中）

public static class NotAssigned {
    public static bool AnyOf( params object[] Objects){
        foreach (var o in Objects)
            if (o == null)
                return true;
        return false;
    }
}

用法如下

Var Var1 = blah1;
Var Var2 = blah2;
if (NotAssigned.AnyOf( blah1, blah2))
    throw new Exception

通过一些小的逻辑调整，你可以抛出一个AllOff函数，也许是一个＆＃34; Assigned＆＃34; class，AnyOf和AllOf。

到目前为止，我只使用了NotAssigned.AnyOf

Answer 9

您可以使用params参数运算符传递空参数列表：

    public static void ThrowIfNull(params object[] input)
    {
        foreach (var item in input)
        {
            //Your choice of how you want to handle this. I chose an exception.
            throw new NullReferenceException();
        }
    }

允许您：

    int? nullableInt = null;
    string someNullString = null;

    ThrowIfNull(nullableInt, someNullString);

还有其他方法可以解决这个问题。例如，您可以为IEnumerable：

创建扩展方法

public static class NullExtensionMethods
{
    public static void ThrowIfHasNull<T>(this IEnumerable collection)
        where T : Exception, new()
    {
        foreach (var item in collection)
        {
            if (item == null)
            {
                throw new T();
            }
        }
    }

    public static void ThrowIfHasNull(this IEnumerable collection)
    {
        ThrowIfHasNull<NullReferenceException>(collection);
    }
}

使这成为可能：

 string someNullString = null;
 new string[] { someNullString }.ThrowIfHasNull();

 //or for context specific exceptions

 new string[] { someNullString }.ThrowIfHasNull<ArgumentNullException>();

虽然我更愿意尽可能避免例外。您可以进行以下更改：

public static class NullExtensionMethods
{
    public static bool HasNull(this IEnumerable collection)
    {
        foreach (var item in collection)
        {
            if (item == null)
            {
                return true;
            }
        }

        return false;
    }
}

让你更优雅地处理事情：

var nullDetected = new string[] { someNullString }.HasNull();

由于我们使用扩展方法，我们可以通过为特定情况添加重载来进一步利用该功能。因此，例如，可以以String.IsNullOrEmpty的相同方式处理空字符串。在这种情况下，我会添加一个额外的扩展方法HasNullOrEmpty：

    public static bool HasNullOrEmpty(this IEnumerable<string> collection)
    {
        foreach (var item in collection)
        {
            if (string.IsNullOrEmpty(item))
            {
                return true;
            }
        }

        return false;
    }

虽然交易的类型必须是IEnumerable<string>

Answer 10

这是我的方式，被视为box和unbox对象。

尽管 ref 可以提高性能，但编码通过params很难看

用途：

void Bala(Guid? id, int? type){
    if (NullableChecker.AnyIsNull(id, type)){
        //Do your stuff
    }
}

该类可以使用T4或类似工具生成代码

internal static class NullableChecker
{
    public static bool AnyIsNull<T>(T? value) where T : struct
    {
        return false == value.HasValue;
    }

    public static bool AnyIsNull<T1, T2>(T1? value1, T2? value2) where T1 : struct where T2 : struct
    {
        return false == value1.HasValue || false == value2.HasValue;
    }

    public static bool AnyIsNull<T1, T2, T3>(T1? value1, T2? value2, T3? value3) where T1 : struct where T2 : struct where T3 : struct
    {
        return false == value1.HasValue || false == value2.HasValue || false == value3.HasValue;
    }

    public static bool AnyIsNull<T1, T2, T3, T4>(T1? value1, T2? value2, T3? value3, T4? value4) where T1 : struct where T2 : struct where T3 : struct where T4 : struct
    {
        return false == value1.HasValue || false == value2.HasValue || false == value3.HasValue || false == value4.HasValue;
    }
}

检查空变量

10 个答案: