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

Question

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

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

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

Answer 1

另一个可能会收到此例外的常规情况涉及在单元测试期间嘲笑课程。无论使用的模拟框架如何，您都必须确保正确嘲笑所有适当的班级层次结构。特别是，必须模拟 httpContext 的所有属性。

请参阅“ nullReReferenizAttribute> nullReReferenizectexception在测试自定义授权attribute 时，就会丢弃。

Answer 2

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

？ 。在这种情况下，依赖注入容器可以用来初始化服务以避免 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 3

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

在开发时，一种更“正式的”方法是 通过合同设计 在您的代码中。这意味着您需要在开发过程中在系统上设置类不变性和/或偶数函数/方法先前的前提和后条件。

简而言之）。 先决条件是指作为函数/方法输入的数据必须遵循某些约束，并且 postciptions 表示函数/方法输出必须再次遵循集合约束，而不会违反它们。
合同条件应在执行免错误程序期间永远不会违反，因此在调试模式下通过合同进行设计，而在发行版中被禁用，以最大程度地提高开发的系统性能。

这样，您可以避免 nullReferenceException 是违反设置约束的结果的情况。例如，如果您在类中使用对象属性 x ，然后尝试调用其方法之一， x 具有无效值，则将导致 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);
    //...
}

为此， 代码合同 project for .net应用程序存在。

另外，可以使用 >。

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

Answer 4

当我们试图访问空对象的属性或字符串值变为空并且我们正在尝试访问字符串方法时， nullReferenceException 是抛出的。

例如：

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

    字符串str = string.empty;
   str.tolower（）; //投掷null参考异常
    

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

    公共班级人{
       公共字符串名称{get;放; }
   }
   人objperson;
   objperson.name /// fort null refernce异常 
    

Answer 5

tl; dr：尝试使用 html.partial 而不是 renderpage

---

我获得了 aboce>对象参考未设置为对象的实例< /code>当我试图通过向视图呈现视图时，将其发送一个模型，例如：

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

调试显示该模型在Myotherview内是无效的。直到我将其更改为：

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

它起作用。

此外，我没有 html.partial 开始的原因是因为Visual Studio 有时 在 html.partial 如果它在不同的循环中构建不同的，即使这不是真正的错误：

@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正在误读AmperSands和artarkets。

Answer 6

您该怎么办？

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

检查参数

例如，方法可以检查不同的参数，以查看它们是否为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 7

您可以使用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 8

有趣的是，此页面上没有一个答案提及两个边缘情况：

边缘案例＃1：同时访问

.NET中对字典通用词典的访问不是线程安全，并且它们有时可能会抛出 nullReference ，甚至（更频繁的） keynotfoundException 尝试从两个并发线程访问键时。在这种情况下，例外是非常误导的。

边缘案例＃2：

如果 nullReferenceException 由 Unsafe 代码抛出的不安全代码，您可以查看指针变量，并检查它们是否 intptr.Zero 或其他东西。这是同一件事（“ null指针异常”），但是在不安全的代码中，变量通常被铸成值类型/数组等，并且您的头撞到了墙上，想知道价值类型如何将其扔给例外。

（顺便说一句，除非需要，除非您需要不使用不安全的代码。）

边缘案例＃3：带有辅助监视器的Visual Studio Multi Monitor设置，该设置的DPI设置与主监视器不同，

此EDGE CASE是Software-与“ nofollow noreferrer”> Visualio＆nbsp; studio＆nbsp; 2019 iDe（以及可能的versions）。

一种重现问题的方法：将任何组件从工具箱拖到具有与主监视器不同的DPI设置的非主要监视器上的Windows表单中目的。”根据，这个问题已经闻名了很多时间，在编写时，它仍然没有修复。

Answer 9

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

例如：假设您有一个名为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 10

好吧，简单地说：

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

因此，如何解决此问题：

1. 调试并让调试器中断...它将直接带您进入损坏的变量...现在您的任务就是简单地解决此问题。.使用 new new 在适当位置的关键字。

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

    如果（i == null）{
       //处理这个
   }
    

3. 最难的一个..如果 gc 已经收集了该对象...如果您想使用字符串找到一个对象，则通常会发生这种情况...也就是说，通过对象的名称找到它，那么GC可能已经将其清除了...这很难找到和将成为一个很大的问题...解决此问题的更好方法是在开发过程中必要的任何地方进行零检查。这将为您节省很多时间。

