NullReferenceException Klasse

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

NullReferenceException.cs

Die Ausnahme, die bei einem Versuch ausgelöst wird, einen Verweis auf ein NULL-Objekt zu dereferenzieren.

C#

public class NullReferenceException : SystemException

Vererbung

Object

Exception

SystemException

NullReferenceException

Hinweise

Eine NullReferenceException Ausnahme wird ausgelöst, wenn Sie versuchen, auf ein Element für einen Typ zuzugreifen, dessen Wert ist null. Eine NullReferenceException Ausnahme spiegelt in der Regel Entwicklerfehler wider und wird in den folgenden Szenarien ausgelöst:

• Sie haben vergessen, einen Verweistyp zu instanziieren. Im folgenden Beispiel wird deklariert, names aber nie instanziiert:

  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()
  

  Einige Compiler geben eine Warnung aus, wenn sie diesen Code kompilieren. Andere geben einen Fehler aus, und die Kompilierung schlägt fehl. Um dieses Problem zu beheben, instanziieren Sie das Objekt so, dass sein Wert nicht mehr nullist. Im folgenden Beispiel wird dazu der Klassenkonstruktor eines Typs aufgerufen.

  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");
     }
  }
  

• Sie haben vergessen, ein Array zu dimensionieren, bevor Sie es initialisieren. Im folgenden Beispiel values wird als ganzzahliges Array deklariert, aber die Anzahl der darin enthaltenen Elemente wird nie angegeben. Der Versuch, die Werte zu initialisieren, löst daher eine Ausnahme aus 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()
  

  Sie können die Ausnahme beseitigen, indem Sie die Anzahl der Elemente im Array deklarieren, bevor Sie es initialisieren, wie im folgenden Beispiel.

  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
  

  Weitere Informationen zum Deklarieren und Initialisieren von Arrays finden Sie unter Arrays und Arrays.

• Sie erhalten einen NULL-Rückgabewert von einer Methode und rufen dann eine Methode für den zurückgegebenen Typ auf. Dies ist manchmal das Ergebnis eines Dokumentationsfehlers. In der Dokumentation wird nicht darauf hingewiesen, dass ein Methodenaufruf zurückgegeben nullwerden kann. In anderen Fällen geht Ihr Code fälschlicherweise davon aus, dass die Methode immer einen Wert ungleich NULL zurückgibt.

  Der Code im folgenden Beispiel geht davon aus, dass die Array.Find -Methode immer ein Objekt zurückgibt Person , dessen FirstName Feld mit einer Suchzeichenfolge übereinstimmt. Da es keine Übereinstimmung gibt, löst die Runtime eine Ausnahme aus 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()
  

  Um dieses Problem zu beheben, testen Sie den Rückgabewert der Methode, um sicherzustellen, dass er nicht null vorhanden ist, bevor Sie wie im folgenden Beispiel eines ihrer Member aufrufen.

  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
  

• Sie verwenden einen Ausdruck (z. B. verketten Sie eine Liste von Methoden oder Eigenschaften), um einen Wert abzurufen. Obwohl Sie überprüfen, ob der Wert ist null, löst die Runtime dennoch eine Ausnahme aus NullReferenceException . Dies tritt auf, weil einer der Zwischenwerte im Ausdruck zurückgibt null. Daher wird Ihr Test für null nie ausgewertet.

  Im folgenden Beispiel wird ein Pages Objekt definiert, das Informationen zu Webseiten zwischenspeichert, die von Page Objekten angezeigt werden. Die Example.Main -Methode überprüft, ob die aktuelle Webseite einen Ungleich-NULL-Titel aufweist, und zeigt den Titel an, falls dies der Fall ist. Trotz dieser Überprüfung löst die Methode jedoch eine Ausnahme aus 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()
  

  Die Ausnahme wird ausgelöst, da pages.CurrentPage zurückgegeben wird null , wenn keine Seiteninformationen im Cache gespeichert sind. Diese Ausnahme kann korrigiert werden, indem Der Wert der CurrentPage -Eigenschaft vor dem Abrufen der Eigenschaft des Title aktuellen Page Objekts getestet wird, wie im folgenden Beispiel:

  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.
  

• Sie listen die Elemente eines Arrays auf, das Verweistypen enthält, und ihr Versuch, eines der Elemente zu verarbeiten, löst eine Ausnahme aus NullReferenceException .

  Im folgenden Beispiel wird ein Zeichenfolgenarray definiert. Eine for -Anweisung listet die Elemente im Array auf und ruft die Methode jeder Zeichenfolge Trim auf, bevor die Zeichenfolge angezeigt wird.

  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()
  

  Diese Ausnahme tritt auf, wenn Sie davon ausgehen, dass jedes Element des Arrays einen Wert ungleich NULL enthalten muss und der Wert des Arrayelements tatsächlich nullist. Die Ausnahme kann beseitigt werden, indem getestet wird, ob das Element vor dem Ausführen eines Vorgangs für dieses Element ist null , wie das folgende Beispiel zeigt.

  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
  

