C# 检查C中的对象是否为null#

如果对象为null，我希望阻止对其进行进一步处理

在以下代码中，我通过以下任一方法检查对象是否为null：

if (!data.Equals(null))

及

但是，我在

dataList.Add（data）

处收到一个

NullReferenceException

。如果对象为空，则它甚至不应该输入

If

-语句

因此，我要问的是，这是否是检查对象是否为null的正确方法：

public List<Object> dataList;
public  bool AddData(ref Object data)
    bool success = false;
    try
    {
        // I've also used "if (data != null)" which hasn't worked either
        if (!data.Equals(null))
        {
           //NullReferenceException occurs here ...
           dataList.Add(data);
           success = doOtherStuff(data);
        }
    }
    catch (Exception e)
    {
        throw new Exception(e.ToString());
    }
    return success;
}

公共列表数据列表；
公共bool AddData（参考对象数据）
布尔成功=假；
尝试
{
//我还使用了“if（data！=null）”，它也不起作用
如果（！data.Equals（null））
{
//此处发生NullReferenceException。。。
dataList.Add（数据）；
成功=doOtherStuff（数据）；
}
}
捕获（例外e）
{
抛出新异常（例如ToString（））；
}
回归成功；
}

---

如果这是检查对象是否为null的正确方法，那么我做错了什么（如何防止对对象进行进一步处理以避免NullReferenceException）？

根据您发布的代码判断，您的数据列表为null，因为它未被实例化

尝试：

public List dataList=new List（）；
公共bool AddData（参考对象数据）
布尔成功=假；
尝试
{
if（！data.Equals（null））//我还使用了if（data！=null），它也不起作用
{
dataList.Add（data）；//此处发生NullReferenceException
成功=doOtherStuff（数据）；
}
}
捕获（例外e）
{
抛出新异常（例如ToString（））；
}
回归成功；
}
不是
数据
为
空
，而是
数据列表

您需要创建一个具有

public List<Object> dataList = new List<Object>();

这绝对不好。我可以想象，你把它放在那里，这样你就可以在仍然在方法中的时候闯入调试器，在这种情况下，忽略这一段。否则，不要无缘无故捕获异常。如果你这样做了，就用
throw重新播放它们
这种情况下的问题不是
数据
为空。这是因为
dataList
本身为空

在声明
dataList
的地方，应该创建一个新的
List
对象并将其分配给变量

List<object> dataList = new List<object>();

List dataList=newlist（）；
不，您应该使用
=。如果
数据
实际上是空的，那么由于试图调用
null
上的
Equals
方法，程序将因
NullReferenceException
而崩溃。还要认识到，如果您特别想检查引用相等性，您应该使用
对象.ReferenceEquals
方法，因为您永远不知道
Equals
是如何实现的