通过名称查找，我的意思是某个框架允许您使用字符串查找对象，并且代码可能看起来像： findObject（“ objectName”）;

Answer 11

当您尝试使用的类的对象未实例化时，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 12

从字面上看，修复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 13

这基本上是一个零参考异常。 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 14

什么原因？

底线

您正在尝试使用 null （或 nothing 中的）的东西。这意味着您要么将其设置为 null ，要么根本不会将其设置为任何东西。

像其他任何东西一样， null 被传递。如果是 null 方法“ a”，则可以是该方法“ b”传递 null to 方法“ A”。

null 可以具有不同的含义：

1. 的对象变量，因此 noth noth。在这种情况下，如果您访问此类对象的成员，它导致 nullReferenceException 。
2. 开发人员使用 null 有意表示没有有意义的值。请注意，C＃具有用于变量的无效数据型的概念（例如，数据库表可以具有不可用字段） - 您可以将 null 分配给他们，以表明其中没有存储的值，例如 int？ a = null; （这是 nullable＆lt; int＆gt; a = null; ）的快捷方式，其中问号表示它可以存储在变量中 null a 。如果（a.hasvalue）{...} 或 if（a == null）{...} ，您可以使用进行检查。无效的变量，例如 a 在此示例中，允许通过 a.value 明确或通过 a 明确访问该值。
Note 通过 A.Value 访问 InvalidOperationException 而不是 NullReferenceException 如果 ，则将其访问它。 is null - 您应该事先进行检查，即，如果您有另一个不可用的变量 int b; ，则应进行分配，例如 if（a.hasvalue）{b = a.value; } 或shorter if（a！= null）{b = a; } 。

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

更具体地说的是

Runtime 投掷 nullReferenceException 始终表示同一件事：您正在尝试使用参考，并且该参考未初始化（或它是 初始化的，但不再是 初始化）。

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

string foo = null;
foo.ToUpper();

这将在第二行上扔 nullReferenceException ，因为您无法在 string> String Refere指向 null 。

调试

如何找到 nullReferenceException 的来源？除了查看异常本身（将完全在发生的位置）上抛出外，在Visual Studio中调试的一般规则适用：放置战略断点和检查变量，要么通过将鼠标悬停在其名称上，打开（快速）手表窗口，或使用当地人等各种调试面板，例如汽车。

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

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

示例

一些可以抛出异常的常见场景：

如果Ref1或Ref2或Ref3为

ref1.ref2.ref3.member

null，则您将获得 nullReferenceException 。如果要解决问题，请通过将表达式重写为更简单的等效词来找出null：

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

具体来说，在 httpcontext.current.current.user.sideity.name.name 中，>>>> httpcontext。当前可以为null，或者用户属性可以为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.
    }
}

如果您想避免孩子（人）null引用，则可以在父（书）对象的构造函数中初始化它。

嵌套对象初始化器

相同适用于嵌套对象初始化器：

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

这转化为：

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

new 使用关键字，它仅创建一个新实例 book ，但不创建新实例 person 的内容，因此作者属性仍然是 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" });

新人仅创建一个 person 的实例，但是书籍集合仍然是 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编译器插入事件使用情况的null检查，因此不必检查 在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空视图模型

如果在引用 @model的属性时发生异常，则代码>在 asp.net MVC视图中，您需要了解 model 在您的操作方法中设置时，当您 return> return a视图时。当您从控制器返回空模型（或模型属性）时，当视图访问视图时发生异常：

// 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 控件是在调用 indiralizecomponent ointerizecomponent < /代码>按顺序出现在视觉树中。 nullReferenceException 将在带有事件处理程序等的早期创建控件等的情况下提高，该控件在 initizecomponent 中发射，其中引用晚期创建的控件。

例如：

<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 中更改声明的顺序（即，列表 label1 在 combobox1 之前，忽略设计理念的问题）至少可以解决<代码> NullReferenceException 在此处。

用铸造

var myThing = someObject as Thing;

这不会抛出 invalidcastException ，但在铸件失败时返回 null （以及当 someobject 时）本身为null）。因此请注意。

linq firstordEfault（）和 singleordefault（）

普通版本什么都没有。在这种情况下，“ ORDEFAULT”版本返回 null 。因此请注意。

foreach

foreach 尝试在 null 集合上迭代时投掷。通常是由意外 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;
}

使用 debug.assert ，如果一个值不应为 null ，则比早于问题发生例外。

