什么是NullReferenceException，我该如何修复？

Question

我有一些代码，当它执行时，它会引发nullReferenceException，说：

对象引用未设置为对象的实例。

这是什么意思，我该怎么办来解决此错误？

Answer 1

这意味着您的代码使用了一个设置为 null 的对象引用变量（即它没有引用实际的对象实例）。

为了防止该错误，可能为 null 的对象应在使用之前测试是否为 null。

if (myvar != null)
{
    // Go ahead and use myvar
    myvar.property = ...
}
else
{
    // Whoops! myvar is null and cannot be used without first
    // assigning it to an instance reference
    // Attempting to use myvar here will result in NullReferenceException
}

Answer 2

这意味着所讨论的变量没有指向任何内容。我可以这样生成：

SqlConnection connection = null;
connection.Open();

这会抛出错误，因为虽然我声明了变量“connection”，但它没有指向任何内容。当我尝试调用成员“Open”时，没有可供解析的引用，并且会抛出错误。

要避免此错误：

1. 在尝试对对象执行任何操作之前，请务必先初始化它们。
2. 如果您不确定对象是否为 null，请使用 object == null 进行检查。

JetBrains 的 ReSharper 工具将识别代码中可能存在空引用的每个位置错误，允许您进行空检查。恕我直言，这个错误是错误的第一大来源。

Answer 3

请注意，无论何种情况，.NET 中的原因始终相同：

您正在尝试使用值为 Nothing/null 的引用变量。当引用变量的值为 Nothing/null 时，这意味着它实际上并未持有对堆上存在的任何对象实例的引用。

您要么从未为该变量分配过任何内容，也从未创建过分配给该变量的值的实例，要么您手动将变量设置为 Nothing/null，或者您调用了一个函数，为您将变量设置为 Nothing/null。

Answer 4

抛出此例外的一个例子是：当您试图检查某些东西时，那是无效的。

例如：

string testString = null; //Because it doesn't have a value (i.e. it's null; "Length" cannot do what it needs to do)

if (testString.Length == 0) // Throws a nullreferenceexception
{
    //Do something
} 

当您尝试对未实例化的某些操作（即上述代码）执行操作时，.NET运行时将抛出NullReferenceException。

与一个参数努力相比，如果某种方法期望将其传递给它不是零，则通常将其作为防御措施进行。

更多信息在 c＃nullreferenceException和null parameter 。

Answer 5

更新C＃8.0，2019：无效参考类型

C＃8.0引入无效的参考类型和不可删除的参考类型。因此，仅必须检查可无效的参考类型，以避免 nullReferenceException 。

---

如果您尚未初始化参考类型，并且要设置或读取其属性之一，它将抛出 nullReferenceException 。

示例：

Person p = null;
p.Name = "Harry"; // NullReferenceException occurs here.

您可以通过检查变量是否没有零来避免这种情况：

Person p = null;
if (p!=null)
{
    p.Name = "Harry"; // Not going to run to this point
}

要完全理解为什么要抛出NullReferenceException，重要的是要了解值类型和[参考类型] [3]。

因此，如果您要处理价值类型，则NullReferenceExceptions可能不会发生 。尽管在处理参考类型时，您需要保持警惕！

只有名称建议的参考类型才能将参考文献或点字面上的内容（或“ null”）保存。而价值类型始终包含一个值。

参考类型（必须检查这些类型）：

• 动态
• 对象
• 字符串

值类型（您可以简单地忽略这些类型）：

• 数字类型
• 的积分类型浮点类型
• 浮点类型
• DECIMAL
• BOOL
• 用户定义结构

Answer 6

可能发生 NullReferenceExceptions 的另一种情况是（不正确）使用 as 运算符：

class Book {
    public string Name { get; set; }
}
class Car { }

Car mycar = new Car();
Book mybook = mycar as Book;   // Incompatible conversion --> mybook = null

Console.WriteLine(mybook.Name);   // NullReferenceException

这里，Book 和 Car 是不兼容的类型； 汽车无法转换/转换为书籍。当此转换失败时，as 返回null。此后使用 mybook 会导致 NullReferenceException。

一般来说，您应该使用强制转换或as，如下所示：

如果您期望类型转换始终成功（即您提前知道对象应该是什么），那么您应该使用强制转换：

ComicBook cb = (ComicBook)specificBook;

如果您不确定类型，但想要尝试将其用作特定类型，则使用as：

ComicBook cb = specificBook as ComicBook;
if (cb != null) {
   // ...
}

Answer 7

您正在使用包含空值引用的对象。所以它给出了一个空异常。在示例中，字符串值为 null，在检查其长度时发生异常。

示例：

string value = null;
if (value.Length == 0) // <-- Causes exception
{
    Console.WriteLine(value); // <-- Never reached
}

异常错误为：

未处理的异常：

System.NullReferenceException：未将对象引用设置到实例
一个物体的。在 Program.Main()

Answer 8

而什么导致NullReferenceExceptions 以及避免/修复此类异常的方法已在其他答案中得到解决，许多程序员尚未学会的是如何独立调试此类异常期间的例外情况 发展。

在 Visual Studio 中，借助 Visual Studio 调试器，这通常很容易。

---

首先，确保将捕获正确的错误 - 请参阅
如何允许在 VS2010 中中断“System.NullReferenceException”？ 注意¹< /em>

然后或者 开始调试 (F5 ) 或 将[VS 调试器]附加到正在运行的进程。有时使用 Debugger.Break，这将提示启动调试器。

现在，当抛出（或未处理）NullReferenceException 时，调试器将在发生异常的行上停止（还记得上面设置的规则吗？）。有时错误很容易被发现。

例如，
在下面的行中，可能导致异常的唯一代码是如果 myString 计算结果为 null。这可以通过查看观察窗口 或在 立即中运行表达式窗口。

var x = myString.Trim();

在更高级的情况下，例如以下情况，您需要使用上述技术之一（Watch 或 Immediate Windows）来检查表达式以确定 str1 是否为 null 或者 str2 为空。

var x = str1.Trim() + str2.Trim();

一旦定位了抛出异常的位置，通常很容易向后推理以找出[错误]引入空值的位置 -

花一些时间来了解异常的原因。检查空表达式。检查可能导致此类空表达式的先前表达式。添加断点 并根据需要逐步执行该程序。 使用调试器。

---

¹ 如果 Break on Throws 过于激进并且调试器在 .NET 或第 3 方库中的 NPE 上停止，Break on User-Unhandled 可用于限制捕获的异常。此外，VS2012 引入了Just My Code，我也建议启用它。

如果您在启用“仅我的代码”的情况下进行调试，则行为会略有不同。启用“仅我的代码”后，调试器会忽略在“我的代码”之外引发且不通过“我的代码”的首次公共语言运行时 (CLR) 异常

Answer 9

Simon Mourier给了这个示例：

object o = null;
DateTime d = (DateTime)o;  // NullReferenceException

其中 unboxing 转换（铸造（铸造） ）来自 object（或从类别之一system.valuetype或system.enum，或从接口type） to 一个值类型（nullable＆lt;＆gt;）本身给出了nullReferenceException。

在另一个方向上，来自 a a nullable＆lt;＆gt;＆gt;的 拳击 转换代码>等于false to 参考类型，可以给出null参考，然后可以稍后引入NullReferenceException。经典的例子是：

DateTime? d = null;
var s = d.ToString();  // OK, no exception (no boxing), returns ""
var t = d.GetType();   // Bang! d is boxed, NullReferenceException

有时拳击会以另一种方式发生。例如，使用此非传播扩展方法：

public static void MyExtension(this object x)
{
  x.ToString();
}

以下代码将是有问题的：

DateTime? d = null;
d.MyExtension();  // Leads to boxing, NullReferenceException occurs inside the body of the called method, not here.

这些情况是由于运行时在拳击nullable时使用的特殊规则而出现的。

Answer 10

当实体框架中使用的实体的类名称与Web表单代码范围文件的类名称相同时，添加一个案例。

假设您有一个Web表单Contact.ASPX，其CodeBehind类是联系人，并且您具有实体名称联系人。

请在调用Context.SaveChanges（）时，以下代码将丢弃NullReferenceException

Contact contact = new Contact { Name = "Abhinav"};
var context = new DataContext();
context.Contacts.Add(contact);
context.SaveChanges(); // NullReferenceException at this line

然后，为了完整的dataContext类

public class DataContext : DbContext 
{
    public DbSet<Contact> Contacts {get; set;}
}

和联系人实体类， 。有时，实体类是部分类，因此您也可以在其他文件中扩展它们。

public partial class Contact 
{
    public string Name {get; set;}
}