您的程序正在崩溃，因为
dataList
为空，因为您从未初始化它。
Jeffrey L Whitledge是对的。您的`数据列表'-对象本身为空

代码还有另一个问题：您使用的是ref关键字，这意味着参数数据不能为null！MSDN说：

必须首先初始化传递给ref参数的参数。这与out不同，out的参数在传递之前不必显式初始化

将泛型与“Object”类型一起使用也不是一个好主意。泛型应避免装箱/拆箱，并确保类型安全。如果您想要一个公共类型，请将您的方法设置为泛型。最后，您的代码应该如下所示：

public class Foo<T> where T : MyTypeOrInterface {

      public List<T> dataList = new List<T>();

      public bool AddData(ref T data) {
        bool success = false;
        try {
          dataList.Add(data);                   
          success = doOtherStuff(data);
        } catch (Exception e) {
          throw new Exception(e.ToString());
        }
        return success;
      }

      private bool doOtherStuff(T data) {
        //...
      }
    }

公共类Foo其中T:MyTypeOrInterface{
public List dataList=新列表（）；
公共布尔添加数据（参考T数据）{
布尔成功=假；
试一试{
dataList.Add（数据）；
成功=doOtherStuff（数据）；
}捕获（例外e）{
抛出新异常（例如ToString（））；
}
回归成功；
}
私人bool doOtherStuff（T数据）{
//...
}
}
正如其他人已经指出的，不是
数据
，而是
数据列表
很可能是
null
。除此之外

catch
-
throw
是一种反模式，每次看到它时，几乎总是让我想呕吐。想象一下，
doOtherStuff（）
调用的东西在深处出错。返回的只是一个
异常
对象，在
AddData（）
中的
抛出
。没有堆栈跟踪，没有调用信息，没有状态，没有任何东西可以指示问题的真正根源，除非您进入并切换调试器以在抛出异常而不是未处理异常时中断。如果您正在捕获一个异常并以任何方式重新抛出它，特别是如果try块中的代码在任何方面都不重要，请帮您自己（以及您现在和将来的同事）一个忙，并抛出整个
try
-
catch
块。授予，
抛出
比其他方法更好，但您仍然给自己（或其他试图修复代码中错误的人）带来了完全不必要的麻烦。这并不是说try-catch-throw本身就一定是邪恶的，只要您对catch块中抛出的异常对象做一些相关的事情

首先，捕获
Exception
可能存在一些问题，但这是另一回事，特别是在这种情况下，您抛出了一个异常

另一件让我觉得有点危险的事情是，
数据
可能会在函数执行期间更改值，因为您是通过引用传递的。因此，空检查可能会通过，但在代码开始对值进行任何操作之前，它会被更改-可能会更改为
null
。我不确定这是否是一个问题（可能不是），但似乎不是
List<object> dataList = new List<object>();

public class Foo<T> where T : MyTypeOrInterface {

      public List<T> dataList = new List<T>();

      public bool AddData(ref T data) {
        bool success = false;
        try {
          dataList.Add(data);                   
          success = doOtherStuff(data);
        } catch (Exception e) {
          throw new Exception(e.ToString());
        }
        return success;
      }

      private bool doOtherStuff(T data) {
        //...
      }
    }

class Nully
{
    public static bool operator ==(Nully n, object o)
    {
        Console.WriteLine("Comparing '" + n + "' with '" + o + "'");
        return true;
    }
    public static bool operator !=(Nully n, object o) { return !(n==o); }
}
void Main()
{
    var data = new Nully();
    Console.WriteLine(null == data);
    Console.WriteLine(object.ReferenceEquals(null, data));
}

if (points != null) {
    var next = points.FirstOrDefault();
    if (next != null && next.X != null) return next.X;
}   
return -1;

var bestValue = points?.FirstOrDefault()?.X ?? -1;

  public static bool isnull(object T)
  {
      return T == null ? true : false;
  }

isnull(object.check.it)

isnull(object.check.it) ? DoWhenItsTrue : DoWhenItsFalse;

public static bool IsNull(object T)
{
    return (bool)T ? true : false;
}

 public static bool IsNull(this object T)
     {
        return T == null;
     } 

object foo = new object(); //or any object from any class
if (foo.IsNull())
   {
     // blah blah //
   }

void myFunction(object1)
{
  if(object1!=null)
  {
     object1.value1 //If we miss the null check then here we get the Null Reference exception
  }
}

var obj = new Object();
var objStr = obj.ToString();
if (!string.IsNullOrEmpty(objStr)){
  // code as per your needs
}

if (obj is { })
{
    // 'obj' is not null here
}


    if (MyObj is Object)
    {
            //Do something .... for example:  
            if (MyObj is Button)
                MyObj.Enabled = true;
    }


if (obj is null) { ... }

if (obj is not null) { ... }

if (name is null) { }

if (name is not null) { }

public List<Object> dataList;
public  bool AddData(ref Object data)
bool success = false;
try
{
    if (data != null)
    {
       dataList.Add(data);
       success = doOtherStuff(data);
    }
}
catch (Exception e)
{
    throw new Exception(e.ToString());
}
return success;

/// <summary>
/// Extensions to the object class
/// </summary>
public static class ObjectExtensions
{
    /// <summary>
    /// True if the object is null, else false
    /// </summary>
    public static bool IsNull(this object input) => input is null;

    /// <summary>
    /// False if the object is null, else true
    /// </summary>
    public static bool NotNull(this object input) => !IsNull(input);
}

        var foo = obj ?? "";

        if (!String.IsNullOrEmpty(foo.ToString()))
        {
          //Do something
        }

!String.IsNullOrWhitespace(obj?.ToString())

public bool IsVisible(object ClaimCount)
    {
        bool flag = true;
        #region || HIDE COLUMNS ON CONDITION BASIS
        if (!String.IsNullOrEmpty(Convert.ToString(ClaimCount)))
        {
            Int32 ClaimCnt = Convert.ToInt32(ClaimCount);
            if (ClaimCnt == 1)
            {
                flag = false;
            }
        }
        #endregion
        return flag;
    }