NullReferenceException Classe

Definizione

public ref class NullReferenceException : Exception

public ref class NullReferenceException : SystemException

public class NullReferenceException : Exception

public class NullReferenceException : SystemException

[System.Serializable]
public class NullReferenceException : SystemException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class NullReferenceException : SystemException

type NullReferenceException = class
    inherit Exception

type NullReferenceException = class
    inherit SystemException

[<System.Serializable>]
type NullReferenceException = class
    inherit SystemException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type NullReferenceException = class
    inherit SystemException

Public Class NullReferenceException
Inherits Exception

Public Class NullReferenceException
Inherits SystemException

Ereditarietà

Object

Exception

NullReferenceException

Ereditarietà

Object

Exception

SystemException

NullReferenceException

Attributi

SerializableAttribute ComVisibleAttribute

Commenti

Viene generata un'eccezione NullReferenceException quando si tenta di accedere a un membro in un tipo il cui valore è null. Un'eccezione NullReferenceException in genere riflette l'errore dello sviluppatore e viene generata negli scenari seguenti:

• Si è dimenticato di creare un'istanza di un tipo riferimento. Nell'esempio seguente viene names dichiarata ma mai creata un'istanza (la riga interessata viene impostata come commento nell'esempio C# perché non viene compilata):

  using System.Collections.Generic;
  
  public class UseBeforeAssignExample
  {
      public static void Main(string[] args)
      {
          int value = int.Parse(args[0]);
          List<string> names;
          if (value > 0)
              names = [];
  
          //names.Add("Major Major Major");
      }
  }
  
  // Compilation displays a warning like the following:
  //    warning BC42104: Variable //names// is used before it
  //    has been assigned a value. A null reference exception could result
  //    at runtime.
  //
  //          names.Add("Major Major Major")
  //          ~~~~~
  // The example displays output like the following output:
  //    Unhandled Exception: System.NullReferenceException: Object reference
  //    not set to an instance of an object.
  //       at UseBeforeAssignExample.Main()
  

  open System
  
  [<EntryPoint>]
  let main args =
      let value = Int32.Parse args[0]
      // Set names to null, don't initialize it. 
      let mutable names = Unchecked.defaultof<ResizeArray<string>>
      if value > 0 then
          names <- ResizeArray()
      names.Add "Major Major Major"
      0
  // Compilation does not display a warning as this is an extremely rare occurance in F#.
  // Creating a value without initalizing either requires using 'null' (not possible
  // on types defined in F# without [<AllowNullLiteral>]) or Unchecked.defaultof.
  //
  // The example displays output like the following output:
  //    Unhandled Exception: System.NullReferenceException: Object reference
  //    not set to an instance of an object.
  //       at Example.main()
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim names As List(Of String)
        names.Add("Major Major Major")       
     End Sub
  End Module
  ' Compilation displays a warning like the following:
  '    Example1.vb(10) : warning BC42104: Variable 'names' is used before it 
  '    has been assigned a value. A null reference exception could result 
  '    at runtime.
  '    
  '          names.Add("Major Major Major")
  '          ~~~~~
  ' The example displays output like the following output:
  '    Unhandled Exception: System.NullReferenceException: Object reference 
  '    not set to an instance of an object.
  '       at Example.Main()
  

  Alcuni compilatori generano un avviso quando compilano questo codice. Altri generano un errore e la compilazione non riesce. Per risolvere questo problema, creare un'istanza dell'oggetto in modo che il relativo valore non sia più null. L'esempio seguente esegue questa operazione chiamando il costruttore della classe di un tipo.

  using System.Collections.Generic;
  
  public class AnotherExample
  {
      public static void Main()
      {
          List<string> names = ["Major Major Major"];
      }
  }
  

  let names = ResizeArray()
  names.Add "Major Major Major"
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim names As New List(Of String)()
        names.Add("Major Major Major")       
     End Sub
  End Module
  

