Problembehandlung bei Ausnahmen: System.NullReferenceException

Eine NullReferenceException tritt auf, wenn Sie versuchen, eine Methode oder Eigenschaft eines Verweistyps (C#, Visual Basic) zu verwenden, deren Wert null ist. Möglicherweise haben Sie versucht, ein Objekt zu verwenden, ohne zunächst das Schlüsselwort new (New in Visual Basic) zu verwenden, oder der Wert des Objekts war null (Nothing in Visual Basic).

Abschnitte in diesem Artikel

In diesem Artikel verwendete Klassen

Häufige Ursachen für NullReferenceExceptions

Suche nach der Quelle für NullReferenceExceptions während der Entwicklung

Vermeiden von NullReferenceExceptions

Behandlung von NullReferenceExceptions im Releaseversionscode

In diesem Artikel verwendete Klassen

Die meisten Beispiele in diesem Artikel verwenden eine oder beide der folgenden Klassen:

public class Automobile
{
    public EngineInfo Engine {get; set;}
}

public class EngineInfo
{
    public EngineInfo() { }

    public EngineInfo(string powerSrc, double engineSize)
    {
        Power = powerSrc;
        Size = engineSize;
    }

    public double Size { get; set; }
    public string Power = null;
}
   

Public Class Automobile
    Public Property Engine As EngineInfo
End Class

Public Class EngineInfo
    Public Sub New()
    End Sub

    Public Sub New(powerSrc As String, engineSize As Double)
        Power = powerSrc
        Size = engineSize
    End Sub

    Public Property Size() As Double
    Public Power As String = Nothing
End Class

Andere Abschnitte in diesem Artikel

Häufige Ursachen für NullReferenceExceptions

Jede Verweistyp-Variable kann null sein. Lokale Variablen, Eigenschaften von Klassen, Methodenparameter und Methodenrückgabewerte können Nullverweise enthalten. Beim Aufrufen von Methoden oder Eigenschaften dieser Variablen mit Nullwert wird eine NullReferenceException geworfen. Sonderfälle:

Eine lokale Variable oder ein Member-Feld ist deklariert, jedoch nicht initialisiert

Eine Eigenschaft oder ein Feld ist null

Ein Methodenparameter ist null

Der Rückgabewert einer Methode ist null

Ein Objekt in einer Sammlung oder einem Array ist null

Ein Objekt wird aufgrund einer Bedingung nicht erstellt

Ein nach Verweis an eine Methode übergebenes Objekt ist null

Eine lokale Variable oder ein Member-Feld ist deklariert, jedoch nicht initialisiert

Dieser einfache Fehler tritt am Häufigsten in Visual Basic-Code auf. Mit der Ausnahme einer Variablendeklaration, die als Ausgabeparameter verwendet wird, erlaubt der C#-Compiler keine Verwendung einer lokalen Verweisvariable, wenn diese nicht initialisiert wurde. Der VB-Compiler generiert eine Warnung.

• Im folgenden C#-Code generiert die hervorgehobene Zeile diesen Compilerfehler:

Verwendung der nicht zugewiesenen lokalen Variablen 'Modul'

• Im Visual Basic Code generiert die hervorgehobene Zeile die Compilerwarnung BC42104:

Die Variable wird verwendet, bevor ihr ein Wert zugewiesen wird.  Zur Laufzeit kann eine null-Verweisausnahme auftreten.

Und die Zeile wirft bei der Ausführung eine NullReferenceException.

public void NullReferencFromUninitializedLocalVariable()
{
    EngineInfo engine;
    Console.WriteLine(engine.ToString());
}

Public Sub NullReferencFromUninitializedLocalVariable()
    Dim engine As EngineInfo
    Console.WriteLine(engine.ToString())
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Eine Eigenschaft oder ein Feld ist null

Die Felder und Eigenschaften einer Klasse werden bei der Erstellung der Klasse automatisch mit deren Standardwert initialisiert. Der Standardwert eines Verweistyps ist null (Nothing in Visual Basic). Beim Aufrufen von Membermethoden auf ein Feld oder eine Eigenschaft einer übergeordneten Klasse wird eine NullReferenceException geworfen, wenn das Feld bzw. die Eigenschaft null ist.

In diesem Beispiel wirft die hervorgehobene Zeile eine NullReferenceException, da die Engine-Eigenschaft von car automatisch auf null initialisiert wird.

public void NullReferenceFromProperty()
{
    var car = new Automobile();

    Console.WriteLine(car.Engine.ToString());
}

Public Sub NullReferenceFromProperty()
    Dim car = New Automobile()
    Console.WriteLine(car.Engine.ToString())
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Ein Methodenparameter ist null

Ein Methodenparameter, der ein Verweistyp ist, kann null (Nothing in Visual Basic) sein. Beim Aufrufen von Membermethoden oder Eigenschaften auf einen Parameterwert wird eine NullReferenceException geworfen, wenn dieser Wert null ist.

In diesem Beispiel wirft die hervorgehobene Zeile eine NullReferenceException, da BadEngineInfoPassedToMethod NullReferenceFromMethodParameter mit einem Parameter aufruft, der null ist.

public void BadEngineInfoPassedToMethod()
{
    EngineInfo eng = null;
    NullReferenceFromMethodParameter(eng);
}

public void NullReferenceFromMethodParameter(EngineInfo engine)
{
    Console.WriteLine(engine.ToString());
}

Public Sub BadParameterPassedToMethod() As EngineInfo
    Dim eng As EngineInfo = Nothing
    NullReferenceFromMethodParameter(eng)
End Sub

Public Sub NullReferenceFromMethodParameter(engine As EngineInfo)
    Console.WriteLine(engine.ToString())
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Der Rückgabewert einer Methode ist null

Eine Methode, die einen Verweistyp zurückgibt, kann null (Nothing in Visual Basic) zurückgeben. Beim Aufrufen von Methoden oder Eigenschaften des zurückgegebenen Verweistyps wird eine NullReferenceException geworfen, wenn der Verweis null ist.

In diesem Beispiel wirft die hervorgehobene Zeile eine NullReferenceException, da der Aufruf von BadGetEngineInfo einen Nullverweis in der NullReferenceFromMethodParameter-Methode zurückgibt.

public EngineInfo BadGetEngineInfo()
{
    EngineInfo engine = null;
    return engine;
}

public void NullReferenceFromMethodReturnValue()
{
    var engine = BadGetEngineInfo();
    Console.WriteLine(engine.ToString());
}

Public Function BadGetEngineInfo() As EngineInfo
    Dim engine As EngineInfo = Nothing
    Return engine
End Function

Public Sub NullReferenceFromMethodReturnValue()
    Dim engine = BadGetEngineInfo()
    Console.WriteLine(engine.ToString())
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Ein Objekt in einer Sammlung oder einem Array ist null

Eine Liste oder ein Array von Verweistypen kann ein Element enthalten, das null ist. Beim Aufrufen von Methoden oder Eigenschaften auf ein Listenelement wird eine NullReferenceException geworfen, wenn dieses Element null ist.

In diesem Beispiel wirft die hervorgehobene Zeile in NullReferenceFromListItem() eine NullReferenceException, da der Aufruf an BadGetCarList ein Element zurückgibt, das null ist.

public Automobile[] BadGetCarList()
{
    var autos = new Automobile[10];
    for (int i = 0; i autos.Length; i++)
    {
        if (i != 6)
        {
            autos[i] = new Automobile();
        }
    }
    return autos;
}

public void NullReferenceFromListItem()
{
    var cars = BadGetCarList();
    foreach (Automobile car in cars)
    {
        Console.WriteLine(car.ToString());
    }
}

Public Function BadGetCarList() As Automobile()
    Dim autos = New Automobile(10) {}
    For i As Integer = 0 To 9
        If i <> 6 Then
            autos(i) = New Automobile()
        End If
    Next
    Return autos
End Function

Public Sub NullReferenceFromListItem()
    Dim cars = BadGetCarList()
    For Each car As Automobile In cars
        Console.WriteLine(car.ToString())
    Next
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Ein Objekt wird aufgrund einer Bedingung nicht erstellt

Wenn ein Verweistyp in einem bedingten Block initialisiert wird, kann es passieren, dass das Objekt nicht erstellt wird, wenn die Bedingung nicht erfüllt ist.

In diesem Beispiel wirft die hervorgehobene Zeile in NullReferenceFromConditionalCreation eine NullReferenceException, da die engine-Variable nur initialisiert wird, wenn die DetermineTheCondition()-Methode den Wert true zurückgibt.

 public bool DetermineTheCondition()
{
    return false;
}

public void NullReferenceFromConditionalCreation()
{
    EngineInfo engine = null;
    var condition = DetermineTheCondition();
    if (condition)
    {
        engine = new EngineInfo();
        engine.Power = "Diesel";
        engine.Size = 2.4;
    }
    Console.WriteLine(engine.Size);
}

Public Function DetermineTheCondition() As Boolean
    Return False
End Function

Public Sub NullReferenceFromConditionalCreation()
    Dim engine As EngineInfo = Nothing
    Dim condition = DetermineTheCondition()
    If condition Then
        engine = New EngineInfo()
        engine.Power = "Diesel"
        engine.Size = 2.4
    End If
    Console.WriteLine(engine.Size)
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Die Eigenschaft eines an eine Methode übergebenen Objekts ist null

Wenn Sie ein Objekt nach Wert als Parameter an eine Methode übergeben (ohne die Schlüsselwörter ref bzw. out in C# oder das Schlüsselwort ByRef in Visual Basic), kann die Methode den Speicherort des Parameters (auf den der Parameter zeigt) nicht ändern. Sie kann jedoch die Eigenschaften des Objekts ändern.

In diesem Beispiel erstellt dieNullPropertyReferenceFromPassToMethod-Methode ein Automobile -Objekt und initialisiert die Engine-Eigenschaft. Anschließend wird BadSwapCarEngine aufgerufen und das neue Objekt als Parameter übergeben. BadSwapCarEngine setzt die Engine-Eigenschaft auf null. Dadurch wirft die hervorgehobene Zeile in NullPropertyReferenceFromPassToMethod eine NullReferenceException.

public void BadSwapCarEngine(Automobile car)
{
    car.Engine = null;
}

public void (Automobile car)
{
    car.Engine = new EngineInfo("GAS", 1.5);
    BadSwapCarEngine(car);
    Console.WriteLine(car.Engine.ToString());
}

Public Sub BadSwapCarEngine(car As Automobile)
    car.Engine = Nothing
End Sub

Public Sub NullPropertyReferenceFromPassToMethod()
    Dim car As New Automobile()
    car.Engine = New EngineInfo("GAS", 1.5)
    BadSwapCarEngine(car)
    Console.WriteLine(car.Engine.ToString())
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Ein nach Verweis an eine Methode übergebenes Objekt ist null

Wenn Sie ein Objekt nach Verweis als Parameter an eine Methode übergeben (mit dem Schlüsselwort ref bzw. out in C# oder das Schlüsselwort ByRef in Visual Basic), können Sie den Speicherort ändern, auf den der Parameter zeigt.

Wenn Sie einen Verweistyp nach Verweis an eine Methode übergeben, kann die Methode den Verweistyp zu null (Nothing in Visual Basic) ändern.

In diesem Beispiel wirft die hervorgehobene Zeile in NullReferenceFromPassToMethodByRef eine NullReferenceException, da der Aufruf an die BadEngineSwapByRef-Methode die stockEngine-Variable auf null setzt.

public void BadEngineSwapByRef(ref EngineInfo engine)
{
    engine = null;
}

public void NullReferenceFromPassToMethodByRef()
{
    var stockEngine = new EngineInfo();
    stockEngine.Power = "Gas";
    stockEngine.Size = 7.0;
    BadSwapEngineByRef(ref stockEngine);
    Console.WriteLine(stockEngine.ToString());
}

Public Sub BadSwapEngineByRef(ByRef engine As EngineInfo)
    engine = Nothing
End Sub

Public Sub NullReferenceFromPassToMethodByRef()
    Dim formatStr = "The stock engine has been replaced by a {0} liter {} engine"
    Dim stockEngine = New EngineInfo()
    stockEngine.Power = "Gas"
    stockEngine.Size = 7.0
    BadSwapEngineByRef(stockEngine)
    Console.WriteLine(stockEngine.ToString())
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Ermitteln der Ursache einer NullReferenceException bei der Entwicklung

Verwenden Sie Datentipps, das Lokalfenster und die Überwachungsfenster, um die Variablenwerte anzuzeigen

Durchlaufen Sie die Aufrufliste, um herauszufinden, an welcher Stelle eine Verweisvariable nicht initialisiert oder auf null gesetzt wird

Erstellen bedingter Haltepunkte, um das Debuggen zu unterbrechen, wenn ein Objekt null (Nothing in Visual Basic) ist

Verwenden Sie Datentipps, das Lokalfenster und die Überwachungsfenster, um die Variablenwerte anzuzeigen

• Zeigen Sie mit der Maus auf die Variablennamen, um deren Werte in einem Datentipp anzuzeigen. Wenn die Variable auf ein Objekt oder eine Sammlung verweist, können Sie den Datentyp erweitern, um dessen Eigenschaften oder Elemente zu prüfen.

• Öffnen Sie das Fenster Lokal, um alle im aktuellen Kontext aktiven Variablen anzuzeigen.

• Mit dem Überwachungsfenster können Sie die Änderungen von Variablenwerten überwachen, während Sie den Code durchlaufen.

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Durchlaufen Sie die Aufrufliste, um herauszufinden, an welcher Stelle eine Verweisvariable nicht initialisiert oder auf null gesetzt wird

Das Aufruflistenfenster in Visual Studio enthält eine Liste mit den Namen der Methoden, die nicht abgeschlossen wurden, wenn der Debugger bei einer Ausnahme oder einem Haltepunkt anhält. Sie können einen Namen im Fenster Anrufliste und Zu Rahmen wechseln auswählen, um den Ausführungskontext zur entsprechenden Methode zu wechseln und deren Variablen zu untersuchen.

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Erstellen bedingter Haltepunkte, um das Debuggen zu unterbrechen, wenn ein Objekt null (Nothing in Visual Basic) ist

Sie können einen bedingten Haltepunkt erstellen, um die Ausführung zu unterbrechen, wenn eine Variable null ist. Bedingte Haltepunkte sind hilfreich, wenn der Nullverweis nur selten auftritt, z. B. wenn ein Element in einer Sammlung nur gelegentlich null ist. Bedingte Haltepunkte haben außerdem den Vorteil, dass Sie mit deren Hilfe ein Problem debuggen können, bevor Sie sich für eine bestimmte Behandlungsroutine entscheiden.

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Vermeiden von NullReferenceExceptions

Bestätigen von Invarianten mit Debug.Assert

Vollständiges Initialisieren von Verweistypen

Bestätigen von Invarianten mit Debug.Assert

Eine Invariante ist eine Bedingung, bei der Sie sicher sind, dass diese wahr ist. Debug.Assert (System.Diagnostics)-Anweisungen werden nur in Debug-Builds Ihrer Anwendungen aufgerufen und nicht im Releaseversionscode. Wenn die invariante Bedingung nicht wahr ist, hält der Debugger bei der Assert-Anweisung an und zeigt ein Dialogfeld an. Debug.Assert ermöglicht eine Prüfung, dass sich eine Bedingung bei der Entwicklung der Anwendung nicht geändert hat. Eine Assertion dokumentiert auch für andere, die Ihren Code lesen, dass die Bedingung immer erfüllt sein muss.

Die MakeEngineFaster-Methode nimmt z. B. an, dass der engine-Parameter niemals null ist, da deren einzige aufrufende Methode (TheOnlyCallerOfMakeEngineFaster) die EngineInfobekannterweise komplett initialisiert. Die Assertion in MakeEngineFaster dokumentiert diese Annahme und prüft zugleich, ob diese erfüllt ist.

Wenn jemand eine neue aufrufende Methode hinzufügt (BadNewCallerOfMakeEngineFaster), die den Parameter nicht initialisiert, wird die Annahme ausgelöst.

private void TheOnlyCallerOfMakeEngineFaster()
{
    var engine = new EngineInfo();
    engine.Power = "GAS";
    engine.Size = 1.5;
    MakeEngineFaster(engine);
}

private void MakeEngineFaster(EngineInfo engine)
{
    System.Diagnostics.Debug.Assert(engine != null, "Assert: engine != null");
    engine.Size *= 2;
    Console.WriteLine("The engine is twice as fast");
}

private void BadNewCallerOfMakeEngineFaster()
{
    EngineInfo engine = null;
    MakeEngineFaster(engine);
}

Public Sub TheOnlyCallerOfMakeEngineFaster()
    Dim engine As New EngineInfo
    engine.Power = "GAS"
    engine.Size = 1.5
    MakeEngineFaster(engine)
End Sub

Private Sub MakeEngineFaster(engine As EngineInfo)
    System.Diagnostics.Debug.Assert(engine IsNot Nothing, "Assert: engine IsNot Nothing")
    engine.Size = engine.Size * 2
    Console.WriteLine("The engine is twice as fast")
End Sub

Public Sub BadNewCallerOfMakeEngineFaster()
    Dim engine As EngineInfo = Nothing
    MakeEngineFaster(engine)
End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Vollständiges Initialisieren von Verweistypen

Sie sollten Verweistypen so nahe wie möglich an deren Erstellung vollständig initialisieren, um viele NullReferenceExceptions zu vermeiden.

Vollständige Initialisierung in Ihren eigenen Klassen

Wenn Sie die Klasse kontrollieren, die eine NullReferenceException wirft, sollten Sie das Objekt im Typkonstruktor vollständig initialisieren. Hier ist z. B. eine überarbeitete Version der Beispielklassen mit garantierter vollständiger Initialisierung:

public class Automobile
{
    public EngineInfo Engine { get; set; }

    public Automobile() 
    { 
        this.Engine = new EngineInfo(); 
    }

    public Automobile(string powerSrc, double engineSize)
    {
        this.Engine = new EngineInfo(powerSrc, engineSize);
    }
}


public class EngineInfo
{
    public double Size {get; set;}
    public string Power {get; set;}

    public EngineInfo() 
    { 
        // the base engine 
        this.Power = "GAS"; 
        this.Size = 1.5; 
    }

    public EngineInfo(string powerSrc, double engineSize)
    {
        this.Power = powerSrc;
        this.Size = engineSize;
    }
}

Public Class Automobile
    Public Property Engine As EngineInfo

    Public Sub New() 
        Me.Engine = New EngineInfo() 
    End Sub 

    Public Sub New(powerSrc As String, engineSize As Double) 
        Me.Engine = New EngineInfo(powerSrc, engineSize) 
    End Sub

End Class

Public Class BaseEngineInfo
    Public Sub New() 
        ' the base engine 
        Me.Power = "GAS" 
        Me.Size = 1.5 
    End Sub

    Public Sub New(powerSrc As String, engineSize As Double)
        Power = powerSrc
        Size = engineSize
    End Sub

    Public Property Size() As Double
    Public Power As String = String.Empty
End Class

Hinweis

Verzögerte Initialisierung für große oder selten verwendete Eigenschaften

Um die Speicherverwendung Ihrer Klassen zu senken und deren Leistung zu verbessern, können Sie Eigenschaften mit Verweistypen verzögert initialisieren.Siehe Verzögerte Initialisierung.

Behandlung von NullReferenceExceptions im Releaseversionscode

Prüfen auf null (Nothing in Visual Basic) vor dem Verwenden von Verweistypen

Verwenden von try – catch – finally (Try – Catch – Finally in Visual Basic) zur Behandlung von Ausnahmen

Es ist immer besser, NullReferenceExceptions zu vermeiden, anstatt diese 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. 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.

Hier sehen Sie zwei Möglichkeiten für die Behandlung von NullReferenceExceptions im Releaseversionscode.

Prüfen auf null (Nothing in Visual Basic) vor dem Verwenden von Verweistypen

Sie können ein Objekt vor der Verwendung explizit auf null testen, um die Leistungseinbuße von try-catch-finally-Blöcken zu vermeiden. Sie müssen jedoch trotzdem entscheiden und implementieren, was im Fall eines nicht initialisierten Objekts geschehen soll.

In diesem Beispiel die CheckForNullReferenceFromMethodReturnValue prüft den Rückgabewert der BadGetEngineInfo Methode. Wenn das Objekt nicht null ist, wird es verwendet; andernfalls meldet die Methode einen Fehler.

public EngineInfo BadGetEngineInfo()
{
    EngineInfo engine = null;
    return engine;
}

public void CheckForNullReferenceFromMethodReturnValue()
{
    var engine = BadGetEngineInfo();
    if(engine != null)
    {
        // modify the info
        engine.Power = "DIESEL";
        engine.Size = 2.4;
    }
    else
    {
        // report the error
        Console.WriteLine("BadGetEngine returned null")
    }
}

public EngineInfo BadGetEngineInfo()
{
    EngineInfo engine = null;
    return engine;
}
Public Sub CheckForNullReferenceFromMethodReturnValue()
    Dim engine = BadGetEngineInfo()
    If (engine IsNot Nothing) Then
        ' modify the info
        engine.Power = "DIESEL"
        engine.Size = 2.4
    Else
        ' report the error
        Console.WriteLine("BadGetEngineInfo returned Nothing")
    End If

End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Verwenden von try – catch – finally (Try – Catch – Finally in Visual Basic) zur Behandlung von Ausnahmen

Die integrierten Konstrukte für die Ausnahmebehandlung (try, catch, finally in C#, Try, Catch, Finally in Visual Basic) bieten weitere Optionen für den Umgang mit NullReferenceExceptions neben der Prüfung, ob ein Objekt nicht null ist.

In diesem Beispiel verwendet CatchNullReferenceFromMethodCall zwei Assertions, um die Annahme zu bestätigen, dass der Parameter ein komplettes Automobil inklusive Motor enthält. Im try-Block wirft die hervorgehobene Zeile eine NullReferenceException, da der Aufruf an RarelyBadEngineSwapdie Engine-Eigenschaft des Autos zerstören kann. Der catch-Block fängt die Ausnahme ab, schreibt deren Informationen in eine Datei und meldet den Fehler an den Benutzer. Im finally-Block stellt die Methode sicher, dass der Status des Autos nicht schlechter ist als beim Methodeneintritt.

public void RarelyBadSwapCarEngine(Automobile car)
{
    if ((new Random()).Next() == 42)
    {
        car.Engine = null;
    }
    else
    {
        car.Engine = new EngineInfo("DIESEL", 2.4);
    }
}

public void CatchNullReferenceFromMethodCall(Automobile car)
{
    System.Diagnostics.Debug.Assert(car != null, "Assert: car != null");
    System.Diagnostics.Debug.Assert(car.Engine != null, "Assert: car.Engine != null");

    // save current engine properties in case they're needed
    var enginePowerBefore = car.Engine.Power;
    var engineSizeBefore = car.Engine.Size;

    try
    {
        RarelyBadSwapCarEngine(car);
        var msg = "Swap succeeded. New engine power source: {0} size {1}";
        Console.WriteLine(msg, car.Engine.Power, car.Engine.Size);
    }
    catch(NullReferenceException nullRefEx)
    {
        // write exception info to log file
        LogException(nullRefEx);
        // notify the user
        Console.WriteLine("Engine swap failed. Please call your customer rep.");
    }
    finally
    {
        if(car.Engine == null)
        {
            car.Engine = new EngineInfo(enginePowerBefore, engineSizeBefore);
        }
    }
}

Public Sub RarelyBadSwapCarEngine(car As Automobile)
    If (New Random()).Next = 42 Then
        car.Engine = Nothing
    Else
        car.Engine = New EngineInfo("DIESEL", 2.4)
    End If
End Sub

Public Sub CatchNullReferenceFromMethodCall(car As Automobile)
    System.Diagnostics.Debug.Assert(car IsNot Nothing)
    System.Diagnostics.Debug.Assert(car.Engine IsNot Nothing)

    ' save current engine properties in case they're needed
    Dim powerBefore = car.Engine.Power
    Dim sizeBefore = car.Engine.Size

    Try
        RarelyBadSwapCarEngine(car)
        Dim msg = "Swap succeeded. New engine power source: {0} size {1}"
        Console.WriteLine(msg, car.Engine.Power, car.Engine.Size)
    Catch nullRefEx As NullReferenceException
        ' write exception info to log file
        LogException(nullRefEx)
        ' notify user
        Console.WriteLine("Engine swap failed. Please call your customer rep.")
    Finally
        If car.Engine Is Nothing Then car.Engine = New EngineInfo(powerBefore, sizeBefore)
    End Try

End Sub

Einträge in diesem Abschnitt

Abschnitte in diesem Artikel

Verwandte Artikel

Entwurfsrichtlinien für Ausnahmen (.NET Framework-Entwurfsrichtlinien)

Behandeln und Auslösen von Ausnahmen (.NET Framework-Anwendungsgrundlagen)

Vorgehensweise:Empfangen von Ausnahmebenachrichtigungen (.NET Framework-Entwicklungsleitfaden)

Vorgehewnsweise:Behandeln von Ausnahmen in einer PLINQ-Abfrage (.NET Framework-Entwicklungsleitfaden)

Ausnahmen in verwalteten Threads (.NET Framework-Entwicklungsleitfaden)

Ausnahmen und Ausnahmebehandlung (C#-Programmierhandbuch)

Ausnahmebehandlungsanweisungen (C#-Referenz)

Try...Catch...Finally-Anweisung (Visual Basic)

Ausnahmebehandlung (F#)

Ausnahmen in C++/CLI

Ausnahmebehandlung (Task Parallel Library)

Ausnahmebehandlung (Debugging)

Exemplare Vorgehensweise: Behandeln einer Parallelitätsausnahme (Datenzugriff in Visual Studio)

Vorgehensweise: Behandeln von Fehlern und Ausnahmen in Zusammenhang mit der Datenbindung (Windows Forms)

Behandeln von Ausnahmen in Netzwerk-Apps (XAML) (Windows)

Abschnitte in diesem Artikel