什么是 NullReferenceException，如何修复它？

Question

我有一些代码，当它执行时，它抛出一个 NullReferenceException ，说：

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

这是什么意思？我该如何修复此错误？

Answer 1

原因是什么？

底线

您正在尝试使用 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.Value; } 或更短的 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：启用可空注释上下文。可为空的警告上下文是安全的。引用类型的变量不可为 null。所有安全可空性警告均已启用。
• 警告：可空注释上下文已禁用。可以为空的警告上下文已启用。引用类型的变量是不可见的。所有可空性警告均已启用。
• 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 2

NullReference 异常 - Visual Basic

Visual Basic 的 NullReference 异常 与 C# 中的 NullReference 异常没有什么不同。毕竟，它们都报告它们都使用的 .NET Framework 中定义的相同异常。 Visual Basic 特有的原因很少（也许只有一个）。

本答案将使用 Visual Basic 术语、语法和上下文。使用的例子来自大量过去的Stack溢出问题。这是为了通过使用帖子中常见的各种情况来最大化相关性。还为可能需要的人提供了更多解释。这里很可能列出了与您类似的示例。

注意：

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

基本含义

消息“对象未设置为对象的实例”意味着您正在尝试使用尚未初始化的对象。这可以归结为以下之一：

• 您的代码声明了一个对象变量，但没有初始化它（创建一个实例或“实例化”）它）
• 您的代码假设会初始化对象的东西，但没有
• 可能，其他代码过早地使仍在使用的对象失效

查找原因

由于问题是一个对象引用，它是Nothing，所以答案是检查它们以找出是哪一个。然后判断为什么没有初始化。将鼠标悬停在各个变量上，Visual Studio (VS) 将显示它们的值 - 罪魁祸首将是 Nothing。

您还应该从相关代码中删除所有 Try/Catch 块，尤其是 Catch 中没有任何内容的代码块堵塞。当您的代码尝试使用 Nothing 的对象时，这将导致您的代码崩溃。 这就是您想要的，因为它将识别问题的确切位置，并允许您识别导致问题的对象。

Catch 中显示 Error while... 的 MsgBox 没有什么帮助。此方法还会导致堆栈非常糟糕溢出问题，因为您无法描述实际的异常、涉及的对象甚至发生异常的代码行。

您还可以使用Locals Window（调试 -> Windows -> Locals）来检查您的对象。

一旦您知道问题是什么以及问题出在哪里，通常就很容易修复，并且比发布新问题更快。

另请参阅：

• 断点
• MSDN：如何：使用 Try/Catch 块捕获异常
• MSDN：异常的最佳实践

示例和补救措施

类对象/创建实例

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

问题是 Dim 不会创建 CashRegister 对象；它仅声明该类型的名为 reg 的变量。 声明对象变量和创建实例是两件不同的事情。

补救措施

New 运算符通常可用于在声明实例时创建实例：

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

注意：不要< /strong> 在过程中再次使用 Dim，包括构造函数 (Sub New)：

Private reg As CashRegister
'...

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

这将创建一个本地变量，reg，仅存在于该上下文（子）中。您将在其他地方使用的具有模块级别 Scope 的 reg 变量仍然是 Nothing。

缺少 New 运算符是堆栈中出现 NullReference 异常 的第一大原因审查了溢出问题。

Visual Basic 尝试使用 New 反复使该过程变得清晰：使用 New 运算符创建一个 < strong>new 对象并调用 Sub New - 构造函数 - 您的对象可以在其中执行任何其他初始化。

需要明确的是，Dim（或Private）仅声明一个变量及其类型。变量的范围 - 无论它存在于整个模块/类还是局部于过程 - 由声明它的位置决定。 私人 |朋友| Public 定义访问级别，而不是范围。

有关详细信息，请参阅：

• 新运算符< /a>
• 范围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 开始，当使用文字和 Option Infer 初始化本地数组时，As 和 < code>New 元素是可选的：

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 和 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

使用 List(Of 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

有关详细信息，请参阅：

• 选项推断语句
• Visual Basic 中的范围
• Visual Basic 中的数组

---

列表和集合

。 NET 集合（其中有很多种类 - 列表、字典等）也必须实例化或创建。

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)