• Si è dimenticato di dimensionare una matrice prima di inizializzarla. Nell'esempio values seguente viene dichiarato come matrice integer, ma il numero di elementi che contiene non viene mai specificato. Il tentativo di inizializzare i valori genera quindi un'eccezione NullReferenceException .

  int[] values = null;
  for (int ctr = 0; ctr <= 9; ctr++)
      values[ctr] = ctr * 2;
  
  foreach (int value in values)
      Console.WriteLine(value);
  
  // The example displays the following output:
  //    Unhandled Exception:
  //       System.NullReferenceException: Object reference not set to an instance of an object.
  //       at Array3Example.Main()
  

  let values: int[] = null
  for i = 0 to 9 do
      values[i] <- i * 2
  
  for value in values do
      printfn $"{value}"
  // The example displays the following output:
  //    Unhandled Exception:
  //       System.NullReferenceException: Object reference not set to an instance of an object.
  //       at <StartupCode$fs>.main()
  

  Module Example
     Public Sub Main()
         Dim values() As Integer
         For ctr As Integer = 0 To 9
            values(ctr) = ctr * 2
         Next
            
         For Each value In values
            Console.WriteLine(value)
         Next      
     End Sub
  End Module
  ' The example displays the following output:
  '    Unhandled Exception: 
  '       System.NullReferenceException: Object reference not set to an instance of an object.
  '       at Example.Main()
  

  È possibile eliminare l'eccezione dichiarando il numero di elementi nella matrice prima di inizializzarlo, come nell'esempio seguente.

  int[] values = new int[10];
  for (int ctr = 0; ctr <= 9; ctr++)
      values[ctr] = ctr * 2;
  
  foreach (int value in values)
      Console.WriteLine(value);
  
  // The example displays the following output:
  //    0
  //    2
  //    4
  //    6
  //    8
  //    10
  //    12
  //    14
  //    16
  //    18
  

  let values = Array.zeroCreate<int> 10
  for i = 0 to 9 do
      values[i] <- i * 2
  
  for value in values do
      printfn $"{value}"
  // The example displays the following output:
  //    0
  //    2
  //    4
  //    6
  //    8
  //    10
  //    12
  //    14
  //    16
  //    18
  

  Module Example
     Public Sub Main()
         Dim values(9) As Integer
         For ctr As Integer = 0 To 9
            values(ctr) = ctr * 2
         Next
            
         For Each value In values
            Console.WriteLine(value)
         Next      
     End Sub
  End Module
  ' The example displays the following output:
  '    0
  '    2
  '    4
  '    6
  '    8
  '    10
  '    12
  '    14
  '    16
  '    18
  

  Per altre informazioni sulla dichiarazione e l'inizializzazione di matrici, vedere Matrici e matrici.

