NullReferenceException Třída

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Zdroj:: NullReferenceException.cs

Zdroj:: NullReferenceException.cs

Zdroj:: NullReferenceException.cs

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Výjimka, která je vyvolán při pokusu o přesferencování null odkaz na objekt.

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

Dědičnost: Object

Exception
NullReferenceException

Dědičnost: Object

Exception

SystemException
NullReferenceException

Atributy: SerializableAttribute ComVisibleAttribute

Poznámky

Při NullReferenceException pokusu o přístup k členu typu, jehož hodnota je null, vyvolá se výjimka. Výjimka NullReferenceException obvykle odráží chybu vývojáře a vyvolá se v následujících scénářích:

Zapomněli jste vytvořit instanci typu odkazu. V následujícím příkladu je deklarován, names ale nikdy se nevyužila instance:

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

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

Některé kompilátory při kompilaci tohoto kódu vydávají upozornění. Jiné vyhlásí chybu a kompilace se nezdaří. Chcete-li tento problém vyřešit, vytvořte instanci objektu tak, aby jeho hodnota již nullnebyla . Následující příklad to provede voláním konstruktoru třídy typu.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      List<String> names = new List<String>();
      names.Add("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

Před inicializací pole jste zapomněli kótovat. V následujícím příkladu values je deklarován jako celočíselné pole, ale počet prvků, které obsahuje, není nikdy zadán. Pokus o inicializaci svých hodnot proto vyvolal NullReferenceException výjimku.

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

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

Výjimku můžete eliminovat deklarací počtu prvků v poli před jeho inicializací, jak je tomu v následujícím příkladu.

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

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

Další informace o deklarování a inicializaci polí najdete v tématu Pole a pole.

Z metody získáte návratovou hodnotu null a pak zavoláte metodu pro vrácený typ. To je někdy výsledkem chyby dokumentace; v dokumentaci se nepodaří poznamenat, že volání metody může vrátit null. V jiných případech kód chybně předpokládá, že metoda vždy vrátí hodnotu, která není null .

Kód v následujícím příkladu předpokládá, že Array.Find metoda vždy vrací Person objekt, jehož FirstName pole odpovídá vyhledávacímu řetězci. Vzhledem k tomu, že neexistuje žádná shoda, modul runtime vyvolá NullReferenceException výjimku.

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

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

Chcete-li tento problém vyřešit, otestujte návratovou hodnotu metody a ujistěte se, že není null před voláním některého z jejích členů, jak je tomu v následujícím příkladu.

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

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

K načtení hodnoty používáte výraz (například zřetězujete seznam metod nebo vlastností), a přestože kontrolujete, jestli je nullhodnota , modul runtime stále vyvolává NullReferenceException výjimku. K tomu dochází, protože jedna z mezilehlých hodnot ve výrazu vrátí null. Výsledkem je, že test pro null se nikdy nevyhodnotí.

Následující příklad definuje Pages objekt, který ukládá do mezipaměti informace o webových stránkách, které jsou prezentovány Page objekty. Metoda Example.Main zkontroluje, jestli má aktuální webová stránka název, který není null, a pokud ano, zobrazí ho. I přes tuto kontrolu však metoda vyvolá NullReferenceException výjimku.

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

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

Výjimka je vyvolán, protože pages.CurrentPage vrátí null , pokud nejsou v mezipaměti uloženy žádné informace o stránce. Tuto výjimku lze opravit otestováním hodnoty CurrentPage vlastnosti před načtením vlastnosti aktuálního Page objektu Title , jak je tomu v následujícím příkladu:

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.

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.

Vyčíslujete prvky pole, které obsahuje odkazové typy, a pokus o zpracování jednoho z prvků vyvolá NullReferenceException výjimku.

Následující příklad definuje pole řetězců. Příkaz for vytvoří výčet prvků v poli a před zobrazením řetězce volá metodu každého řetězce Trim .

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

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

K této výjimce dojde, pokud předpokládáte, že každý prvek pole musí obsahovat hodnotu, která není null, a hodnota prvku pole je ve skutečnosti null. Výjimku lze odstranit testováním, zda je null prvek před provedením jakékoli operace s tímto elementem, jak je znázorněno v následujícím příkladu.

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

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

Výjimka NullReferenceException může být vyvolán metodou při přístupu ke členu jednoho ze svých argumentů, ale tento argument je null. Metoda PopulateNames v následujícím příkladu vyvolá výjimku na řádku names.Add(arrName);.

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

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

Chcete-li tento problém vyřešit, ujistěte se, že argument předaný metodě není null, nebo zpracovat vyvolanou výjimku v try…catch…finally bloku. Další informace najdete v tématu Výjimky.

Následující instrukce jazyka MSIL (Microsoft Intermediate Language) vyvolají : , , , ldfldacpobjstind.<type>stelem.<type>ldlenstfldldelemaldind.<type>throwldfldinitblkldelem.<type>a .unboxcpblkcallvirtNullReferenceException

NullReferenceException používá COR_E_NULLREFERENCE HRESULT s hodnotou 0x80004003.

Seznam počátečních hodnot vlastností pro instanci najdete v NullReferenceException konstruktorechNullReferenceException.

Zpracování výjimky NullReferenceException v kódu verze

Obvykle je lepší se vyhnout výjimce NullReferenceException, než ji zpracovat, když k ní dojde. Zpracování výjimky může znesnadnit údržbu a pochopení kódu a někdy může vést k dalším chybám. Výjimka NullReferenceException je často neopravitelná chyba. V takových případech může být nejlepší alternativou nechat aplikaci zastavit výjimkou.

Existuje však mnoho situací, kdy může být zpracování chyby užitečné:

Vaše aplikace může ignorovat objekty, které mají hodnotu null. Pokud například aplikace načítá a zpracovává záznamy v databázi, můžete ignorovat určitý počet chybných záznamů, které mají za následek objekty s hodnotou null. Záznam chybná data v souboru protokolu nebo v uživatelském rozhraní aplikace může být vše, co musíte udělat.
Z výjimky můžete provést obnovení. Například volání webové služby, která vrací typ odkazu, může vrátit hodnotu null, pokud dojde ke ztrátě připojení nebo vypršení jeho časového limitu. Můžete se pokusit znovu navázat připojení a zkusit volat znovu.
Stav aplikace můžete obnovit do platného stavu. Můžete například provádět úlohu s více kroky, která vyžaduje, abyste uložili informace do úložiště dat před voláním metody, která vyvolá Výjimku NullReferenceException. Pokud neinicializovaný objekt poškodí datový záznam, můžete před zavření aplikace odebrat předchozí data.
Chcete nahlásit výjimku. Pokud chybu způsobila například chyba uživatele vaší aplikace, můžete vygenerovat zprávu, která mu pomůže zadat správné informace. Můžete také protokolovat informace o chybě, které vám pomůžou problém vyřešit. Některé architektury, například ASP.NET, mají obslužnou rutinu výjimek vysoké úrovně, která zachycuje všechny chyby, aby aplikace nikdy nechyběla; v takovém případě může být protokolování výjimky jediným způsobem, jak můžete zjistit, že k ní dochází.

Konstruktory

NullReferenceException()	Inicializuje novou instanci NullReferenceException třídy a nastaví Message vlastnost nové instance na zprávu dodanou systémem, která popisuje chybu, například "Hodnota null byla nalezena, kde byla požadována instance objektu." Tato zpráva bere v úvahu aktuální jazykovou verzi systému.
NullReferenceException(SerializationInfo, StreamingContext)	Zastaralé. Inicializuje novou instanci třídy NullReferenceException se serializovanými daty.
NullReferenceException(String)	Inicializuje novou instanci NullReferenceException třídy se zadanou chybovou zprávou.
NullReferenceException(String, Exception)	Inicializuje novou instanci NullReferenceException třídy se zadanou chybovou zprávou a odkazem na vnitřní výjimku, která je příčinou této výjimky.

Vlastnosti

Data	Získá kolekci párů klíč/hodnota, které poskytují další uživatelem definované informace o výjimce. (Zděděno od Exception)
HelpLink	Získá nebo nastaví odkaz na soubor nápovědy přidružený k této výjimce. (Zděděno od Exception)
HResult	Získá nebo nastaví HRESULT, kódovaná číselná hodnota, která je přiřazena ke konkrétní výjimce. (Zděděno od Exception)
InnerException	Exception Získá instanci, která způsobila aktuální výjimku. (Zděděno od Exception)
Message	Získá zprávu, která popisuje aktuální výjimku. (Zděděno od Exception)
Source	Získá nebo nastaví název aplikace nebo objektu, který způsobuje chybu. (Zděděno od Exception)
StackTrace	Získá řetězcovou reprezentaci okamžitých rámců v zásobníku volání. (Zděděno od Exception)
TargetSite	Získá metodu, která vyvolá aktuální výjimku. (Zděděno od Exception)

Metody

Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetBaseException()	Při přepsání v odvozené třídě vrátí hodnotu Exception , která je původní příčinou jedné nebo více následných výjimek. (Zděděno od Exception)
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. Při přepsání v odvozené třídě nastaví s SerializationInfo informacemi o výjimce. (Zděděno od Exception)
GetType()	Získá typ modulu runtime aktuální instance. (Zděděno od Exception)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
ToString()	Vytvoří a vrátí řetězcovou reprezentaci aktuální výjimky. (Zděděno od Exception)

Událost

SerializeObjectState

Zastaralé.

Nastane, když je výjimka serializována k vytvoření objektu stavu výjimky, který obsahuje serializovaná data o výjimce.

(Zděděno od Exception)

Platí pro

Viz také

Váš názor

Byla tato stránka užitečná?