常见的疏忽是使用集合 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(Of T) 类。

---

数据提供者对象

使用数据库为 NullReference 提供了许多机会，因为可以有许多对象（Command、Connection、Transaction、Dataset、DataTable、DataRows....) 立即使用。 注意：无论您使用哪个数据提供程序（MySQL、SQL Server、OleDB 等），概念都是相同的。

示例 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 Dataset 对象，但从未创建实例。 DataAdapter 将填充现有的DataSet，而不是创建一个。在这种情况下，由于 ds 是局部变量，因此 IDE 会警告您可能会发生这种情况：

当声明为模块/类级别变量时，如 con 的情况，编译器无法知道该对象是否由上游过程创建。不要忽视警告。

补救措施

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)

这里存在拼写错误的问题：Employees 与 Employee。没有创建名为“Employee”的 DataTable，因此尝试访问它会导致 NullReferenceException。另一个潜在的问题是假设存在 Items，但当 SQL 包含 WHERE 子句时，情况可能并非如此。

补救措施

由于这使用一个表，因此使用 Tables(0) 将避免拼写错误。检查 Rows.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 是一个返回受影响的 Rows 数量的函数，也可以对其进行测试：

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.Tables("TICKET_RESERVATION") 引用了一个不存在的表。

补救措施是相同的，通过索引引用表格：

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

另请参阅DataTable 类。

---

对象路径/嵌套

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

代码仅测试 Items，而 myFoo 和 Bar 也可能是 Nothing。 补救措施是一次测试一个对象的整个链或路径：

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

AndAlso 很重要。一旦遇到第一个 False 条件，后续测试将不会执行。这允许代码一次安全地“钻取”对象一个“级别”，仅在确定 myFoo 后（并且如果）才评估 myFoo.Bar是有效的。在对复杂对象进行编码时，对象链或路径可能会变得相当长：

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

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

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

这里，myWebBrowser 或 Document 可以为 Nothing，或者 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。

补救措施

在使用数据之前验证数据（也使用Option 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 IsNot Nothing) AndAlso...< /code>

---

Visual Basic Forms

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 或 Controls.结果：

• 列表和集合将只是空
• 数组将包含 Nothing 的五个元素
• somevar 赋值将导致立即 NRE，因为 Nothing 没有 .Text property

稍后引用数组元素将产生 NRE。如果您在 Form_Load 中执行此操作，由于奇怪的错误，IDE 在发生异常时可能不会报告该异常。当您的代码尝试使用该数组时，稍后会弹出异常。 这篇文章详细介绍了这种“静默异常”。就我们的目的而言，关键是当创建表单时发生灾难性事件（Sub New 或 Form Load 事件）时，可能不会报告异常，代码会退出过程并仅显示表格。

由于 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

部分补救措施

奇怪的是 VB 没有提供警告，但补救措施是在表单级别声明容器，但当控件确实存在时，在表单加载事件处理程序中初始化它们。只要您的代码位于 InitializeComponent 调用之后，就可以在 Sub New 中完成此操作：

' 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

数组代码可能尚未脱离困境。容器控件（例如 GroupBox 或 Panel）中的任何控件都不会在 Me.Controls 中找到；它们将位于该面板或组框的控件集合中。当控件名称拼写错误时 ("TeStBox2")，也不会返回控件。在这种情况下，Nothing 将再次存储在这些数组元素中，并且当您尝试引用它时将产生 NRE。

既然您知道自己在寻找什么，那么这些应该很容易找到：

“Button2”位于面板

补救措施

不要使用表单的 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

在这种情况下，IDE 会警告您“并非所有路径都返回”可能会导致一个值和一个 NullReferenceException'。您可以通过将 Exit Function 替换为 Return Nothing 来抑制警告，但这并不能解决问题。当 someCondition = False 时尝试使用 return 的任何操作都会导致 NRE：

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

补救措施

将函数中的 Exit Function 替换为 Return b列表。返回空 List 与返回Nothing 不同。如果返回的对象有可能Nothing，请在使用它之前进行测试：

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

---

实施不当的 Try/Catch