当实体和CodeBehind类处于同一名称空间时，发生错误。
要解决此问题，请重命名实体类或CodeBehind类以供contact.aspx。

原因
我仍然不确定原因。但是，每当任何实体类都扩展system.web.ui.page时，此错误就会发生。

为了讨论，请查看 nullReReference exception in dbcontext.savechanges（）

Answer 11

另一种可能收到此异常的常见情况涉及在单元测试期间模拟类。无论使用哪种模拟框架，您都必须确保正确模拟类层次结构的所有适当级别。特别是，被测试代码引用的 HttpContext 的所有属性都必须被模拟。

请参阅“测试自定义 AuthorizationAttribute 时抛出 NullReferenceException”以获得稍微详细的示例。

Answer 12

我对这个问题有不同的看法。这种答案“我还能做什么来避免它？”

当跨不同层工作时，例如在 MVC 应用程序中，控制器需要服务来调用业务操作。在这种情况下，可以使用依赖注入容器来初始化服务以避免NullReferenceException。因此，这意味着您无需担心检查 null，只需从控制器调用服务，就好像它们始终作为单例或原型可用（并初始化）一样。

public class MyController
{
    private ServiceA serviceA;
    private ServiceB serviceB;

    public MyController(ServiceA serviceA, ServiceB serviceB)
    {
        this.serviceA = serviceA;
        this.serviceB = serviceB;
    }

    public void MyMethod()
    {
        // We don't need to check null because the dependency injection container 
        // injects it, provided you took care of bootstrapping it.
        var someObject = serviceA.DoThis();
    }
}

Answer 13

关于“我该怎么办”这个问题，可以有很多答案。

在开发时防止此类错误情况的一种更“正式”的方法是应用在代码中按契约设计。这意味着您需要在开发时在系统上设置类不变量，和/或什至函数/方法前置条件和后置条件。

简而言之，类不变量确保您的类中存在一些在正常使用中不会被违反的约束（因此，该类不会处于不一致的状态）。 先决条件意味着作为函数/方法的输入给出的数据必须遵循一些约束集并且决不违反它们，而后置条件意味着函数/方法输出必须再次遵循设定的约束，而不能违反它们。
在执行无错误程序期间绝不违反合同条件，因此在调试模式下实际上会检查合同设计，同时在发布中禁用，以最大限度地提高开发的系统性能。

这样，您可以避免因违反约束集而导致的 NullReferenceException 情况。例如，如果您在类中使用对象属性 X，然后尝试调用其方法之一，而 X 具有 null 值，则这将导致 NullReferenceException：

public X { get; set; }

public void InvokeX()
{
    X.DoSomething(); // if X value is null, you will get a NullReferenceException
}

但是，如果您将“属性 X 绝不能有空值”设置为方法前提条件，那么您可以防止前面描述的情况：

//Using code contracts:
[ContractInvariantMethod]
protected void ObjectInvariant() 
{
    Contract.Invariant(X != null);
    //...
}

因此，代码合同项目存在对于.NET应用程序。

或者，可以使用断言来应用按合同设计。

更新：值得一提的是，该术语是由 Bertrand Meyer 创造的 与他设计的 Eiffel 编程语言有关。

Answer 14

当我们尝试访问空对象的属性时，或者当字符串值变为空并且我们尝试访问字符串方法时，会抛出 NullReferenceException 。

例如：

1. 当访问空字符串的字符串方法时：

   字符串 str = string.Empty;
   str.ToLower(); // 抛出空引用异常
   

2. 当访问空对象的属性时：

   公共类人 {
       公共字符串名称{获取;放; }
   }
   人 objPerson;
   objPerson.Name /// 抛出空引用异常 
   

Answer 15

TL;DR：尝试使用Html.Partial而不是Renderpage

---

我得到对象引用未设置到对象的实例< /code> 当我尝试通过向视图发送模型来渲染视图中的视图时，如下所示：

@{
    MyEntity M = new MyEntity();
}
@RenderPage("_MyOtherView.cshtml", M); // error in _MyOtherView, the Model was Null

调试显示模型在 MyOtherView 中为 Null。直到我将其更改为：

@{
    MyEntity M = new MyEntity();
}
@Html.Partial("_MyOtherView.cshtml", M);

并且它起作用了。

此外，我一开始就没有 Html.Partial 的原因是 Visual Studio 有时 在 Html.Partial 下抛出看起来错误的波浪线> 如果它位于不同构造的 foreach 循环内，即使它并不是真正的错误：

@inherits System.Web.Mvc.WebViewPage
@{
    ViewBag.Title = "Entity Index";
    List<MyEntity> MyEntities = new List<MyEntity>();
    MyEntities.Add(new MyEntity());
    MyEntities.Add(new MyEntity());
    MyEntities.Add(new MyEntity());
}
<div>
    @{
        foreach(var M in MyEntities)
        {
            // Squiggly lines below. Hovering says: cannot convert method group 'partial' to non-delegate type Object, did you intend to envoke the Method?
            @Html.Partial("MyOtherView.cshtml");
        }
    }
</div>

但我能够运行该应用程序，而不会出现此“错误”的问题。我能够通过将 foreach 循环的结构更改为如下所示来消除该错误：

@foreach(var M in MyEntities){
    ...
}

虽然我有一种感觉，这是因为 Visual Studio 误读了 & 符号和括号。

Answer 16

您该怎么办？

这里有很多好的答案，解释了什么是无效的引用以及如何调试它。但是，如何防止问题或至少使捕获更容易。

检查参数

例如，方法可以检查不同的参数，以查看它们是否为null并投掷gongementnullexception，显然是出于此确切目的而创建的例外。

参数Nullexception的构造函数甚至以参数的名称和消息作为参数，因此您可以确切地告诉开发人员问题是什么。

public void DoSomething(MyObject obj) {
    if(obj == null) 
    {
        throw new ArgumentNullException("obj", "Need a reference to obj.");
    }
}

使用工具

也有几个库可以提供帮助。例如，“ Resharper”可以在编写代码时为您提供警告，尤其是如果您使用其属性： notnullattribute

有“ Microsoft Code Contracts”，您使用语法，例如Contract.requires.requires（obj！= null），可以为您提供运行时和编译时间：介绍代码合同。

还有“ PostSharp”，它将允许您仅使用类似的属性：

public void DoSometing([NotNull] obj)

通过这样做并将后期换成构建过程的一部分obj将在运行时检查NULL的null。请参阅： noreferrer“

普通代码解决方案

，也可以使用普通的旧代码来编码自己的方法。例如，这里是一个结构，您可以使用该结构来获取零引用。它以与Nullable＆lt; t＆gt;相同的概念进行建模：

[System.Diagnostics.DebuggerNonUserCode]
public struct NotNull<T> where T: class
{
    private T _value;

    public T Value
    {
        get
        {
            if (_value == null)
            {
                throw new Exception("null value not allowed");
            }

            return _value;
        }
        set
        {
            if (value == null)
            {
                throw new Exception("null value not allowed.");
            }

            _value = value;
        }
    }

    public static implicit operator T(NotNull<T> notNullValue)
    {
        return notNullValue.Value;
    }

    public static implicit operator NotNull<T>(T value)
    {
        return new NotNull<T> { Value = value };
    }
}

您将使用与使用nullable＆lt; t＆gt;相同的方式使用的方式，但目的是确切地完成。相反 - 不允许null。以下是一些示例：

NotNull<Person> person = null; // throws exception
NotNull<Person> person = new Person(); // OK
NotNull<Person> person = GetPerson(); // throws exception if GetPerson() returns null

notnull＆lt; t＆gt;被隐式地投入到t中，因此您几乎可以在任何需要的地方使用它。例如，您可以将person对象传递到采用notnull＆lt; person＆gt;的方法：

Person person = new Person { Name = "John" };
WriteName(person);

public static void WriteName(NotNull<Person> person)
{
    Console.WriteLine(person.Value.Name);
}

如上所述，您可以通过无效的方式访问基础值value属性。另外，您可以使用明确或隐式铸件，您可以在下面看到一个示例：

Person person = GetPerson();

public static NotNull<Person> GetPerson()
{
    return new Person { Name = "John" };
}

或者，当方法刚刚返回t（在这种情况下，您甚至可以使用它） /code>）通过演员表。例如，以下代码与上述代码相似：

Person person = (NotNull<Person>)GetPerson();

public static Person GetPerson()
{
    return new Person { Name = "John" };
}

与扩展名相结合

combine notnull＆lt; t＆gt;使用扩展方法，您可以涵盖更多情况。以下是扩展方法的外观示例：

[System.Diagnostics.DebuggerNonUserCode]
public static class NotNullExtension
{
    public static T NotNull<T>(this T @this) where T: class
    {
        if (@this == null)
        {
            throw new Exception("null value not allowed");
        }

        return @this;
    }
}