• Si ottiene un valore restituito Null da un metodo e quindi si chiama un metodo sul tipo restituito. Questo talvolta è il risultato di un errore di documentazione; La documentazione non riesce a notare che una chiamata al metodo può restituire null. In altri casi, il codice presuppone erroneamente che il metodo restituisca sempre un valore non Null.

  Il codice nell'esempio seguente presuppone che il metodo restituisca Person sempre l'oggetto il Array.Find cui FirstName campo corrisponde a una stringa di ricerca. Poiché non esiste alcuna corrispondenza, il runtime genera un'eccezione NullReferenceException .

  public static void NoCheckExample()
  {
      Person[] persons = Person.AddRange([ "Abigail", "Abra",
                                        "Abraham", "Adrian", "Ariella",
                                        "Arnold", "Aston", "Astor" ]);
      string nameToFind = "Robert";
      Person found = Array.Find(persons, p => p.FirstName == nameToFind);
      Console.WriteLine(found.FirstName);
  }
  
  // The example displays the following output:
  //       Unhandled Exception: System.NullReferenceException:
  //       Object reference not set to an instance of an object.
  

  open System
  
  type Person(firstName) =
      member _.FirstName = firstName
  
      static member AddRange(firstNames) =
          Array.map Person firstNames
  
  let persons = 
      [| "Abigail"; "Abra"; "Abraham"; "Adrian"
         "Ariella"; "Arnold"; "Aston"; "Astor" |]
      |> Person.AddRange
  
  let nameToFind = "Robert"
  let found = Array.Find(persons, fun p -> p.FirstName = nameToFind)
  
  printfn $"{found.FirstName}"
  
  // The example displays the following output:
  //       Unhandled Exception: System.NullReferenceException:
  //       Object reference not set to an instance of an object.
  //          at <StartupCode$fs>.main()
  

  Module Example
     Public Sub Main()
        Dim persons() As Person = Person.AddRange( { "Abigail", "Abra",
                                                     "Abraham", "Adrian",
                                                     "Ariella", "Arnold", 
                                                     "Aston", "Astor" } )    
        Dim nameToFind As String = "Robert"
        Dim found As Person = Array.Find(persons, Function(p) p.FirstName = nameToFind)
        Console.WriteLine(found.FirstName)
     End Sub
  End Module
  
  Public Class Person
     Public Shared Function AddRange(firstNames() As String) As Person()
        Dim p(firstNames.Length - 1) As Person
        For ctr As Integer = 0 To firstNames.Length - 1
           p(ctr) = New Person(firstNames(ctr))
        Next   
        Return p
     End Function
     
     Public Sub New(firstName As String)
        Me.FirstName = firstName
     End Sub 
     
     Public FirstName As String
  End Class
  ' The example displays the following output:
  '       Unhandled Exception: System.NullReferenceException: 
  '       Object reference not set to an instance of an object.
  '          at Example.Main()
  

  Per risolvere questo problema, testare il valore restituito del metodo per assicurarsi che non null sia prima di chiamare uno dei relativi membri, come illustrato nell'esempio seguente.

  public static void ExampleWithNullCheck()
  {
      Person[] persons = Person.AddRange([ "Abigail", "Abra",
                                        "Abraham", "Adrian", "Ariella",
                                        "Arnold", "Aston", "Astor" ]);
      string nameToFind = "Robert";
      Person found = Array.Find(persons, p => p.FirstName == nameToFind);
      if (found != null)
          Console.WriteLine(found.FirstName);
      else
          Console.WriteLine($"'{nameToFind}' not found.");
  }
  
  // The example displays the following output:
  //        'Robert' not found
  

  open System
  
  [<AllowNullLiteral>]
  type Person(firstName) =
      member _.FirstName = firstName
  
      static member AddRange(firstNames) =
          Array.map Person firstNames
  
  let persons = 
      [| "Abigail"; "Abra"; "Abraham"; "Adrian"
         "Ariella"; "Arnold"; "Aston"; "Astor" |]
      |> Person.AddRange
  
  let nameToFind = "Robert"
  let found = Array.Find(persons, fun p -> p.FirstName = nameToFind)
  
  if found <> null then
      printfn $"{found.FirstName}"
  else 
      printfn $"{nameToFind} not found."
  
  // Using F#'s Array.tryFind function
  // This does not require a null check or [<AllowNullLiteral>]
  let found2 = 
      persons |> Array.tryFind (fun p -> p.FirstName = nameToFind)
  
  match found2 with
  | Some firstName ->
      printfn $"{firstName}"
  | None ->
      printfn $"{nameToFind} not found."
  
  // The example displays the following output:
  //        Robert not found.
  //        Robert not found.
  

  Module Example
     Public Sub Main()
        Dim persons() As Person = Person.AddRange( { "Abigail", "Abra",
                                                     "Abraham", "Adrian",
                                                     "Ariella", "Arnold", 
                                                     "Aston", "Astor" } )    
        Dim nameToFind As String = "Robert"
        Dim found As Person = Array.Find(persons, Function(p) p.FirstName = nameToFind)
        If found IsNot Nothing Then
           Console.WriteLine(found.FirstName)
        Else
           Console.WriteLine("{0} not found.", nameToFind)
        End If   
     End Sub
  End Module
  
  Public Class Person
     Public Shared Function AddRange(firstNames() As String) As Person()
        Dim p(firstNames.Length - 1) As Person
        For ctr As Integer = 0 To firstNames.Length - 1
           p(ctr) = New Person(firstNames(ctr))
        Next   
        Return p
     End Function
     
     Public Sub New(firstName As String)
        Me.FirstName = firstName
     End Sub 
     
     Public FirstName As String
  End Class
  ' The example displays the following output:
  '       Robert not found
  