实施不当的 Try/Catch 可能会隐藏问题所在并导致新的问题：

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 不执行任何操作后，Finally 尝试执行清理，但由于您无法 Close 空 DataReader 对象，一个全新的 NullReferenceException 结果。

空的 Catch 块是魔鬼的游乐场。这位 OP 很困惑为什么他会在 Finally 块中得到一个 NRE。在其他情况下，空的 Catch 可能会导致下游的其他事情变得混乱，并导致您花时间在错误的位置查找错误的内容来解决问题。 （上述“静默异常”提供了相同的娱乐价值。）

补救措施

不要使用空的 Try/Catch 块 - 让代码崩溃，以便您可以 a) 确定原因 b) 确定位置c) 采取适当的补救措施。 Try/Catch 块并不是为了向唯一有资格修复它们的人（开发人员）隐藏异常。

---

DBNull 与 Nothing 不同

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

IsDBNull 函数用于测试值是否等于 System.DBNull：来自 MSDN：

System.DBNull 值指示该对象表示丢失或不存在的数据。 DBNull 与 Nothing 不同，Nothing 表示变量尚未初始化。

补救措施

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

与之前一样，您可以测试 Nothing，然后测试特定值：

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 返回第一项或默认值，其中对于引用类型来说是 Nothing，并且从不 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 的 CheckBox（或者存在于 GroupBox 中），则 chk 将为 Nothing，并且尝试引用任何属性都会导致异常。

补救措施

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，它将创建列，但不会命名它们，因此上面的代码在按名称引用它们时会失败。

补救措施

手动命名列，或按索引引用：

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 设置为 True< 时， /code> （默认），底部空白/新行中的 Cells 将全部包含 Nothing。大多数使用内容的尝试（例如，ToString）都会导致 NRE。

补救措施

使用 For/Each 循环并测试 IsNewRow 属性以确定它是否是最后一行。无论 AllowUserToAddRows 是否为真，这都有效：

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

如果您确实使用 For n 循环，请修改行数或在 Exit For 时使用>IsNewRow 为 true。

---

My.Settings (StringCollection)

在某些情况下，尝试使用 My.Settings 中的一个 StringCollection 项目可能会在您第一次使用它时导致 NullReference。解决方案是相同的，但不那么明显。考虑一下：

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

由于 VB 正在为您管理“设置”，因此期望它初始化该集合是合理的。它会，但前提是您之前已将初始条目添加到集合中（在“设置”编辑器中）。由于该集合（显然）是在添加项目时初始化的，因此当“设置”编辑器中没有要添加的项目时，该集合将保持 Nothing 状态。

补救措施

如果需要的话，在表单的 Load 事件处理程序中初始化设置集合：

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

通常，Settings 集合只需要在以下情况下初始化：应用程序第一次运行时。另一种补救措施是在项目 -> 中为您的集合添加初始值。设置 | FooBars，保存项目，然后删除假值。

---

要点

您可能忘记了 New 运算符。

或者

您认为可以完美地执行以将初始化的对象返回到您的代码的某些操作，但事实并非如此。

不要忽略编译器警告（永远）并使用Option Strict On（始终）。

---

MSDN NullReference 异常

Answer 3

另一种情况是当您将 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 生成的代码中，可以正常编译...

Answer 4

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

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

SqlConnection connection = null;
connection.Open();

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

要避免此错误：

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

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

Answer 6

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

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

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

Answer 7

抛出此异常的一个示例是：当您尝试检查某些内容时，该内容为空。

例如：

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。

与 ArgumentNullException 相比，如果方法期望传递给它的内容不为空，则通常将抛出 ArgumentNullException 作为防御措施。

更多信息请参见C# NullReferenceException 和 Null 参数。

Answer 8

更新 C#8.0，2019：可为空引用类型

C#8.0 引入了可为空引用类型和不可为空引用类型。因此，必须仅检查可为 null 的引用类型以避免 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]。

因此，如果您正在处理值类型，则可能不会发生 NullReferenceException。不过在处理引用类型时您需要保持警惕！

顾名思义，只有引用类型可以保存引用或实际上指向任何内容（或“空”）。而值类型总是包含一个值。

引用类型（必须勾选这些）：