• Eine NullReferenceException Ausnahme kann von einer Methode ausgelöst werden, wenn sie auf ein Element eines ihrer Argumente zugreift, aber dieses Argument ist null. Die PopulateNames -Methode im folgenden Beispiel löst die Ausnahme an der Zeile names.Add(arrName);aus.

  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()
  

  Um dieses Problem zu beheben, stellen Sie sicher, dass das an die -Methode übergebene Argument nicht nullist, oder behandeln Sie die ausgelöste Ausnahme in einem try…catch…finally Block. Weitere Informationen finden Sie unter Ausnahmendefiniert sind.

Die folgenden MSIL-Anweisungen (Microsoft Intermediate Language) lösen folgendes ausNullReferenceException: callvirt, , cpblk, cpobjinitblk, ldelem.<type>ldelema, , ldfld, , ldflda, ldind.<type>, , ldlen, stelem.<type>, , stfld, stind.<type>, throwund unbox.

NullReferenceException verwendet die HRESULT-COR_E_NULLREFERENCE, die den Wert 0x80004003 hat.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von NullReferenceException, finden Sie unter den NullReferenceException Konstruktoren.

Behandeln von NullReferenceException im Releasecode

Es ist in der Regel besser, eine NullReferenceException zu vermeiden, als sie nach dem Auftreten zu behandeln. Die Behandlung von Ausnahmen kann die Wartbarkeit und Lesbarkeit Ihres Codes erschweren und gelegentlich sogar zu neuen Problemen führen. NullReferenceExceptions sind oftmals nicht behebbare Fehler. In diesen Fällen macht es oft Sinn, wenn die Ausnahme die Anwendung beenden kann.

Oft ist es jedoch auch möglich, den Fehler auf sinnvolle Art zu behandeln.

• Ihre Anwendung kann Objekte ignorieren, die null sind. Wenn Ihre Anwendung Einträge in einer Datenbank abruft und verarbeitet, können Sie z. B. ungültige Einträge ignorieren, die zu Nullobjekten führen. Möglicherweise reicht es aus, die ungültigen Daten in einer Protokolldatei oder der Anwendungs-GUI aufzuzeichnen.

• Sie können nach einer Ausnahme fortfahren. Ein Aufruf eines Webdiensts, der einen Verweistyp zurückgibt, kann z. B. NULL zurückgeben, wenn die Verbindung verloren geht oder ein Timeout der Verbindung ausfällt. Sie können versuchen, die Verbindung wiederherzustellen, und den Anruf erneut versuchen.

• Sie können Ihre Anwendung zurück in einen gültigen Status versetzen. Wenn Sie z. B. eine Aufgabe mit mehreren Schritten ausführen, die Informationen in einem Datenspeicher ablegen muss, bevor eine Methode aufgerufen wird, die eine NullReferenceException zurückgibt. Wenn das nicht initialisierte Objekt den Datensatz ungültig machen würde, können Sie z. B. die vorherigen Daten entfernen, bevor Sie die Anwendung schließen.

• Sie möchten die Ausnahme melden. Wenn der Fehler beispielsweise durch einen Fehler des Benutzers Ihrer App verursacht wurde, können Sie eine Nachricht generieren, die ihnen hilft, die richtigen Informationen zur Verfügung zu stellen. Außerdem können Sie Informationen über den Fehler protokollieren, um bei der Korrektur des Problems zu helfen. Einige Frameworks, wie ASP.NET, verfügen über einen hohen Ausnahmehandler, der alle Fehler aufzeichnet, damit die Anwendung nie abstürzt. In diesem Fall kann die Protokollierung der Ausnahme möglicherweise die einzige Möglichkeit sein, damit Sie wissen, dass sie auftritt.

Konstruktoren

NullReferenceException()	Initialisiert einen neuen instance der NullReferenceException -Klasse und legt die Message Eigenschaft des neuen instance auf eine vom System bereitgestellte Meldung fest, die den Fehler beschreibt, z. B. "Der Wert 'null' wurde gefunden, wenn ein instance eines Objekts erforderlich war." Diese Nachricht berücksichtigt die aktuelle Systemkultur.
NullReferenceException(SerializationInfo, StreamingContext)	Veraltet. Initialisiert eine neue Instanz der NullReferenceException-Klasse mit serialisierten Daten.
NullReferenceException(String)	Initialisiert eine neue Instanz der NullReferenceException-Klasse mit einer angegebenen Fehlermeldung.
NullReferenceException(String, Exception)	Initialisiert eine neue Instanz der NullReferenceException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

Eigenschaften

Data	Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen. (Geerbt von Exception)
HelpLink	Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest. (Geerbt von Exception)
HResult	Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist. (Geerbt von Exception)
InnerException	Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat. (Geerbt von Exception)
Message	Ruft eine Meldung ab, mit der die aktuelle Ausnahme beschrieben wird. (Geerbt von Exception)
Source	Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest. (Geerbt von Exception)
StackTrace	Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab. (Geerbt von Exception)
TargetSite	Ruft die Methode ab, die die aktuelle Ausnahme auslöst. (Geerbt von Exception)

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetBaseException()	Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist. (Geerbt von Exception)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)	Veraltet. Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest. (Geerbt von Exception)
GetType()	Ruft den Laufzeittyp der aktuellen Instanz ab. (Geerbt von Exception)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück. (Geerbt von Exception)

Ereignisse

SerializeObjectState

Veraltet. Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen. (Geerbt von Exception)

Gilt für:

Weitere Informationen

• Exception
• Behandeln und Auslösen von Ausnahmen