• Si usa un'espressione ( ad esempio, è stato concatenato un elenco di metodi o proprietà) per recuperare un valore e, anche se si sta controllando se il valore è null, il runtime genera comunque un'eccezione NullReferenceException . Ciò si verifica perché uno dei valori intermedi nell'espressione restituisce null. Di conseguenza, il test per null non viene mai valutato.

  Nell'esempio seguente viene definito un Pages oggetto che memorizza nella cache le informazioni sulle pagine Web, presentate dagli Page oggetti . Il Example.Main metodo controlla se la pagina Web corrente ha un titolo non Null e, in caso affermativo, visualizza il titolo. Nonostante questo controllo, tuttavia, il metodo genera un'eccezione NullReferenceException .

  public class Chain1Example
  {
      public static void Main()
      {
          var pages = new Pages();
          if (!string.IsNullOrEmpty(pages.CurrentPage.Title))
          {
              string title = pages.CurrentPage.Title;
              Console.WriteLine($"Current title: '{title}'");
          }
      }
  }
  
  public class Pages
  {
      readonly Page[] _page = new Page[10];
      int _ctr = 0;
  
      public Page CurrentPage
      {
          get { return _page[_ctr]; }
          set
          {
              // Move all the page objects down to accommodate the new one.
              if (_ctr > _page.GetUpperBound(0))
              {
                  for (int ndx = 1; ndx <= _page.GetUpperBound(0); ndx++)
                      _page[ndx - 1] = _page[ndx];
              }
              _page[_ctr] = value;
              if (_ctr < _page.GetUpperBound(0))
                  _ctr++;
          }
      }
  
      public Page PreviousPage
      {
          get
          {
              if (_ctr == 0)
              {
                  if (_page[0] is null)
                      return null;
                  else
                      return _page[0];
              }
              else
              {
                  _ctr--;
                  return _page[_ctr + 1];
              }
          }
      }
  }
  
  public class Page
  {
      public Uri URL;
      public string Title;
  }
  
  // The example displays the following output:
  //    Unhandled Exception:
  //       System.NullReferenceException: Object reference not set to an instance of an object.
  //       at Chain1Example.Main()
  

  open System
  
  type Page() =
      [<DefaultValue>]
      val mutable public URL: Uri
      [<DefaultValue>]
      val mutable public Title: string
  
  type Pages() =
      let pages = Array.zeroCreate<Page> 10
      let mutable i = 0
  
      member _.CurrentPage
          with get () = pages[i]
          and set (value) =
              // Move all the page objects down to accommodate the new one.
              if i > pages.GetUpperBound 0 then
                  for ndx = 1 to pages.GetUpperBound 0 do
                      pages[ndx - 1] <- pages[ndx]
  
              pages[i] <- value
              if i < pages.GetUpperBound 0 then
                  i <- i + 1
  
      member _.PreviousPage =
          if i = 0 then
              if box pages[0] = null then
                  Unchecked.defaultof<Page>
              else
                  pages[0]
          else
              i <- i - 1
              pages[i + 1]
  
  let pages = Pages()
  if String.IsNullOrEmpty pages.CurrentPage.Title |> not then
      let title = pages.CurrentPage.Title
      printfn $"Current title: '{title}'"
  
  
  // The example displays the following output:
  //    Unhandled Exception:
  //       System.NullReferenceException: Object reference not set to an instance of an object.
  //       at <StartupCode$fs>.main()
  

  Module Example
     Public Sub Main()
        Dim pages As New Pages()
        Dim title As String = pages.CurrentPage.Title
     End Sub
  End Module
  
  Public Class Pages 
     Dim page(9) As Page
     Dim ctr As Integer = 0
     
     Public Property CurrentPage As Page
        Get
           Return page(ctr)
        End Get
        Set
           ' Move all the page objects down to accommodate the new one.
           If ctr > page.GetUpperBound(0) Then
              For ndx As Integer = 1 To page.GetUpperBound(0)
                 page(ndx - 1) = page(ndx)
              Next
           End If    
           page(ctr) = value
           If ctr < page.GetUpperBound(0) Then ctr += 1 
        End Set
     End Property
     
     Public ReadOnly Property PreviousPage As Page
        Get
           If ctr = 0 Then 
              If page(0) Is Nothing Then
                 Return Nothing
              Else
                 Return page(0)
              End If   
           Else
              ctr -= 1
              Return page(ctr + 1)
           End If
        End Get
     End Property         
  End Class
  
  Public Class Page
     Public URL As Uri
     Public Title As String
  End Class
  ' The example displays the following output:
  '    Unhandled Exception: 
  '       System.NullReferenceException: Object reference not set to an instance of an object.
  '       at Example.Main()
  

  L'eccezione viene generata perché pages.CurrentPage restituisce null se nella cache non vengono archiviate informazioni sulla pagina. Questa eccezione può essere corretta testando il valore della proprietà prima di CurrentPage recuperare la proprietà dell'oggetto Title correntePage, come nell'esempio seguente:

  var pages = new Pages();
  Page current = pages.CurrentPage;
  if (current != null)
  {
      string title = current.Title;
      Console.WriteLine($"Current title: '{title}'");
  }
  else
  {
      Console.WriteLine("There is no page information in the cache.");
  }
  
  // The example displays the following output:
  //       There is no page information in the cache.
  

  let pages = Pages()
  let current = pages.CurrentPage
  if box current <> null then
      let title = current.Title
      printfn $"Current title: '{title}'"
  else
      printfn "There is no page information in the cache."
  // The example displays the following output:
  //       There is no page information in the cache.
  

  Module Example
     Public Sub Main()
        Dim pages As New Pages()
        Dim current As Page = pages.CurrentPage
        If current IsNot Nothing Then 
           Dim title As String = current.Title
           Console.WriteLine("Current title: '{0}'", title)
        Else
           Console.WriteLine("There is no page information in the cache.")
        End If   
     End Sub
  End Module
  ' The example displays the following output:
  '       There is no page information in the cache.
  