当您在开发过程中知道一种方法可以，但永远不要返回 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.
}

不过 ：此检查不会最终进入您的版本构建 nullReferenceException 再次在发行模式下运行时 book == null 。

使用 getValueordEfault（） nullable 值类型在 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

使用NULL合并运算符： ?? [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条件运算符：？。可在C＃6和VB.NET 14中提供：

有时也称为安全导航或猫王（其形状后）操作员。如果操作员左侧的表达式为null，则将无法评估右侧，而返回空。这意味着这样的案例：

var title = person.Title.ToUpper();

如果该人没有标题，则会引发异常，因为它试图在具有无效值的属性上调用 toupper 。

在 c＃5 及以下，可以对此进行防护：

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

现在标题变量将是无效的，而不是抛出异常。 C＃6为此引入了较短的语法：

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

这将导致标题变量为 null ，并且如果 person.title 是 null 。

当然，您仍然必须检查 null 或将NULL条件运算符与Null Colescing Operator（ ?? ）要提供默认值：

// 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 中引入，无效的上下文和Nullable参考类型在变量上执行静态分析，并提供编译器警告，如果值可能是 null 或已设置为 null 。无效的参考类型允许明确允许类型为 null 。

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

• 启用：启用了无效的注释上下文。启用了无效的警告上下文。例如，引用类型的变量，例如，字符串是不可删除的。所有无效警告均已启用。
• 禁用：禁用了无效的注释上下文。无效的警告上下文被禁用。就像c＃的早期版本一样，参考类型的变量是遗忘的。所有无效警告均被禁用。
• safeonly ：启用了无效的注释上下文。无效的警告环境是安全的。参考类型的变量是不可删除的。启用了所有安全性无性警告。
• 警告：禁用了无效的注释上下文。启用了无效的警告上下文。参考类型的变量忽略了。所有无效警告均已启用。
• safeonlywarnings ：禁用了无效的注释上下文。无效的警告环境是安全的。
  参考类型的变量忽略了。启用了所有安全性无性警告。

使用与无效的值类型相同的语法记录了一个无效的参考类型：？将附加到变量的类型上。

用于调试和修复迭代器中的null derefs的特殊技术

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) { ... }

如果 whything 导致 null 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 只需返回一个iTerated 时将运行迭代器块的对象。

通过编写 null 以下检查，您可以防止 nullReferenceException ，但是您将 nullargumentException 移动到 iteration ，不是 call 的点，这是非常混乱的调试。

正确的修复程序是：

// 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 的参考源检查到对象中，您将看到此技术在整个过程中都使用。编写稍微笨拙，但使调试无效错误变得容易得多。 为了方便呼叫者而不是作者的便利性，优化您的代码。

关于不安全代码 c＃c​​＃的无效代码的注释，

其“不安全”模式，顾名思义，这是极其危险的，因为提供记忆安全性和类型安全性的正常安全机制未能强制执行。 ，除非您对记忆的工作原理有深刻而深刻的了解，否则您不应编写不安全的代码。

在不安全的模式下，您应该意识到两个重要的事实：

• 取消定位指针产生的例外与删除null 参考
• 降低无效的非零指针在某些情况下可以

理解为什么会产生该例外，它有助于了解.NET首先如何产生 nullReferenceException 。 （这些详细信息适用于在Windows上运行的.NET；其他操作系统使用相似的机制。）

内存在 Windows 中虚拟化；每个过程都会获得操作系统跟踪的许多内存“页面”的虚拟内存空间。内存的每个页面都设置了标志，以确定其使用方式：从，写入，执行等。 最低页面被标记为“如果以任何方式使用，则产生错误”。

c＃中的空指针和null引用均以内部表示为零，因此任何尝试将其放在相应的内存存储中的尝试都会导致操作系统产生错误。然后，.NET运行时检测此错误，并将其转换为 nullReferenceException 。

这就是为什么删除无效指针和无效参考会产生相同例外的原因。

第二点呢？删除属于虚拟内存最低页面的任何无效指针都会导致相同的操作系统错误，从而导致相同的例外。

为什么这有意义？好吧，假设我们有一个包含两个INT的结构，一个不受托管的指针等于NULL。如果我们试图放置结构中的第二个int，则 clr 将不会尝试访问位置零的存储；它将在位置四处访问存储空间。但是从逻辑上讲，这是一个无效的解雇，因为我们正在通过 null到达该地址。