• 动态
• 对象
• 字符串

值类型（可以忽略这些）：

• 数字类型
• 整数类型
• 浮点类型
• 小数
• bool
• 用户定义结构体

Answer 9

可能发生 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，如下所示：

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

ComicBook cb = (ComicBook)specificBook;

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

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

Answer 10

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

示例：

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

异常错误为：

未处理的异常：

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

Answer 11

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

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

---

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

然后 < 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 12

Simon Mourier 给出了这个示例：

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

其中拆箱转换（强制转换) 来自 object （或来自 System.ValueType 或 System.Enum 类之一，或来自接口type）值类型（Nullable<>除外）本身会产生NullReferenceException。

另一方面，从具有 HasValueNullable 的装箱转换 code> 等于 false 对于引用类型，可以给出 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 13

添加当实体框架中使用的实体的类名与 Web 表单代码隐藏文件的类名相同时的情况。

假设您有一个 Web 表单 Contact.aspx，其代码隐藏类是 Contact，并且您有一个实体名称 Contact。

然后，当您调用 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;}
}

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

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

当实体和代码隐藏类位于同一命名空间中时，会发生错误。
要解决此问题，请重命名 Contact.aspx 的实体类或代码隐藏类。

原因
我仍然不确定原因。但每当任何实体类扩展 System.Web.UI.Page 时，就会发生此错误。

有关讨论，请查看 DbContext.saveChanges() 中的 NullReferenceException

Answer 14

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

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

Answer 15

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

当跨不同层工作时，例如在 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 16

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

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

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

这样，您可以避免因违反约束集而导致的 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 17

当我们尝试访问 null 对象的 Properties 时，或者当字符串值变为空并且我们尝试访问字符串方法时，会引发 NullReferenceException。

例如：

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

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

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

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

Answer 18

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 19

你能对此做什么？

这里有很多很好的答案，解释了什么是空引用以及如何调试它。但关于如何预防该问题或至少使其更容易被发现的信息却很少。

检查参数

例如，方法可以检查不同的参数以查看它们是否为 null 并抛出 ArgumentNullException，显然是为此目的而创建的异常。

ArgumentNullException 的构造函数甚至将参数名称和消息作为参数，以便您可以准确地告诉开发人员问题所在。

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

使用工具

还有一些库可以提供帮助。例如，“Resharper”可以在您编写代码时向您提供警告，特别是在您使用其属性时： NotNullAttribute

有“Microsoft 代码合同”，您可以在其中使用 Contract.Requires(obj != null) 等语法，为您提供运行时和编译检查：介绍代码契约。

还有“PostSharp”，它允许您仅使用如下属性：

public void DoSometing([NotNull] obj)

通过这样做并使 PostSharp 成为构建过程的一部分，将在运行时检查 obj 是否为 null。请参阅：PostSharp 空值检查

纯代码解决方案

或者您始终可以使用纯旧代码编写自己的方法。例如，这是一个可用于捕获空引用的结构。它采用与 Nullable 相同的概念进行建模：

[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 的方式非常相似，只不过目标是准确完成相反 - 不允许 null。以下是一些示例：

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

NotNull 与 T 之间隐式转换，因此您可以在任何需要的地方使用它。例如，您可以将 Person 对象传递给采用 NotNull 的方法：

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

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

正如您在上面所看到的，对于可为 null 的情况，您可以通过Value 属性。或者，您可以使用显式或隐式转换，您可以看到下面带有返回值的示例：

Person person = GetPerson();

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

或者您甚至可以在方法仅返回 T 时使用它（在本例中为 Person< /code>) 通过进行强制转换。例如，以下代码与上面的代码类似：

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

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

与扩展结合

将 NotNull 与扩展方法结合，您可以覆盖更多情况。以下是扩展方法的示例：