• Vengono enumerati gli elementi di una matrice che contiene tipi riferimento e il tentativo di elaborare uno degli elementi genera un'eccezione NullReferenceException .

  Nell'esempio seguente viene definita una matrice di stringhe. Un'istruzione for enumera gli elementi nella matrice e chiama il metodo di ogni stringa prima di Trim visualizzare la stringa.

  string[] values = [ "one", null, "two" ];
  for (int ctr = 0; ctr <= values.GetUpperBound(0); ctr++)
      Console.Write("{0}{1}", values[ctr].Trim(),
                    ctr == values.GetUpperBound(0) ? "" : ", ");
  Console.WriteLine();
  
  // The example displays the following output:
  //    Unhandled Exception:
  //       System.NullReferenceException: Object reference not set to an instance of an object.
  

  open System
  
  let values = [| "one"; null; "two" |]
  for i = 0 to values.GetUpperBound 0 do
      printfn $"""{values[i].Trim()}{if i = values.GetUpperBound 0 then "" else ", "}"""
  printfn ""
  // The example displays the following output:
  //    Unhandled Exception:
  //       System.NullReferenceException: Object reference not set to an instance of an object.
  //       at <StartupCode$fs>.main()
  

  Module Example
     Public Sub Main()
        Dim values() As String = { "one", Nothing, "two" }
        For ctr As Integer = 0 To values.GetUpperBound(0)
           Console.Write("{0}{1}", values(ctr).Trim(), 
                         If(ctr = values.GetUpperBound(0), "", ", ")) 
        Next
        Console.WriteLine()
     End Sub
  End Module
  ' The example displays the following output:
  '    Unhandled Exception: System.NullReferenceException: 
  '       Object reference not set to an instance of an object.
  '       at Example.Main()
  

  Questa eccezione si verifica se si presuppone che ogni elemento della matrice debba contenere un valore non Null e che il valore dell'elemento della matrice sia effettivamente null. L'eccezione può essere eliminata verificando se l'elemento è null prima di eseguire qualsiasi operazione su tale elemento, come illustrato nell'esempio seguente.

  string[] values = [ "one", null, "two" ];
  for (int ctr = 0; ctr <= values.GetUpperBound(0); ctr++)
      Console.Write("{0}{1}",
                    values[ctr] != null ? values[ctr].Trim() : "",
                    ctr == values.GetUpperBound(0) ? "" : ", ");
  Console.WriteLine();
  
  // The example displays the following output:
  //       one, , two
  

  open System
  
  let values = [| "one"; null; "two" |]
  for i = 0 to values.GetUpperBound 0 do
      printf $"""{if values[i] <> null then values[i].Trim() else ""}{if i = values.GetUpperBound 0 then "" else ", "}"""
  Console.WriteLine()
  // The example displays the following output:
  //       one, , two
  

  Module Example
     Public Sub Main()
        Dim values() As String = { "one", Nothing, "two" }
        For ctr As Integer = 0 To values.GetUpperBound(0)
           Console.Write("{0}{1}", 
                         If(values(ctr) IsNot Nothing, values(ctr).Trim(), ""), 
                         If(ctr = values.GetUpperBound(0), "", ", ")) 
        Next
        Console.WriteLine()
     End Sub
  End Module
  ' The example displays the following output:
  '       one, , two
  