如果您正在使用不安全的代码，并且会得到 nullReferenceException ，请注意，有问题的指针不必为null。它可以是最低页面中的任何位置，并且将产生此例外。

Answer 15

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 16

另一种情况是，当您将null对象施加到a 。例如，下面的代码：

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

它将在铸件上抛出 nullReferenceException 。在上面的示例中似乎很明显，但是这可以在更多的“后期”错综复杂的方案中发生，在这些方案中，从您不拥有的某些代码返回了空对象，并且演员表是由某些自动系统生成的。

一个示例是使用日历控件的简单ASP.NET绑定片段：

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

selected -Date 实际上是 dateTime type -of calendar的属性 - Web控制类型，绑定可以完美返回一些空物。隐式ASP.NET生成器将创建一个代码，该代码等效于上面的铸造代码。这将引起很难发现的 nullReferenceException ，因为它位于ASP.NET生成的代码中，该代码可以编译好...

Answer 17

这意味着您的代码使用了设置为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 18

这意味着所涉及的变量一无所有。我可以这样生成这样的生成：

SqlConnection connection = null;
connection.Open();

这会丢弃错误，因为当我声明变量“ connection ”时，它没有指向任何内容。当我尝试调用成员“ Open ”时，没有参考可以解决，它将引发错误。

为了避免此错误：

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

jetbrains'“ noreferrer”> resharper 工具将确定代码中的每个位置错误，允许您进行零检查。这个错误是恕我直言的错误的第一源。

Answer 19

请注意，无论情况如何，.net中的原因始终是相同的：

您正在尝试使用一个值为 nothing / null 的参考变量。当值为无需/ null 用于参考变量的null ，这意味着它实际上并没有对堆上存在的任何对象的实例进行引用。

您从未将某些内容分配给变量，从未创建分配给变量的值的实例，或者将变量设置为等于 nothing / null null 或者您调用一个将变量设置为 nothing / null 的函数。

Answer 20

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

例如：

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 21

更新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 22

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 and car 是不兼容的类型； CAR 无法转换/铸造到 book 。当此演员失败时，返回 null 。使用 mybook 在导致 nullReferenceException 之后。

通常，您应该使用cast或作为，如下：

如果您期望类型转换始终成功（即。演员：

ComicBook cb = (ComicBook)specificBook;

如果您不确定类型，但是要尝试将其用作特定类型，然后将用作：

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

Answer 23

您正在使用包含null值参考的对象。因此，它给出了无效的例外。在示例中，字符串值为null，在检查其长度时，发生了异常。

示例：

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

异常错误是：

未经治疗的例外：

system.nullReferenceException：对象引用未设置为实例
一个对象。在program.main（）

Answer 24

什么导致 nullReferenceExceptions 以及避免/修复的方法在其他答案中已经解决了这样一个例外，许多程序员还没有学到的是如何独立debug debug 这样开发过程中的例外。

在Visual Studio中，由于“ noreferrer”> Visual Studio Debugger 。

---

首先，确保将要捕获正确的错误 - 查看
我如何允许在VS2010中打破'System.NullReferenceException'？ /em>

然后从调试（F5） 或 将[VS调试器]附加到运行过程 。有时使用 debugger.break ，它将提示启动调试器。

现在，当将nullReferenceException抛弃（或未经处理）时，调试器将停止（记住上面的规则集？）。有时，错误很容易发现。

例如，
在以下行中， can 的唯一代码是例外是 mystring 评估为null。可以通过查看观看窗口或在

var x = myString.Trim();

在更高级的情况下，例如以下情况，您需要使用上面的技术之一（观看或立即的窗口）来检查表达式以确定 str1 是否为null或 str2是否为null 是无效的。

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

一旦， throw的位置已找到，通常会很琐碎地向后推理以找出零值的位置[错误地] -

请花时间了解例外的原因所需的时间。检查无效表达式。检查可能导致此类零表达式的先前表达式。添加并遵守程序。 使用调试器。

---

¹ 如果打开掷出过于侵略性，并且调试器在.net或第三方库中的NPE上停止，则可以使用用户 - 毫无用处 break 可用于限制捕获的异常。此外，VS2012引入只是我的代码我也建议启用。

如果您仅启用了我的代码，则行为略有不同。只需启用我的代码，调试器就忽略了在我的代码之外抛出的第一频通用语言运行时（CLR）异常，并且不会通过我的代码

Answer 25

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 26

当实体框架中使用的实体的类名称与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（）