NullReferenceException Classe

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Origine:

NullReferenceException.cs

Eccezione generata quando viene effettuato un tentativo di dereferenziare un oggetto Null.

C#

public class NullReferenceException : SystemException

Ereditarietà

Object

Exception

SystemException

NullReferenceException

Commenti

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

• Si è dimenticato di creare un'istanza di un tipo di riferimento. Nell'esempio seguente viene names dichiarata ma mai creata un'istanza:

  C#

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main(string[] args)
     {
        int value = Int32.Parse(args[0]);
        List<String> names;
        if (value > 0)
           names = new List<String>();
  
        names.Add("Major Major Major");
     }
  }
  // Compilation displays a warning like the following:
  //    Example1.cs(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 durante la compilazione di tale codice generano un avviso. Altri generano un errore e la compilazione ha esito negativo. Per risolvere questo problema, creare un'istanza dell'oggetto in modo che il valore non sia più null. Nell'esempio seguente viene eseguita questa operazione chiamando il costruttore della classe di un tipo.

  C#

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     public static void Main()
     {
        List<String> names = new List<String>();
        names.Add("Major Major Major");
     }
  }
  

• 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 relativi valori genera quindi un'eccezione NullReferenceException .

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
         int[] values = null;
         for (int ctr = 0; ctr <= 9; ctr++)
            values[ctr] = ctr * 2;
  
         foreach (var 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 Example.Main()
  

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

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
         int[] values = new int[10];
         for (int ctr = 0; ctr <= 9; ctr++)
            values[ctr] = ctr * 2;
  
         foreach (var value in values)
            Console.WriteLine(value);
     }
  }
  // The example displays the following output:
  //    0
  //    2
  //    4
  //    6
  //    8
  //    10
  //    12
  //    14
  //    16
  //    18
  

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

• Viene ottenuto un valore restituito null da un metodo e quindi chiamare un metodo nel tipo restituito. Questo a volte è 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 restituirà sempre un valore non Null .

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

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Person[] persons = Person.AddRange( new String[] { "Abigail", "Abra",
                                            "Abraham", "Adrian", "Ariella",
                                            "Arnold", "Aston", "Astor" } );
        String nameToFind = "Robert";
        Person found = Array.Find(persons, p => p.FirstName == nameToFind);
        Console.WriteLine(found.FirstName);
     }
  }
  
  public class Person
  {
     public static Person[] AddRange(String[] firstNames)
     {
        Person[] p = new Person[firstNames.Length];
        for (int ctr = 0; ctr < firstNames.Length; ctr++)
           p[ctr] = new Person(firstNames[ctr]);
  
        return p;
     }
  
     public Person(String firstName)
     {
        this.FirstName = firstName;
     }
  
     public String FirstName;
  }
  // 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.

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        Person[] persons = Person.AddRange( new String[] { "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("{0} not found.", nameToFind);
     }
  }
  
  public class Person
  {
     public static Person[] AddRange(String[] firstNames)
     {
        Person[] p = new Person[firstNames.Length];
        for (int ctr = 0; ctr < firstNames.Length; ctr++)
           p[ctr] = new Person(firstNames[ctr]);
  
        return p;
     }
  
     public Person(String firstName)
     {
        this.FirstName = firstName;
     }
  
     public String FirstName;
  }
  // The example displays the following output:
  //        Robert not found
  