• Metodo quando accede a un membro di uno dei relativi argomenti, ma tale argomento è null. Il PopulateNames metodo nell'esempio seguente genera l'eccezione alla riga names.Add(arrName);.

  using System.Collections.Generic;
  
  public class NRE2Example
  {
      public static void Main()
      {
          List<string> names = GetData();
          PopulateNames(names);
      }
  
      private static void PopulateNames(List<string> names)
      {
          string[] arrNames = [ "Dakota", "Samuel", "Nikita",
                              "Koani", "Saya", "Yiska", "Yumaevsky" ];
          foreach (string arrName in arrNames)
              names.Add(arrName);
      }
  
      private static List<string> GetData()
      {
          return null;
      }
  }
  
  // The example displays output like the following:
  //    Unhandled Exception: System.NullReferenceException: Object reference
  //    not set to an instance of an object.
  //       at NRE2Example.PopulateNames(List`1 names)
  //       at NRE2Example.Main()
  

  let populateNames (names: ResizeArray<string>) =
      let arrNames =
          [ "Dakota"; "Samuel"; "Nikita"
            "Koani"; "Saya"; "Yiska"; "Yumaevsky" ]
      for arrName in arrNames do
          names.Add arrName
  
  let getData () : ResizeArray<string> =
      null
  
  let names = getData ()
  populateNames names
  
  // The example displays output like the following:
  //    Unhandled Exception: System.NullReferenceException: Object reference
  //    not set to an instance of an object.
  //       at Example.PopulateNames(List`1 names)
  //       at <StartupCode$fs>.main()
  

  Imports System.Collections.Generic
  
  Module Example
     Public Sub Main()
        Dim names As List(Of String) = GetData()
        PopulateNames(names)
     End Sub
     
     Private Sub PopulateNames(names As List(Of String))
        Dim arrNames() As String = { "Dakota", "Samuel", "Nikita",
                                     "Koani", "Saya", "Yiska", "Yumaevsky" }
        For Each arrName In arrNames
           names.Add(arrName)
        Next
     End Sub
     
     Private Function GetData() As List(Of String)
        Return Nothing   
     End Function
  End Module
  ' The example displays output like the following:
  '    Unhandled Exception: System.NullReferenceException: Object reference 
  '    not set to an instance of an object.
  '       at Example.PopulateNames(List`1 names)
  '       at Example.Main()
  

  Per risolvere questo problema, assicurarsi che l'argomento passato al metodo non nullsia o gestire l'eccezione generata in un try…catch…finally blocco. Per altre informazioni, vedere Eccezioni.