[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-conditional”运算符”这对此有一点帮助。利用此功能，您可以引用嵌套对象，如果其中任何一个为 null，则整个表达式将返回 null。

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

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

假设country是一个Country类型的对象，它有一个名为State的属性等等。如果 country、State、County 或 City 为 null 则 地址将为null。因此，您只需检查address是否为null`。

这是一个很棒的功能，但它为您提供的信息较少。它并没有明确表明这 4 个中哪一个为空。

像 Nullable 一样内置？

C# 有一个很好的 Nullable 简写方式，您可以通过在类型后面添加一个问号来使某些内容可以为 null，如 int ？。

如果 C# 具有类似于上面的 NotNull 结构的内容，并且具有类似的简写形式（可能是感叹号 (!)），那就太好了，这样您就可以编写如下内容：public void WriteName （人！人）。

Answer 20

您可以使用 C# 6 中的 Null 条件运算符以干净的方式修复 NullReferenceException，并编写更少的代码来处理 null 检查。

它用于在执行成员访问 (?.) 或索引 (?[) 操作之前测试 null。

示例

  var name = p?.Spouse?.FirstName;

等价于：

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

当 p 为 null 或 p.Spouse 为 null 时，结果是 name 为 null。

否则，变量名称将被赋予p.Spouse.FirstName的值。

有关更多详细信息：空条件运算符

Answer 21

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

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

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

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

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

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

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

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

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

Answer 22

错误行“未将对象引用设置到对象的实例。”表明您尚未将实例对象分配给对象引用，但您仍在访问该对象的属性/方法。

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

简单来说：

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

那么如何解决这个问题：

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

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

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

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

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

Answer 24

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

如上面的代码所示，语句
Student s - 只声明Student类型的变量，注意此时Student类还没有实例化。
因此，当执行s.GetFullName()语句时，它将抛出NullReferenceException。

Answer 25

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

例如，如果您有一个带有附加脚本的游戏对象和一个名为 rb（刚体）的变量，则当您开始游戏时，该变量将以 null 开头。
这就是您收到 NullReferenceException 的原因，因为计算机没有在该变量中存储数据。

我将使用 RigidBody 变量作为示例。
实际上，我们可以通过几种方式轻松添加数据：

1. 使用 AddComponent > 添加 RigidBody 到您的对象中。物理>刚体
   然后进入脚本并输入 rb = GetComponent();
   这行代码在 Start() 或 Awake() 函数下效果最佳。
2. 您可以通过编程方式添加组件，并使用一行代码同时分配变量： rb = AddComponent();

进一步说明：如果您想要 Unity 要向您的对象添加组件，而您可能忘记添加组件，您可以输入 [RequireComponent (typeof(RigidBody))] 位于类声明上方（所有 using 下面的空间）。

享受制作游戏的乐趣！

Answer 26

这基本上是一个空引用异常。正如Microsoft所述 -

当您尝试访问某个对象时，会抛出 NullReferenceException 异常
值为 null 的类型的成员。

这意味着什么？

这意味着，如果任何不具有任何价值的成员，并且我们正在让该成员执行某些任务，那么系统无疑会抛出一条消息并说 -

“嘿等等，该成员没有值，所以它不能执行您正在移交的任务。”

异常本身表示正在引用某些内容，但尚未设置其值。因此，这表示它仅在使用引用类型时发生，因为值类型不可为空。

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

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

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

现在，当我尝试打印字符串 str 的长度时，我确实收到了 发生了类型为 'System.NullReferenceException' 的未处理异常 消息，因为成员 str< /strong> 指向 null 并且不能有任意长度的 null。

当我们忘记实例化引用类型时，也会发生“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. 显式检查：我们应该遵循检查对象、属性、方法、数组和集合是否为 null 的传统。这可以使用 if-else if-else 等条件语句简单地实现。

2. 异常处理：管理此异常的重要方法之一。使用简单的 try-catch-finally 块，我们可以控制这个异常并维护它的日志。当您的应用程序处于生产阶段时，这非常有用。

3. 空运算符：在为对象、变量、属性和字段设置值时，也可以方便地使用空合并运算符和空条件运算符。

4. 调试器：对于开发者来说，我们身边有一个大武器——调试。如果我们在开发过程中遇到NullReferenceException，我们可以使用调试器来找到异常的来源。

5. 内置方法：GetValueOrDefault()、IsNullOrWhiteSpace() 和 IsNullorEmpty() 等系统方法检查空值，如果存在空值，则分配默认值。

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

希望这也有帮助！