• Si usa un'espressione , ad esempio si sta concatenando un elenco di metodi o proprietà insieme, per recuperare un valore e, anche se si verifica se il valore è null, il runtime genera ancora 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 verifica se la pagina Web corrente ha un titolo non Null e, se lo fa, visualizza il titolo. Nonostante questo controllo, tuttavia, il metodo genera un'eccezione NullReferenceException .

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        var pages = new Pages();
        if (! String.IsNullOrEmpty(pages.CurrentPage.Title)) {
           String title = pages.CurrentPage.Title;
           Console.WriteLine("Current title: '{0}'", title);
        }
     }
  }
  
  public class Pages
  {
     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] == 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 Example.Main()
  

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

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        var pages = new Pages();
        Page current = pages.CurrentPage;
        if (current != null) {
           String title = current.Title;
           Console.WriteLine("Current title: '{0}'", 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.
  

• Si enumera gli elementi di una matrice che contiene tipi di 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 Trim ogni stringa prima di visualizzare la stringa.

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        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.
  //       at Example.Main()
  

  Questa eccezione si verifica se si presuppone che ogni elemento della matrice debba contenere un valore non Null e il valore dell'elemento 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.

  C#

  using System;
  
  public class Example
  {
     public static void Main()
     {
        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
  

• Un'eccezione NullReferenceException può essere generata da un metodo quando accede a un membro di uno dei relativi argomenti, ma tale argomento è null. Il PopulateNames metodo nell'esempio seguente genera l'eccezione nella riga names.Add(arrName);.

  C#

  using System;
  using System.Collections.Generic;
  
  public class Example
  {
     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 (var 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 Example.PopulateNames(List`1 names)
  //       at Example.Main()
  

  Per risolvere questo problema, assicurarsi che l'argomento passato al metodo non sia null oppure gestire l'eccezione generata in un blocco try…catch…finally. Per ulteriori informazioni, vedi Eccezioni.

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

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

Per un elenco di valori di proprietà iniziali per un'istanza di NullReferenceException, vedere il NullReferenceException costruttori.

Gestione di NullReferenceException nel codice di versione

In genere è preferibile evitare un'eccezione NullReferenceException che gestirla dopo che si verifica. La gestione di un'eccezione può complicare la gestione e la comprensione del codice e può talvolta introdurre altri bug. Un'eccezione NullReferenceException è spesso un errore irreversibile. In questi casi, lasciare che l'eccezione arresti l'app potrebbe essere l'alternativa migliore.

In diverse situazioni, tuttavia, la gestione dell'errore può essere utile:

• L'app può ignorare gli oggetti null. Ad esempio, se l'app recupera ed elabora i record di un database, potrebbe essere possibile ignorare alcuni record che risultano in oggetti null. Potrebbe essere sufficiente registrare i dati errati in un file di log o nell'interfaccia utente dell'applicazione.

• È possibile ripristinare lo stato precedente l'eccezione. Ad esempio, una chiamata a un servizio Web che restituisce un tipo di riferimento potrebbe restituire null se la connessione viene persa o il timeout della connessione. È possibile tentare di ripristinare la connessione e riprovare la chiamata.

• È possibile ripristinare uno stato valido dell'app. Supponiamo ad esempio di dover 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 dovesse danneggiare il record di dati, è possibile rimuovere i dati precedenti prima di chiudere l'app.

• È consigliabile segnalare l'eccezione. Ad esempio, se l'errore è stato causato da un errore dall'utente dell'app, è possibile generare un messaggio per aiutarli a fornire le informazioni corrette. È anche possibile registrare le informazioni sull'errore per agevolare la risoluzione del problema. Alcuni framework, come ASP.NET, hanno un gestore di eccezioni di alto livello che acquisisce tutti gli errori in modo tale che non si verifichino mai arresti anomali dell'app. In tal caso, la registrazione dell'eccezione potrebbe essere l'unico modo per sapere se si verifica effettivamente.

Costruttori

NullReferenceException()	Inizializza una nuova istanza della NullReferenceException classe, impostando la Message proprietà della nuova istanza su un messaggio fornito dal sistema che descrive l'errore, ad esempio "Il valore 'null' è stato trovato in cui è stata necessaria un'istanza di un oggetto". Questo messaggio tiene conto delle impostazioni cultura di sistema correnti.
NullReferenceException(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe NullReferenceException con dati serializzati.
NullReferenceException(String)	Inizializza una nuova istanza della classe NullReferenceException con un messaggio di errore specificato.
NullReferenceException(String, Exception)	Inizializza una nuova istanza della classe NullReferenceException con un messaggio di errore specificato e un riferimento all'eccezione interna che è la causa dell'eccezione corrente.

Proprietà

Data	Ottiene una raccolta di coppie chiave/valore che forniscono informazioni definite dall'utente aggiuntive sull'eccezione. (Ereditato da Exception)
HelpLink	Ottiene o imposta un collegamento al file della Guida associato all'eccezione. (Ereditato da Exception)
HResult	Ottiene o imposta HRESULT, un valore numerico codificato che viene assegnato a un'eccezione specifica. (Ereditato da Exception)
InnerException	Ottiene l'istanza di Exception che ha causato l'eccezione corrente. (Ereditato da Exception)
Message	Ottiene un messaggio che descrive l'eccezione corrente. (Ereditato da Exception)
Source	Ottiene o imposta il nome dell'oggetto o dell'applicazione che ha generato l'errore. (Ereditato da Exception)
StackTrace	Ottiene una rappresentazione di stringa dei frame immediati nello stack di chiamate. (Ereditato da Exception)
TargetSite	Ottiene il metodo che genera l'eccezione corrente. (Ereditato da Exception)

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetBaseException()	Quando ne viene eseguito l'override in una classe derivata, restituisce l'Exception che è la causa radice di una o più eccezioni successive. (Ereditato da Exception)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleti. Quando ne viene eseguito l'override in una classe derivata, imposta il controllo SerializationInfo con le informazioni sull'eccezione. (Ereditato da Exception)
GetType()	Ottiene il tipo di runtime dell'istanza corrente. (Ereditato da Exception)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Crea e restituisce una rappresentazione di stringa dell'eccezione corrente. (Ereditato da Exception)

Eventi

SerializeObjectState

Obsoleti. Si verifica quando un'eccezione viene serializzata per creare un oggetto di stato eccezione contenente i dati serializzati relativi all'eccezione. (Ereditato da Exception)

Si applica a

Vedi anche

• Exception
• Gestione e generazione di eccezioni