• Viene creato un elenco senza conoscere il tipo e l'elenco non è stato inizializzato. Il GetList metodo nell'esempio seguente genera l'eccezione alla riga emptyList.Add(value).

  using System;
  using System.Collections.Generic;
  using System.Collections;
  using System.Runtime.Serialization;
  
  public class NullReferenceExample
  {
      public static void Main()
      {
          var listType = GetListType();
          _ = GetList(listType);
      }
  
      private static Type GetListType()
      {
          return typeof(List<int>);
      }
  
      private static IList GetList(Type type)
      {
          var emptyList = (IList)FormatterServices.GetUninitializedObject(type); // Does not call list constructor
          var value = 1;
          emptyList.Add(value);
          return emptyList;
      }
  }
  // The example displays output like the following:
  //    Unhandled Exception: System.NullReferenceException: 'Object reference
  //    not set to an instance of an object.'
  //    at System.Collections.Generic.List`1.System.Collections.IList.Add(Object item)
  //    at NullReferenceExample.GetList(Type type): line 24
  

  Per risolvere questo problema, assicurarsi che l'elenco sia inizializzato (un modo per eseguire questa operazione consiste nel chiamare Activator.CreateInstance invece di FormatterServices.GetUninitializedObject) o gestire l'eccezione generata in un try…catch…finally blocco. Per altre informazioni, vedere Eccezioni.

Le istruzioni MSIL (Intermediate Language) Microsoft seguenti generano NullReferenceException: callvirt, cpblk, cpobj, initblk, ldelem.<type>, ldelema, ldfld, ldflda, ldind.<type>, ldlen, stelem.<type>, stfld, stind.<type>, throw e unbox.

NullReferenceException usa HRESULT COR_E_NULLREFERENCE, che ha il valore 0x80004003.

Per un elenco dei valori iniziali delle proprietà per un'istanza di NullReferenceException, consultare i costruttori di NullReferenceException.

Quando gestire le eccezioni NullReferenceException

In genere è preferibile evitare un'eccezione NullReferenceException che gestirla dopo che si verifica. La gestione di un'eccezione può rendere il codice più difficile da gestire e comprendere e talvolta introdurre altri bug. Un'eccezione NullReferenceException è spesso un errore non recuperabile. In questi casi, lasciare che l'eccezione arresti l'app potrebbe essere la migliore alternativa.

Tuttavia, esistono molte situazioni in cui la gestione dell'errore può essere utile:

• L'app può ignorare gli oggetti null. Ad esempio, se l'app recupera ed elabora i record in un database, potrebbe essere possibile ignorare alcuni record non validi che generano oggetti Null. La registrazione dei dati non valido in un file di log o nell'interfaccia utente dell'applicazione potrebbe essere tutto quello che devi fare.

• È possibile eseguire il ripristino dall'eccezione. Ad esempio, una chiamata a un servizio Web che restituisce un tipo riferimento potrebbe restituire Null se la connessione viene persa o si verifica il timeout della connessione. È possibile tentare di ristabilire la connessione e ritentare la chiamata.

• È possibile ripristinare lo stato dell'app in uno stato valido. Ad esempio, è possibile eseguire un'attività in più passaggi che richiede di salvare le informazioni in un archivio dati prima di chiamare un metodo che genera un'eccezione NullReferenceException. Se l'oggetto non inizializzato danneggia il record di dati, è possibile rimuovere i dati precedenti prima di chiudere l'app.

• Si vuole segnalare l'eccezione. Ad esempio, se l'errore è stato causato da un errore dell'utente dell'app, è possibile generare un messaggio per aiutarli a fornire le informazioni corrette. È anche possibile registrare informazioni sull'errore per risolvere il problema. Alcuni framework, ad esempio ASP.NET, hanno un gestore di eccezioni di alto livello che acquisisce tutti gli errori in modo che l'app non si arresti mai in modo anomalo. In questo caso, la registrazione dell'eccezione potrebbe essere l'unico modo in cui è possibile sapere che si verifica.

Vedi anche

• Exception
• gestione e generazione di eccezioni