这是一个可以使用的示例：

var person = GetPerson().NotNull();

github

用于您的参考，我在GitHub上提供了上面的代码，您可以在：

https://github.com/luisperezphd/notnull

相关语言功能

c＃6.0操作员“对此有所帮助。使用此功能，您可以引用嵌套对象，如果其中任何一个是null整个表达式返回null。

这减少了您在某些情况下必须进行的空检查数量。语法是要在每个点之前放一个问号。以以下代码为例：

var address = country?.State?.County?.City;

想象一下country是类型country具有称为state的属性的对象。如果country，状态，县，或code> city is null然后地址将为 null 。因此，您只需要检查地址是否 null`。

这是一个很棒的功能，但它为您提供了更少的信息。这并不明显4个为null。

内置像无效的？

c＃有一个不错的速记，适用于nullable＆lt; t＆gt;，您可以通过在类型之后放置一个so int so int的问号来使某些内容无效？。

如果c＃有notnull＆lt; t＆gt; struct上面并且具有类似的速记，也许是感叹号（！），这样您就可以写出类似的内容，这样您就可以写下类似的内容：public> public void writename，那将是很好的。 （人！人）。

Answer 17

您可以使用c＃6中的无条件运算符以干净的方式修复NullReferenceException，并编写较少的代码来处理无效检查。

它用于在执行成员访问（？）或索引（？[）操作之前测试NULL。

示例

  var name = p?.Spouse?.FirstName;

等于：

    if (p != null)
    {
        if (p.Spouse != null)
        {
            name = p.Spouse.FirstName;
        }
    }

结果是，当p为null或p.p.spouse为null时，名称将为null。

否则，将分配变量名称p.spouse.firstname的值。

对于更多详细信息： null条件运算符

Answer 18

有趣的是，本页上的所有答案都没有提到这两种边缘情况：

边缘情况 #1：并发访问字典

.NET 中的通用字典不是线程安全的，它们有时可能会抛出NullReference 甚至（更常见）出现 KeyNotFoundException。在这种情况下，异常是相当具有误导性的。

边缘情况 #2：不安全代码

如果 unsafe 代码引发 NullReferenceException，您可能会查看指针变量，并检查它们是否有 IntPtr.Zero代码>或其他东西。这是同样的事情（“空指针异常”），但是在不安全的代码中，变量通常会被转换为值类型/数组等，并且你会用头撞墙，想知道值类型如何抛出这个异常例外。

（顺便说一句，除非您需要，否则不使用不安全代码的另一个原因。）

边缘情况 #3：Visual Studio 多显示器设置与辅助显示器的 DPI 设置与主显示器不同

这种边缘情况是软件 -具体并属于 Visual Studio 2019 IDE（可能还有早期版本）。

重现该问题的方法：将工具箱中的任何组件拖动到具有与主显示器不同的 DPI 设置的非主显示器上的 Windows 窗体，然后您会收到一个弹出窗口，其中显示“对象引用未设置为目的。”根据 这个线程，这个问题已经存在很长一段时间了，在撰写本文时它仍然没有得到解决。

Answer 19

错误行“未设置为对象的实例”。指出您尚未将实例对象分配给对象引用，并且您仍在访问该对象的属性/方法。

例如：假设您有一个名为MyClass的课程，它包含一个属性， prop1 。

public Class myClass
{
   public int prop1 {get;set;}
}

现在，您正在其他某些类中访问此Prop1，就像以下类似：

public class Demo
{
     public void testMethod()
     {
        myClass ref = null;
        ref.prop1 = 1;  // This line throws an error
     }
}

上面的行引发了错误，因为声明了类myClass的引用，但未实例化或对象实例未分配给该类的参考。

要解决此问题，您必须实例化（将对象分配给该类的引用）。

public class Demo
{
     public void testMethod()
     {
        myClass ref = null;
        ref = new myClass();
        ref.prop1 = 1;
     }
}

Answer 20

简单来说：

您正在尝试访问未创建或当前不在内存中的对象。

那么如何解决这个问题：

1. 调试并让调试器中断...它会直接将您带到损坏的变量...现在您的任务是简单地修复这个问题..使用new

2. 如果它是由某些数据库命令引起的，因为对象不存在，那么您需要做的就是进行空检查并处理它：

   if (i == null) {
       // 处理这个
   }
   

3. 最难的一个..如果GC已经收集了对象...这通常发生在以下情况：你正试图使用​​字符串来查找一个对象...也就是说，通过对象的名称来查找它，那么GC可能已经清理了它...这很难找到，并且会成为一个很大的问题..解决这个问题的更好方法是在开发过程中根据需要进行空检查。这将为您节省大量时间。

按名称查找是指某些框架允许您使用字符串查找对象，代码可能如下所示： FindObject("ObjectName");

Answer 21

当您尝试使用的类的对象未实例化时，NullReferenceException或对象引用未设置为对象的实例。
例如：

假设您有一个名为Student的课程。

public class Student
{
    private string FirstName;
    private string LastName;
    public string GetFullName()
    {
        return FirstName + LastName;
    }
}

现在，考虑一下您试图检索学生全名的另一堂课。

public class StudentInfo
{      
    public string GetStudentName()
    {
        Student s;
        string fullname = s.GetFullName();
        return fullname;
    }        
}

如以上代码所示，该语句
学生S - 仅声明学生类型的变量，请注意，此时尚未实例化学生班。
因此，当语句 s.getfullname（）被执行时，它将抛出NullReferenceException。

Answer 22

从字面上看，修复nullReferenceExeption的最简单方法有两种方式。

如果您有一个gameObject，例如带有脚本的脚本和一个名为 rb （刚体）的变量，则该变量将在您启动游戏时以null开头。
这就是为什么您获得NullReferenceExeption的原因，因为计算机没有存储在该变量中的数据。

我将以一个刚性变量为例。
实际上，我们可以通过几种方式可以很容易地添加数据：

1. 使用AddComponent＆gt;向对象添加一个刚性体。物理＆GT;僵化的身体
   然后进入您的脚本并键入rb = getComponent＆lt; strigbody＆gt;（）;
   这一行代码在您的start（）或awake（）函数下工作。
2. 您可以以编程方式添加组件，并同时使用一行代码分配变量：rb = addComponent＆lt; strig＆gt;（）;

进一步注释：如果您想要 unity 要在对象中添加一个组件，您可能已经忘记了一个，您可以键入一个[sirceseComponent （typeof（arigidbody））]在您的类声明上方（使用 s的所有下方的空间）。

享受并玩得开心！

Answer 23

这基本上是一个零参考异常。 AS microsoft> Microsoft

尝试访问一个NullReference Exception异常
值为null的类型的成员。

这意味着什么？

这意味着，如果任何不具有任何价值的成员，我们正在使该成员执行某些任务，那么该系统无疑会扔出消息，然后说 -

“嘿，等等，该成员没有值，因此无法 的任务。

执行您要交出 因此，这表示仅在使用参考类型作为值类型时才发生。

如果我们使用Value类型成员，则不会发生NullReferenceException。

class Program
{
    static void Main(string[] args)
    {
        string str = null;
        Console.WriteLine(str.Length);
        Console.ReadLine();
    }
}

上面的代码显示了用 null 值分配的简单字符串。

现在，当我尝试打印字符串的长度 str 时，我确实会出现 'system.nullReferenceException'的类型消息，因为成员 str 消息/strong>指向零，没有任何时间的空。

' nullReferenceException '当我们忘记实例化参考类型时，也会发生。

假设我有一个类和成员方法。我没有实例化我的班级，但只命名了我的班级。现在，如果我尝试使用该方法，编译器将发出错误或发出警告（取决于编译器）。

class Program
{
    static void Main(string[] args)
    {
        MyClass1 obj;
        obj.foo();  // Use of unassigned local variable 'obj'
    }
}

public class MyClass1
{
    internal void foo()
    {
        Console.WriteLine("Hello from foo");
    }
}

上述代码的编译器提出了一个错误，即变量 obj 未分配，这表明我们的变量具有零值或没有。上述代码的编译器提出了一个错误，即变量 obj 未分配，这表明我们的变量具有零值或没有。

为什么发生？

• nullReferenceException由于我们没有检查对象的值而出现了。我们经常将对象值放在代码开发中未选中。

• 当我们忘记实例化对象时，它也会出现。使用方法，属性，集合等可以返回或设置为空值的方法也可能是此例外的原因。

如何避免它？

有多种避免此著名例外的方法和方法：

1. 明确检查：我们应该遵守检查对象，属性，方法，阵列和集合的传统，无论它们是否为无效。可以简单地使用条件语句（例如if-else if-else等）实现。

   。

2. 异常处理：管理此例外的重要方法之一）来实现这一点。使用简单的尝试键入块，我们可以控制此异常并保持其日志。当您的应用程序处于生产阶段时，这可能非常有用。

3. null运算符：无效的合并操作员和无条件操作员也可以用方便地使用，同时将值设置为对象，变量，属性和字段。

4. 调试器：对于开发人员来说，我们拥有与我们一起调试的重要武器。如果我们在开发面前面对NullReferenceException，我们可以使用调试器来达到例外的来源。

5. 内置方法：诸如getValueordEfault（），isnullorWhitespace（）和isnullorement（）检查nulls的系统方法，如果有空值。

   ，请分配默认值。

这里已经有很多好的答案。您还可以在我的博客。

希望这也有帮助！

Answer 24

原因是什么？

底线

您正在尝试使用 null（或 VB.NET 中的 Nothing）的内容。这意味着您要么将其设置为 null，要么根本不将其设置为任何内容。

与其他任何东西一样，null 也会被传递。如果方法“A”中的值为 null ，则可能是方法“B”将 null 传递给了方法“A”。

null 可以有不同的含义：

1. 未初始化的对象变量，因此指向任何内容。在这种情况下，如果您访问此类对象的成员，它会导致 NullReferenceException。
2. 开发人员有意使用null来表示没有可用的有意义的值。请注意，C# 具有变量可为空数据类型的概念（例如数据库表可以具有可为空字段） -您可以将 null 分配给它们以指示其中没有存储任何值，例如 int? a = null;（这是 Nullablea = null; 的快捷方式），其中问号表示允许在变量中存储 null 一个。您可以使用 if (a.HasValue) {...} 或 if (a==null) {...} 进行检查。可空变量（如本示例中的 a）允许通过 a.Value 显式访问值，或者像平常一样通过 a 访问值。
   注意，如果，通过a.Value访问它会抛出InvalidOperationException而不是NullReferenceException a 是 null - 您应该事先进行检查，即如果您有另一个不可为 null 的变量 int b; 那么您应该进行像 这样的赋值if (a.HasValue) { b = a.值; } 或更短的 if (a != null) { b = a; }。

本文的其余部分将更详细地介绍许多程序员经常犯的错误，这些错误可能会导致 NullReferenceException。

更具体地说，

runtime 抛出 NullReferenceException always 意味着同样的事情：您正在尝试使用引用，并且该引用未初始化（或者它曾经初始化过，但不再初始化）。

这意味着该引用为 null，并且您无法通过 null 引用访问成员（例如方法）。最简单的情况：

string foo = null;
foo.ToUpper();

这将在第二行抛出 NullReferenceException，因为您无法在 string 引用上调用实例方法 ToUpper()指向null。

调试

如何找到 NullReferenceException 的来源？除了查看异常本身（异常将在异常发生的位置准确抛出）之外，Visual Studio 中的调试一般规则也适用：放置策略断点和 检查变量，方法是将鼠标悬停在变量名称上，打开（快速）监视窗口或使用各种调试面板，例如 Locals 和汽车。

如果您想找出引用的设置位置或未设置位置，请右键单击其名称并选择“查找所有引用”。然后，您可以在每个找到的位置放置一个断点，并使用附加的调试器运行程序。每次调试器在此类断点处中断时，您都需要确定是否希望引用为非空，检查变量，并验证它是否在您希望时指向实例。

通过这种方式遵循程序流程，您可以找到实例不应该为空的位置，以及为什么没有正确设置它。

示例

一些可能引发异常的常见场景：

通用

ref1.ref2.ref3.member

如果 ref1 或 ref2 或 ref3 为 null，那么您将收到 NullReferenceException。如果您想解决该问题，请通过将表达式重写为其更简单的等效项来找出哪个为 null：

var r1 = ref1;
var r2 = r1.ref2;
var r3 = r2.ref3;
r3.member

具体来说，在 HttpContext.Current.User.Identity.Name 中，HttpContext. Current 可以为 null，或者 User 属性可以为 null，或者 Identity 属性可以为 null。

间接

public class Person 
{
    public int Age { get; set; }
}
public class Book 
{
    public Person Author { get; set; }
}
public class Example 
{
    public void Foo() 
    {
        Book b1 = new Book();
        int authorAge = b1.Author.Age; // You never initialized the Author property.
                                       // There is no Person to get an Age from.
    }
}

如果您想避免子（Person）空引用，您可以在父（Book）对象的构造函数中初始化它。

嵌套对象初始值设定项

同样适用于嵌套对象初始值设定项：

Book b1 = new Book 
{ 
   Author = { Age = 45 } 
};

这意味着：

Book b1 = new Book();
b1.Author.Age = 45;

使用 new 关键字时，它仅创建 Book 的新实例，而不是新实例Person，因此 Author 属性仍为 null。

嵌套集合初始值设定

public class Person 
{
    public ICollection<Book> Books { get; set; }
}
public class Book 
{
    public string Title { get; set; }
}

项 嵌套集合 Initializers 的行为相同：

Person p1 = new Person 
{
    Books = {
         new Book { Title = "Title1" },
         new Book { Title = "Title2" },
    }
};

这意味着：

Person p1 = new Person();
p1.Books.Add(new Book { Title = "Title1" });
p1.Books.Add(new Book { Title = "Title2" });

new Person 仅创建 Person 的实例，但 >Books 集合仍为 null。集合 Initializer 语法不会创建集合
对于 p1.Books，它仅转换为 p1.Books.Add(...) 语句。

数组

int[] numbers = null;
int n = numbers[0]; // numbers is null. There is no array to index.

数组元素

Person[] people = new Person[5];
people[0].Age = 20 // people[0] is null. The array was allocated but not
                   // initialized. There is no Person to set the Age for.

交错数组

long[][] array = new long[1][];
array[0][0] = 3; // is null because only the first dimension is yet initialized.
                 // Use array[0] = new long[2]; first.

集合/列表/字典

Dictionary<string, int> agesForNames = null;
int age = agesForNames["Bob"]; // agesForNames is null.
                               // There is no Dictionary to perform the lookup.

范围 变量（间接/延迟）

public class Person 
{
    public string Name { get; set; }
}
var people = new List<Person>();
people.Add(null);
var names = from p in people select p.Name;
string firstName = names.First(); // Exception is thrown here, but actually occurs
                                  // on the line above.  "p" is null because the
                                  // first element we added to the list is null.

事件 (C#)

public class Demo
{
    public event EventHandler StateChanged;
    
    protected virtual void OnStateChanged(EventArgs e)
    {        
        StateChanged(this, e); // Exception is thrown here 
                               // if no event handlers have been attached
                               // to StateChanged event
    }
}

（注意：VB.NET 编译器插入对事件使用情况的空检查，因此无需检查事件是否无任何内容 code> 在 VB.NET 中。）

错误的命名约定：

如果您对字段的命名与本地字段的命名不同，您可能会意识到您从未初始化过该字段。

public class Form1
{
    private Customer customer;
    
    private void Form1_Load(object sender, EventArgs e) 
    {
        Customer customer = new Customer();
        customer.Name = "John";
    }
    
    private void Button_Click(object sender, EventArgs e)
    {
        MessageBox.Show(customer.Name);
    }
}

这可以通过遵循以下划线前缀字段的约定来解决：

    private Customer _customer;

ASP.NET 页面生命周期：

public partial class Issues_Edit : System.Web.UI.Page
{
    protected TestIssue myIssue;

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
             // Only called on first load, not when button clicked
             myIssue = new TestIssue(); 
        }
    }
        
    protected void SaveButton_Click(object sender, EventArgs e)
    {
        myIssue.Entry = "NullReferenceException here!";
    }
}

ASP.NET 会话值

// if the "FirstName" session value has not yet been set,
// then this line will throw a NullReferenceException
string firstName = Session["FirstName"].ToString();

ASP.NET MVC 空视图模型

如果引用 @ModelASP.NET MVC View 中，您需要了解当您返回视图时，Model 会在您的操作方法中设置。当您从控制器返回空模型（或模型属性）时，视图访问它时会发生异常：

// Controller
public class Restaurant:Controller
{
    public ActionResult Search()
    {
        return View();  // Forgot the provide a Model here.
    }
}

// Razor view 
@foreach (var restaurantSearch in Model.RestaurantSearch)  // Throws.
{
}
    
<p>@Model.somePropertyName</p> <!-- Also throws -->

WPF 控件创建顺序和事件

WPF 控件在调用 InitializeComponent< 期间创建/code> 按照它们在可视化树中出现的顺序。如果早期创建的控件具有事件处理程序等，并且在引用后期创建的控件的 InitializeComponent 期间触发，则会引发 NullReferenceException。

例如：

<Grid>
    <!-- Combobox declared first -->
    <ComboBox Name="comboBox1" 
              Margin="10"
              SelectedIndex="0" 
              SelectionChanged="comboBox1_SelectionChanged">
       <ComboBoxItem Content="Item 1" />
       <ComboBoxItem Content="Item 2" />
       <ComboBoxItem Content="Item 3" />
    </ComboBox>
        
    <!-- Label declared later -->
    <Label Name="label1" 
           Content="Label"
           Margin="10" />
</Grid>

这里comboBox1是在label1之前创建的。如果 comboBox1_SelectionChanged 尝试引用 label1，则它尚未创建。

private void comboBox1_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    label1.Content = comboBox1.SelectedIndex.ToString(); // NullReferenceException here!!
}

更改 XAML 中声明的顺序（即，在 comboBox1 之前列出 label1，忽略设计理念问题）至少可以解决 <代码>NullReferenceException在这里。

使用 as 进行强制转换

var myThing = someObject as Thing;

这不会引发 InvalidCastException，但在强制转换失败时（以及当 someObject 时）返回 null本身为空）。所以要注意这一点。

LINQ FirstOrDefault() 和 SingleOrDefault()

普通版本 First() 和 Single() 会在出现异常时抛出异常没什么。在这种情况下，“OrDefault”版本返回 null。所以要注意这一点。

foreach

当您尝试迭代 null 集合时， foreach 会抛出异常。通常是由返回集合的方法产生意外的 null 结果引起的。

List<int> list = null;    
foreach(var v in list) { } // NullReferenceException here

更实际的示例 - 从 XML 文档中选择节点。如果未找到节点但初始调试显示所有属性均有效，则会抛出异常：

foreach (var node in myData.MyXml.DocumentNode.SelectNodes("//Data"))

---

的方法

避免显式检查 null 并忽略 null 值

。如果您预计引用有时为 null，则可以在访问实例成员之前检查它是否为 null：

void PrintName(Person p)
{
    if (p != null) 
    {
        Console.WriteLine(p.Name);
    }
}

显式检查 null 并提供默认值。

您调用的期望实例的方法可能会返回 null，例如，当无法找到正在查找的对象时。在这种情况下，您可以选择返回默认值：

string GetCategory(Book b) 
{
    if (b == null)
        return "Unknown";
    return b.Category;
}

从方法调用中显式检查 null 并引发自定义异常。

您还可以抛出自定义异常，仅在调用代码中捕获它：

string GetCategory(string bookTitle) 
{
    var book = library.FindBook(bookTitle);  // This may return null
    if (book == null)
        throw new BookNotFoundException(bookTitle);  // Your custom exception
    return book.Category;
}

如果值永远不应该为 null，请使用 Debug.Assert，以便在出现问题之前捕获问题。发生异常。

如果您在开发过程中知道某个方法可以但永远不应该返回 null，则可以使用 Debug.Assert() 在它确实发生时尽快中断

string GetTitle(int knownBookID) 
{
    // You know this should never return null.
    var book = library.GetBook(knownBookID);  

    // Exception will occur on the next line instead of at the end of this method.
    Debug.Assert(book != null, "Library didn't return a book for known book ID.");

    // Some other code

    return book.Title; // Will never throw NullReferenceException in Debug mode.
}

：此检查不会最终出现在您的发布版本中，导致它抛出在发布模式下运行时，当 book == null 时再次出现 NullReferenceException 。

对可为 null 值类型使用 GetValueOrDefault()，以便在它们为 null 时提供默认值。

DateTime? appointment = null;
Console.WriteLine(appointment.GetValueOrDefault(DateTime.Now));
// Will display the default value provided (DateTime.Now), because appointment is null.

appointment = new DateTime(2022, 10, 20);
Console.WriteLine(appointment.GetValueOrDefault(DateTime.Now));
// Will display the appointment date, not the default

使用空合并运算符：?? [C#] 或 If() [VB]。

遇到 null 时提供默认值的简写：

IService CreateService(ILogger log, Int32? frobPowerLevel)
{
   var serviceImpl = new MyService(log ?? NullLog.Instance);
 
   // Note that the above "GetValueOrDefault()" can also be rewritten to use
   // the coalesce operator:
   serviceImpl.FrobPowerLevel = frobPowerLevel ?? 5;
}

对数组使用 null 条件运算符：?. 或 ?[x] (在 C# 6 和 VB.NET 14 中可用）：

有时也称为安全导航或 Elvis（以其形状命名）运算符。如果运算符左侧的表达式为 null，则不会计算右侧，而是返回 null。这意味着像这样的情况：

var title = person.Title.ToUpper();

如果此人没有头衔，则会抛出异常，因为它试图对具有 null 值的属性调用 ToUpper。

在 C# 5 及以下版本中，可以通过以下方式进行保护：

var title = person.Title == null ? null : person.Title.ToUpper();

现在 title 变量将为 null，而不是引发异常。 C# 6 为此引入了更短的语法：

var title = person.Title?.ToUpper();

这将导致 title 变量为 null，并且如果 person.Title 则不会调用 ToUpper code> 为 null。

当然，您仍然必须检查 title 是否为 null 或将 null 条件运算符与 null 合并运算符一起使用 (??）来提供默认值：

// regular null check
int titleLength = 0;
if (title != null)
    titleLength = title.Length; // If title is null, this would throw NullReferenceException
    
// combining the `?` and the `??` operator
int titleLength = title?.Length ?? 0;

同样，对于数组，您可以使用 ?[i]，如下所示：

int[] myIntArray = null;
var i = 5;
int? elem = myIntArray?[i];
if (!elem.HasValue) Console.WriteLine("No value");

这将执行以下操作：如果 myIntArray 是 null，表达式返回 null 并且您可以安全地检查它。如果它包含一个数组，它将执行以下操作：
elem = myIntArray[i]; 并返回第 i^th 元素。

使用 null 上下文（在 C# 8 中可用）：

在 C# 8 中引入，null 上下文和可为 null 的引用类型对变量执行静态分析，并在值可能为 null时提供编译器警告code> 或已设置为 null。可空引用类型允许显式允许类型为null。

可以使用 csproj 文件中的 Nullable 元素为项目设置可为空注释上下文和可为空警告上下文。此元素配置编译器如何解释类​​型的可为空性以及生成哪些警告。有效设置为：

• enable：启用可为空注释上下文。可以为空的警告上下文已启用。引用类型（例如字符串）的变量是不可为 null 的。所有可空性警告均已启用。
• disable：可空注释上下文被禁用。可为空的警告上下文已禁用。引用类型的变量是不可见的，就像 C# 的早期版本一样。所有可空性警告均被禁用。
• safeonly：启用可空注释上下文。可为空的警告上下文是安全的。引用类型的变量不可为空。所有安全可空性警告均已启用。
• 警告：可空注释上下文已禁用。可以为空的警告上下文已启用。引用类型的变量是不可见的。所有可空性警告均已启用。
• safeonlywarnings：可空注释上下文已禁用。可为空的警告上下文是安全的。
  引用类型的变量是不可见的。所有安全可空性警告均已启用。

可空引用类型使用与可为空值类型相同的语法进行标记：将 ? 附加到变量的类型。

用于调试和修复迭代器中空解引用的特殊技术

C# 支持“迭代器块”（在其他一些流行语言中称为“生成器”）。由于延迟执行，NullReferenceException 在迭代器块中调试可能特别棘手：

public IEnumerable<Frob> GetFrobs(FrobFactory f, int count)
{
    for (int i = 0; i < count; ++i)
    yield return f.MakeFrob();
}
...
FrobFactory factory = whatever;
IEnumerable<Frobs> frobs = GetFrobs();
...
foreach(Frob frob in frobs) { ... }

如果 whatever 结果为 null，则 MakeFrob会抛出。现在，您可能认为正确的做法是：

// DON'T DO THIS
public IEnumerable<Frob> GetFrobs(FrobFactory f, int count)
{
   if (f == null) 
      throw new ArgumentNullException("f", "factory must not be null");
   for (int i = 0; i < count; ++i)
      yield return f.MakeFrob();
}

为什么这是错误的？因为迭代器块直到 foreach 才真正运行！对 GetFrobs 的调用只是返回一个对象，该对象在迭代时将运行迭代器块。

通过像这样编写 null 检查，您可以防止出现 NullReferenceException，但可以将 NullArgumentException 移动到迭代点 >，没有达到调用的程度，这调试起来非常混乱。

正确的修复方法是：

// DO THIS
public IEnumerable<Frob> GetFrobs(FrobFactory f, int count)
{
   // No yields in a public method that throws!
   if (f == null) 
       throw new ArgumentNullException("f", "factory must not be null");
   return GetFrobsForReal(f, count);
}
private IEnumerable<Frob> GetFrobsForReal(FrobFactory f, int count)
{
   // Yields in a private method
   Debug.Assert(f != null);
   for (int i = 0; i < count; ++i)
        yield return f.MakeFrob();
}

也就是说，创建一个具有迭代器块逻辑的私有帮助器方法和一个执行 null 检查并返回迭代器的公共表面方法。现在，当调用 GetFrobs 时，null 检查立即发生，然后在迭代序列时执行 GetFrobsForReal。

如果您检查LINQ to Objects 的参考源，您将发现该技术自始至终都在使用。它写起来稍微有点笨拙，但它使调试无效错误变得更加容易。 优化代码是为了调用者的方便，而不是为了作者的方便。

关于不安全代码中的 null 取消引用的说明

C# 有一种“不安全”模式，顾名思义，这种模式极其危险，因为提供内存安全和类型安全的正常安全机制并未强制执行。 除非您对内存的工作原理有透彻而深入的了解，否则不应编写不安全的代码。

在不安全模式下，您应该了解两个重要事实：

• 取消引用空指针 会产生与取消引用空引用 相同的异常
• 取消引用无效的非空指针在某些情况下可能会产生该异常。

要了解其原因，首先需要了解 .NET 如何产生 NullReferenceException。 （这些详细信息适用于在 Windows 上运行的 .NET；其他操作系统使用类似的机制。）

Windows 中的内存是虚拟化的；每个进程都会获得由操作系统跟踪的许多内存“页”组成的虚拟内存空间。内存的每个页面上都设置了标志，用于确定如何使用它：读取、写入、执行等。 最低页面被标记为“如果以任何方式使用都会产生错误”。

C# 中的空指针和空引用在内部都表示为数字零，因此任何将其取消引用到其相应内存存储的尝试都会导致操作系统产生错误。然后 .NET 运行时会检测到此错误并将其转换为 NullReferenceException。

这就是为什么取消引用空指针和空引用会产生相同的异常。

那么第二点呢？取消引用位于虚拟内存最低页中的任何无效指针都会导致相同的操作系统错误，从而导致相同的异常。

为什么这是有道理的？好吧，假设我们有一个包含两个 int 的结构，以及一个等于 null 的非托管指针。如果我们尝试取消引用结构中的第二个 int，CLR 将不会尝试访问位置 0 处的存储；它将访问位置四的存储。但从逻辑上讲，这是一个 null 取消引用，因为我们通过 null 访问该地址。

如果您正在使用不安全的代码并且收到 NullReferenceException，请注意有问题的指针不必为 null。可以是最底层页面的任意位置，都会产生该异常。

Answer 25

nullReference异常 - 视觉基本

nullReference异常 Visual Basic 与 c＃中的一个没有什么不同。毕竟，他们都报告了他们俩使用的.NET框架中定义的相同例外。视觉基础所独有的原因是罕见的（也许只有一个）。

该答案将使用视觉基本术语，语法和上下文。使用的示例来自大量过去的堆栈＆nbsp;溢出问题。这是通过使用帖子中经常看到的情况的种类来最大化相关性。还为可能需要它的人提供了更多解释。与您类似的示例是非常可能在此处列出的示例。

注意：

1. 这是基于概念的：没有代码可以粘贴到项目中。它旨在帮助您了解导致nullReferenceException（NRE），如何找到它，如何修复它以及如何避免它的原因。 NRE可以引起多种方式，因此这不太可能成为您的唯一遇到。
2. 示例（来自Stack＆nbsp; Overflow帖子）首先并不总是显示出做某事的最佳方法。
3. 通常，使用最简单的补救措施。

基本含义

消息“对象未设置为对象实例” 表示您正在尝试使用尚未初始化的对象。这归结为其中之一：

• 您的代码声明是对象变量，但它没有 inatialize it（创建一个实例或' instantiate '它）
• 您的代码假设会初始化对象的某些东西，
• 其他代码不可能过早地无效仍在使用的对象

找到原因

，因为问题是note nothere 检查他们以找出哪一个。然后确定为什么不初始化。将鼠标固定在各种变量上，Visual Studio（VS）将显示其值 - 罪魁祸首将为Nothing。

您还应该从相关代码中删除任何尝试/捕获块堵塞。这将导致您的代码尝试使用nothing的对象时崩溃。 这就是您想要的，因为它将标识问题的精确位置，并允许您识别引起它的对象。

msgbox在捕获量中显示错误，而...几乎没有帮助。此方法还导致非常糟糕的 stack＆nbsp;溢出问题，因为您无法描述实际例外，涉及的对象甚至代码行的发生在哪里。

您还可以使用当地窗口（ debug - ＆gt; windows - ＆gt;当地人）检查您的对象。

一旦您知道问题所在，通常比发布一个新问题相当容易修复和更快。

另请参阅：

• brekaskpoints
• msdn：如何：使用try/catch块来捕获异常

例外

http://msdn.microsoft.com/en-us/library/seyhszts(v=vs.110).aspx“ rel =“ noreferrer”> msdn ： 一个实例

Dim reg As CashRegister
...
TextBox1.Text = reg.Amount         ' NRE

是dim不创建CashRegister 对象;它仅声明该类型的名为reg的变量。 声明一个对象变量和创建实例是两种不同的事情。

补救件

新通常可以使用运算符来创建实例时：

Dim reg As New CashRegister        ' [New] creates instance, invokes the constructor

' Longer, more explicit form:
Dim reg As CashRegister = New CashRegister

当仅适用于以后创建实例时：

Private reg As CashRegister         ' Declare
  ...
reg = New CashRegister()            ' Create instance

注意： do not < /strong>使用dim在一个过程中再次，包括构造函数（sub new）：

Private reg As CashRegister
'...

Public Sub New()
   '...
   Dim reg As New CashRegister
End Sub

这将创建 local variable，reg，仅在此上下文（sub）中存在。 reg带模块级别的变量范围您将在其他任何地方使用nothing。

缺少新操作员是nullReference异常的＃1原因 在stack＆nbsp;溢出问题审查。

Visual Basic尝试使用 new ：使用 new new 运算符创建< ： strong> new 对象和调用 sub new - 构造函数 - 您的对象可以执行任何其他初始化。

需要清楚，dim（或private）仅声明一个变量及其type。该变量的范围 - 是为整个模块/类存在还是在过程中本地化的范围 - 由确定 被声明。 私人|朋友| public定义访问级别，而不是范围。

有关更多信息，请参见：

• Visual Basic
• Visual Basic中的访问级别
• 值类型和参考类型

---

数组

数组也必须进行实例化：

Private arr as String()

仅声明，而不是创建此数组。有几种初始化数组的方法：

Private arr as String() = New String(10){}
' or
Private arr() As String = New String(10){}

' For a local array (in a procedure) and using 'Option Infer':
Dim arr = New String(10) {}

注意：从VS 2010开始，当使用文字和选项初始化本地数组时，，as＆lt; type; type＆gt; and <代码>新元素是可选的：

Dim myDbl As Double() = {1.5, 2, 9.9, 18, 3.14}
Dim myDbl = New Double() {1.5, 2, 9.9, 18, 3.14}
Dim myDbl() = {1.5, 2, 9.9, 18, 3.14}

从分配的数据中推断出数据类型和数组大小。类/模块级别的声明仍然需要as type＆gt; option strict ：

Private myDoubles As Double() = {1.5, 2, 9.9, 18, 3.14}

示例：类对象的数组

Dim arrFoo(5) As Foo

For i As Integer = 0 To arrFoo.Count - 1
   arrFoo(i).Bar = i * 10       ' Exception
Next

已经创建了数组，但是foo对象没有。

补充

For i As Integer = 0 To arrFoo.Count - 1
    arrFoo(i) = New Foo()         ' Create Foo instance
    arrFoo(i).Bar = i * 10
Next

使用列表（t）将使没有有效对象的元素很难：

Dim FooList As New List(Of Foo)     ' List created, but it is empty
Dim f As Foo                        ' Temporary variable for the loop

For i As Integer = 0 To 5
    f = New Foo()                    ' Foo instance created
    f.Bar =  i * 10
    FooList.Add(f)                   ' Foo object added to list
Next

有关更多信息，请参见：

• option peact supper语句
• /leawn.microsoft.com/en-us/dotnet/visual-basic/programming-guide/language-features/declared-elements/scope“ rel =“ noreferrer”> Visual Basic “ noreferrer”>“ noreferrer”> thusis basic 阵列

---

列表和集合

。还必须实例化或创建净收集（其中有许多品种 - 列表，字典等）。

Private myList As List(Of String)
..
myList.Add("ziggy")           ' NullReference

出于相同的原因，您会获得相同的例外 - myList仅声明，但没有创建实例。补救措施是相同的：

myList = New List(Of String)

' Or create an instance when declared:
Private myList As New List(Of String)

一个常见的监督是使用Collection type的类：

Public Class Foo
    Private barList As List(Of Bar)

    Friend Function BarCount As Integer
        Return barList.Count
    End Function

    Friend Sub AddItem(newBar As Bar)
        If barList.Contains(newBar) = False Then
            barList.Add(newBar)
        End If
    End Function

任何一个过程都会导致NRE，因为barlist仅声明，而不是实例化。创建foo的实例也不会创建内部barlist的实例。可能是在构造函数中执行此操作的目的：

Public Sub New         ' Constructor
    ' Stuff to do when a new Foo is created...
    barList = New List(Of Bar)
End Sub

和以前一样，这是不正确的：

Public Sub New()
    ' Creates another barList local to this procedure
     Dim barList As New List(Of Bar)
End Sub

有关更多信息，请参见 list（t） class 。

---

与数据库一起使用的数据提供商对象

为nullReference提供了许多机会，因为可能有许多对象（命令，Connection，trans> trassaction，dataSet，dataTable，datarows ....）一次使用。 注意：您正在使用哪个数据提供商 - MySQL，SQL Server，OLEDB等 - Concepts 是相同的。

示例1

Dim da As OleDbDataAdapter
Dim ds As DataSet
Dim MaxRows As Integer

con.Open()
Dim sql = "SELECT * FROM tblfoobar_List"
da = New OleDbDataAdapter(sql, con)
da.Fill(ds, "foobar")
con.Close()

MaxRows = ds.Tables("foobar").Rows.Count      ' Error

和以前一样，声明了ds数据集对象，但是从未创建实例。 dataAdapter将填充现有的数据集，而不是创建一个。在这种情况下，由于ds是局部变量，因此IDE警告您可能会发生：

​。不要忽略警告。

补救症

Dim ds As New DataSet

示例2

ds = New DataSet
da = New OleDBDataAdapter(sql, con)
da.Fill(ds, "Employees")

txtID.Text = ds.Tables("Employee").Rows(0).Item(1)
txtID.Name = ds.Tables("Employee").Rows(0).Item(2)

在这里错字是一个问题：员工 vs 雇员。没有DataTable命名为“员工”创建的，因此nullReferenceException尝试访问它的结果。另一个潜在的问题是假设将有项目，当SQL包含一个where子句时，可能并非如此。

补救症

由于使用一个表，使用表（0）将避免拼写错误。检查行。COUNT.COUNT也可以帮助：

If ds.Tables(0).Rows.Count > 0 Then
    txtID.Text = ds.Tables(0).Rows(0).Item(1)
    txtID.Name = ds.Tables(0).Rows(0).Item(2)
End If

fill是返回行的数量受影响的功能：

If da.Fill(ds, "Employees") > 0 Then...

示例3

Dim da As New OleDb.OleDbDataAdapter("SELECT TICKET.TICKET_NO,
        TICKET.CUSTOMER_ID, ... FROM TICKET_RESERVATION AS TICKET INNER JOIN
        FLIGHT_DETAILS AS FLIGHT ... WHERE [TICKET.TICKET_NO]= ...", con)
Dim ds As New DataSet
da.Fill(ds)

If ds.Tables("TICKET_RESERVATION").Rows.Count > 0 Then

dataAdapter将提供tableNames，如上一个示例所示，但不会从SQL或数据库表中解析名称。结果，ds.table（“ ticket_reservation”）引用不存在的表。

补救症是相同的，请参考索引：

If ds.Tables(0).Rows.Count > 0 Then

另请参见 DataTable类。

---

对象路径/嵌套

If myFoo.Bar.Items IsNot Nothing Then
   ...

代码仅测试项目，而myfoo和bar也可能没有。 补救症是一次测试一个对象的整个链或路径：

If (myFoo IsNot Nothing) AndAlso
    (myFoo.Bar IsNot Nothing) AndAlso
    (myFoo.Bar.Items IsNot Nothing) Then
    ....

andoLSO很重要。一旦遇到第一个false条件，将不会执行后续测试。这允许代码一次安全地“钻入”一个“级别”，仅在（如果）myfoo之后评估myfoo.bar才能确定有效。编码复杂对象时，对象链或路径可能会变得很长：

myBase.myNodes(3).Layer.SubLayer.Foo.Files.Add("somefilename")

不可能引用null对象的任何“下游”的内容。这也适用于控件：

myWebBrowser.Document.GetElementById("formfld1").InnerText = "some value"

此处，mywebbrowser或document可能不存在formfld1元素可能不存在。

---

UI控件

Dim cmd5 As New SqlCommand("select Cartons, Pieces, Foobar " _
     & "FROM Invoice where invoice_no = '" & _
     Me.ComboBox5.SelectedItem.ToString.Trim & "' And category = '" & _
     Me.ListBox1.SelectedItem.ToString.Trim & "' And item_name = '" & _
     Me.ComboBox2.SelectedValue.ToString.Trim & "' And expiry_date = '" & _
     Me.expiry.Text & "'", con)

除其他方面，此代码不会预期用户可能不会在一个或多个UI控件中选择某些内容。 ListBox1.SelectedItem很可能是nothing，因此listbox1.selectedItem.toString将导致NRE。

Resedy

在使用该数据之前验证数据（还使用strict和SQL参数）：

Dim expiry As DateTime         ' for text date validation
If (ComboBox5.SelectedItems.Count > 0) AndAlso
    (ListBox1.SelectedItems.Count > 0) AndAlso
    (ComboBox2.SelectedItems.Count > 0) AndAlso
    (DateTime.TryParse(expiry.Text, expiry) Then

    '... do stuff
Else
    MessageBox.Show(...error message...)
End If

或者，您可以使用（combobox5.SelectedItem issonnot nothot nothot） /code>

---

Visual Basic表单

Public Class Form1

    Private NameBoxes = New TextBox(5) {Controls("TextBox1"), _
                   Controls("TextBox2"), Controls("TextBox3"), _
                   Controls("TextBox4"), Controls("TextBox5"), _
                   Controls("TextBox6")}

    ' same thing in a different format:
    Private boxList As New List(Of TextBox) From {TextBox1, TextBox2, TextBox3 ...}

    ' Immediate NRE:
    Private somevar As String = Me.Controls("TextBox1").Text

这是获得NRE的相当常见方法。在C＃中，根据其编码方式，IDE将报告Controls在当前上下文中不存在，或“不能引用非静态成员”。因此，在某种程度上，这是仅VB的情况。它也很复杂，因为它会导致故障级联。

无法以这种方式初始化阵列和集合。此初始化代码将在之前运行 构造函数创建form> form 或Controls 。结果：

• 列表和集合将简单地为空。
• 数组将包含
• somevar分配的五个元素，因为没有什么都没有.Text 属性

引用数组元素以后会导致NRE。如果您在form_load中执行此操作，则由于奇数错误，IDE 可能不会在发生时报告异常。当您的代码试图使用数组时，此例外将弹出以后。这个“沉默异常”是在这篇文章中详细介绍。出于我们的目的，关键是，当创建表单时发生灾难性的事情（sub new或表单加载事件）时，异常可能会毫无报告为只是显示表单。

由于您的sub new或form load事件将在NRE之后运行，因此 可以使很多其他事情都可以不进行原始化。

Sub Form_Load(..._
   '...
   Dim name As String = NameBoxes(2).Text        ' NRE
   ' ...
   ' More code (which will likely not be executed)
   ' ...
End Sub

这适用于任何和所有控制和组件的参考文献，使这些参考是非法的

Public Class Form1

    Private myFiles() As String = Me.OpenFileDialog1.FileName & ...
    Private dbcon As String = OpenFileDialog1.FileName & ";Jet Oledb..."
    Private studentName As String = TextBox13.Text

注释

。 声明在形式级别上的容器，但是 当控件 do 存在时，在形式负载事件处理程序中它们。只要您的代码在oniratizecomponent调用：

' Module level declaration
Private NameBoxes as TextBox()
Private studentName As String

' Form Load, Form Shown or Sub New:
'
' Using the OP's approach (illegal using OPTION STRICT)
NameBoxes = New TextBox() {Me.Controls("TextBox1"), Me.Controls("TestBox2"), ...)
studentName = TextBox32.Text           ' For simple control references

数组代码可能还不属于树林之后，就可以在sub new中完成。在容器控件中的任何控件（例如groupbox或面板）都不会在me.controls中找到；他们将在该面板或GroupBox的控件集合中。拼写控件名称时，也不会返回控件（“ TestBox2”）。在这种情况下，都将再次存储在这些数组元素中，并且在您尝试引用它时会产生NRE。

现在您知道您要寻找的东西，这些应该很容易找到：

“ button2”位于panel

补救措施 上

而不是使用表单的Controls集合而不是通过名称进行

' Declaration
Private NameBoxes As TextBox()

' Initialization -  simple and easy to read, hard to botch:
NameBoxes = New TextBox() {TextBox1, TextBox2, ...)

' Initialize a List
NamesList = New List(Of TextBox)({TextBox1, TextBox2, TextBox3...})
' or
NamesList = New List(Of TextBox)
NamesList.AddRange({TextBox1, TextBox2, TextBox3...})

---

间接

Private bars As New List(Of Bars)        ' Declared and created

Public Function BarList() As List(Of Bars)
    bars.Clear
    If someCondition Then
        For n As Integer = 0 to someValue
            bars.Add(GetBar(n))
        Next n
    Else
        Exit Function
    End If

    Return bars
End Function

参考值和nullReferenceException可能结果'。您可以通过退出功能返回来抑制警告，但这并不能解决问题。任何试图使用返回时somecondition = false的任何试图

bList = myFoo.BarList()
For Each b As Bar in bList      ' EXCEPTION
      ...

使用

返回Blist 。返回空 list与返回nothing不同。如果返回的对象可以没有，请在使用之前进行测试：

 bList = myFoo.BarList()
 If bList IsNot Nothing Then...

---

实现/捕获不良实现的尝试

/捕获可能会隐藏问题的位置，并导致新的问题：

Dim dr As SqlDataReader
Try
    Dim lnk As LinkButton = TryCast(sender, LinkButton)
    Dim gr As GridViewRow = DirectCast(lnk.NamingContainer, GridViewRow)
    Dim eid As String = GridView1.DataKeys(gr.RowIndex).Value.ToString()
    ViewState("username") = eid
    sqlQry = "select FirstName, Surname, DepartmentName, ExtensionName, jobTitle,
             Pager, mailaddress, from employees1 where username='" & eid & "'"
    If connection.State <> ConnectionState.Open Then
        connection.Open()
    End If
    command = New SqlCommand(sqlQry, connection)

    'More code fooing and barring

    dr = command.ExecuteReader()
    If dr.Read() Then
        lblFirstName.Text = Convert.ToString(dr("FirstName"))
        ...
    End If
    mpe.Show()
Catch

Finally
    command.Dispose()
    dr.Close()             ' <-- NRE
    connection.Close()
End Try

这是未预期创建对象的情况，但也演示了空的catch的对抗有用性。

SQL中有一个额外的逗号（在“ Mailaddress”之后），在.executereader中导致例外。 catch什么都不做之后，最后试图进行清洁，但是由于您不能close> close null datareader object ，一个全新的nullReferenceException结果。

空的catch块是魔鬼的游乐场。这种操作让他感到困惑，为什么他在最终块中获得NRE。在其他情况下，一个空的catch可能会导致其他事情进一步出现在下游，并使您花时间在错误的位置查看错误的问题。 （上述上述的“沉默异常”提供了相同的娱乐价值。）

Remedy

不要使用空的尝试/捕获块 - 让代码崩溃，以便您可以a）确定原因b）确定位置c）应用适当的补救措施。尝试/捕获块并不是要隐藏异常的人，以解决这些人的唯一资格 - 开发人员。

---

dbnull与isdbnull函数不一样，

For Each row As DataGridViewRow In dgvPlanning.Rows
    If Not IsDBNull(row.Cells(0).Value) Then
        ...

用于测试如果a value equals system.dbnull：的rel =“ noreferrer”>

system.dbnull值表示对象表示缺失或不存在数据。 dbnull与什么都不相同，这表明尚未初始化变量。

Remedy

If row.Cells(0) IsNot Nothing Then ...

与以前一样，您可以一无所获，然后对于特定值：

If (row.Cells(0) IsNot Nothing) AndAlso (IsDBNull(row.Cells(0).Value) = False) Then

示例2

Dim getFoo = (From f In dbContext.FooBars
               Where f.something = something
               Select f).FirstOrDefault

If Not IsDBNull(getFoo) Then
    If IsDBNull(getFoo.user_id) Then
        txtFirst.Text = getFoo.first_name
    Else
       ...

firstordEfault返回第一个项目或默认值，该值是参考类型的无，从不 dbnull ：

If getFoo IsNot Nothing Then...

---

控制

Dim chk As CheckBox

chk = CType(Me.Controls(chkName), CheckBox)
If chk.Checked Then
    Return chk
End If

如果复选框带有chkname 找不到（或存在于groupbox）中，然后chk将一无所有，并试图引用任何属性会导致例外。

补救

If (chk IsNot Nothing) AndAlso (chk.Checked) Then ...

datagridView

dgv会定期看到一些怪癖：

dgvBooks.DataSource = loan.Books
dgvBooks.Columns("ISBN").Visible = True       ' NullReferenceException
dgvBooks.Columns("Title").DefaultCellStyle.Format = "C"
dgvBooks.Columns("Author").DefaultCellStyle.Format = "C"
dgvBooks.Columns("Price").DefaultCellStyle.Format = "C"

如果dgvbooks具有autogeneratecolumns = true，它将创建列，但不会命名它们，因此上述代码以名称引用时会失败。

Remedy

手动命名列，或通过索引参考：

dgvBooks.Columns(0).Visible = True

请当心newRow。

xlWorkSheet = xlWorkBook.Sheets("sheet1")

For i = 0 To myDGV.RowCount - 1
    For j = 0 To myDGV.ColumnCount - 1
        For k As Integer = 1 To myDGV.Columns.Count
            xlWorkSheet.Cells(1, k) = myDGV.Columns(k - 1).HeaderText
            xlWorkSheet.Cells(i + 2, j + 1) = myDGV(j, i).Value.ToString()
        Next
    Next
Next

示例2 -当您的dataGridView具有allowusertoAddrows at true true <时， /code>（默认值），底部的空白/新行中的单元格都包含nothere。大多数使用内容的尝试（例如，toString）将导致NRE。

补救症

使用for/enver循环并测试isNewrow属性属性来确定是否是最后一行。如果allow usertoAddrows是真的：

For Each r As DataGridViewRow in myDGV.Rows
    If r.IsNewRow = False Then
         ' ok to use this row

如果您确实使用循环，请修改行计数或使用 exit 时> isNewrow 是正确的。

---

在某些情况下，尝试使用my.settings的My.Settings（StringCollection）

，它是StringCollection可能在您第一次使用时会导致nullReference。解决方案是相同的，但不那么明显。考虑：

My.Settings.FooBars.Add("ziggy")         ' foobars is a string collection

由于VB正在为您管理设置，因此可以期望它初始化该集合是合理的。它会，但是只有以前您以前已经在集合中添加了初始条目（在“设置编辑器”中）。由于（显然）在添加项目时（显然是）初始化了该集合，因此当设置编辑器中没有项目要添加时，它仍然是nothing。

Remedy

初始化表单load> LOAD事件处理程序中的设置集合，如果/在需要时：

If My.Settings.FooBars Is Nothing Then
    My.Settings.FooBars = New System.Collections.Specialized.StringCollection
End If

通常，settings Collection只需要初始化第一次运行应用程序。另一种补救措施是在 project -＆gt中为您的收藏中添加初始价值；设置| Foobars ，保存项目，然后删除假值。

---

关键点

您可能忘记了新操作员。

或者

您认为可以完美地执行以将初始化的对象返回您的代码。

不要忽略编译器警告（永远），并且使用选项严格在上（始终）。

---

msdn nullReference异常

Answer 26

另一种情况是当您将 null 对象转换为 值类型。例如，下面的代码：

object o = null;
DateTime d = (DateTime)o;

它将在强制转换时抛出 NullReferenceException。在上面的示例中这似乎很明显，但这可能发生在更“后期绑定”的复杂场景中，其中空对象已从您不拥有的某些代码返回，并且强制转换例如由某些自动系统生成。

其中一个示例是这个简单的 ASP.NET 与 Calendar 控件的绑定片段：

<asp:Calendar runat="server" SelectedDate="<%#Bind("Something")%>" />

这里，SelectedDate 实际上是 Calendar 的一个 DateTime 类型的属性 Web Control 类型，并且绑定可以完美地返回 null。隐式 ASP.NET 生成器将创建一段与上面的强制转换代码等效的代码。这将引发一个很难发现的 NullReferenceException ，因为它位于 ASP.NET 生成的代码中，可以正常编译......