Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

NullReferenceException-Klasse

 

Veröffentlicht: Oktober 2016

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

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Exception
    System.SystemException
      System.NullReferenceException

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class NullReferenceException : SystemException

NameBeschreibung
System_CAPS_pubmethodNullReferenceException()

Initialisiert eine neue Instanz der dem NullReferenceException Klasse, indem die Message -Eigenschaft der neuen Instanz mit einer vom System gelieferten Meldung, die den Fehler beschreibt, wie z. B. "der Wert 'Null' gefunden wurde, in dem eine Instanz eines Objekts erforderlich war." Diese Meldung berücksichtigt die aktuelle Systemkultur.

System_CAPS_protmethodNullReferenceException(SerializationInfo, StreamingContext)

Initialisiert eine neue Instanz der NullReferenceException-Klasse mit serialisierten Daten.

System_CAPS_pubmethodNullReferenceException(String)

Initialisiert eine neue Instanz der NullReferenceException-Klasse mit einer angegebenen Fehlermeldung.

System_CAPS_pubmethodNullReferenceException(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.

NameBeschreibung
System_CAPS_pubpropertyData

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen über die Ausnahme bereitstellen.(Geerbt von „Exception“.)

System_CAPS_pubpropertyHelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.(Geerbt von „Exception“.)

System_CAPS_pubpropertyHResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.(Geerbt von „Exception“.)

System_CAPS_pubpropertyInnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.(Geerbt von „Exception“.)

System_CAPS_pubpropertyMessage

Ruft eine Meldung ab, die die aktuelle Ausnahme beschreibt.(Geerbt von „Exception“.)

System_CAPS_pubpropertySource

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.(Geerbt von „Exception“.)

System_CAPS_pubpropertyStackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.(Geerbt von „Exception“.)

System_CAPS_pubpropertyTargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.(Geerbt von „Exception“.)

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodGetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die ursprüngliche Ursache für eine oder mehrere nachfolgende Ausnahmen ist.(Geerbt von „Exception“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest.(Geerbt von „Exception“.)

System_CAPS_pubmethodGetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.(Geerbt von „Exception“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.(Geerbt von „Exception“.)

NameBeschreibung
System_CAPS_proteventSerializeObjectState

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt zu erstellen, das serialisierte Daten für die Ausnahme enthält.(Geerbt von „Exception“.)

Ein NullReferenceException Ausnahme wird ausgelöst, wenn Sie versuchen, einen Member für einen Typ zuzugreifen, dessen Wert null. Ein NullReferenceException Ausnahme in der Regel Entwickler Fehler wiedergibt, und wird ausgelöst, in den folgenden Szenarien:

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

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

    Bei einigen Compilern wird eine Warnung ausgegeben, wenn sie diesen Code kompilieren. Andere Fehler, und die Kompilierung schlägt fehl. Um dieses Problem zu beheben, instanziieren Sie das Objekt so, dass der Wert nicht mehr null. Im folgenden Beispiel wird dies durch den Konstruktor eines Typs Klasse aufrufen.

    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 dimensionieren, bevor es zu initialisieren. Im folgenden Beispiel values wird deklariert, um ein Array von Ganzzahlen sein, aber die Anzahl der Elemente, die es enthält nie angegeben wird. Der Versuch, das seine Werte aus diesem Grund ausgelöst Initialisieren einer NullReferenceException Ausnahme.

    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 vermeiden, indem Sie vor dem initialisieren, die Anzahl der Elemente im Array deklarieren, wie im folgenden Beispiel wird der Fall ist.

    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 (C#-Programmierhandbuch) und Arrays in Visual Basic.

  • Sie erhalten eine null Rückgabewert aus einer Methode, und rufen Sie eine Methode für den zurückgegebenen Typ. Dies ist manchmal das Ergebnis ein Fehler in der Dokumentation. die Dokumentation ein Fehler auftritt, beachten Sie, dass ein Methodenaufruf zurückgegeben werden kann null. In anderen Fällen Codes fälschlicherweise wird davon ausgegangen, dass die Methode immer einen nicht-zurückgebennull Wert.

    Der Code im folgenden Beispiel wird vorausgesetzt, dass die Array.Find<T> immer Methodenrückgabe Person Objekt, dessen FirstName Feld mit eine Suchzeichenfolge übereinstimmt. Da keine Übereinstimmung vorhanden ist, löst die Laufzeit eine NullReferenceException Ausnahme.

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

    Testen Sie zur Behebung dieses Problems den Rückgabewert der Methode, um sicherzustellen, dass es nicht null vor dem Aufrufen einer seiner Elemente, wie im folgenden Beispiel wird der Fall ist.

    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
    
  • Verwenden Sie einen Ausdruck (z. B. Sie verketten eine Liste von Methoden oder Eigenschaften zusammen) zum Abrufen eines Werts, und obwohl Sie einchecken möchten, ob der Wert null, noch löst die Laufzeit eine NullReferenceException Ausnahme. Dies geschieht, weil einer der zwischengeschalteten Werte im Ausdruck gibt null. Als Ergebnis der Rest für null niemals ausgewertet.

    Das folgende Beispiel definiert eine Pages -Objekt, das Informationen zu Webseiten, speichert die vom dargestellt werden Page Objekte. Die Example.Main Methode überprüft, ob der aktuellen Webseite einen Titel ungleich Null ist, und wenn dies der Fall ist, der Titel wird. Trotz dieser Prüfung jedoch die Methode löst eine NullReferenceException Ausnahme.

    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, weil pages.CurrentPage gibt null , wenn keine Seiteninformationen im Cache gespeichert ist. Diese Ausnahme kann behoben werden, durch Testen den Wert der CurrentPage Eigenschaft vor dem Abrufen des aktuellen Page des Objekts Title -Eigenschaft, wie im folgenden Beispiel wird:

    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 sind beim Aufzählen der Elemente eines Arrays, die Verweistypen, und Sie versucht haben, eines der Elemente löst, Prozess enthält einen NullReferenceException Ausnahme.

    Das folgende Beispiel definiert ein Array von Zeichenfolgen. Ein for Anweisung listet die Elemente im Array und ruft jede Zeichenfolge Trim Methode vor der Anzeige der Zeichenfolge.

    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 muss einen Wert ungleich Null enthalten, und der Wert des Arrayelements in der Tat ist null. Die Ausnahme testen, ob das Element entfernt null bevor ein Vorgang für dieses Element durchgeführt wird, wie im folgenden Beispiel dargestellt.

    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
    
  • Ein NullReferenceException -Ausnahme wird ausgelöst durch eine Methode, die übergeben wird null. Einige Methoden überprüft die Argumente, die an sie übergeben werden. Wenn sie keine und eines der Argumente ist null, löst die Methode eine System.ArgumentNullException Ausnahme. Löst andernfalls eine NullReferenceException Ausnahme. Im folgende Beispiel wird dieses Szenario veranschaulicht.

    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 kein ist null, oder behandeln die ausgelöste Ausnahme in einem try…catch…finally Block. Weitere Informationen finden Sie unter Behandeln und Auslösen von Ausnahmen.

The following Microsoft intermediate language (MSIL) instructions throw NullReferenceException: callvirt, cpblk, cpobj, initblk, ldelem.<type>, ldelema, ldfld, ldflda, ldind.<type>, ldlen, stelem.<type>, stfld, stind.<type>, throw, and unbox.

NullReferenceExceptionverwendet HRESULT COR_E_NULLREFERENCE mit den Wert 0 x 80004003.

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

Behandlung von NullReferenceExceptions im Releaseversionscode

Es ist in der Regel besser, NullReferenceExceptions zu vermeiden, als für die Verarbeitungsoption dahinter auftritt. 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. Aufrufe an einen Webdienst, der einen Verweistyp zurückgibt, können z. B. null zurückgeben, wenn die Verbindung unterbrochen wird oder eine Zeitüberschreitung auftritt. Sie können versuchen, die Verbindung erneut herzustellen oder den Aufruf zu wiederholen.

  • 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 z. B. von einem Benutzer Ihrer Anwendung verursacht wurde, möchten Sie möglicherweise eine Nachricht generieren, um den Benutzer bei der Angabe der korrekten Informationen zu unterstützen. 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.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: