NullReferenceException Classe

Définition

Espace de noms:: System

Assemblys:: mscorlib.dll, System.Runtime.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: NullReferenceException.cs

Source:: NullReferenceException.cs

Source:: NullReferenceException.cs

Source:: NullReferenceException.cs

Source:: NullReferenceException.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Exception levée lorsqu’il existe une tentative de déréférencement d’une référence d’objet Null.

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

Héritage: Object

Exception
NullReferenceException

Héritage: Object

Exception

SystemException
NullReferenceException

Attributs: SerializableAttribute ComVisibleAttribute

Remarques

Une NullReferenceException exception est levée lorsque vous essayez d’accéder à un membre sur un type dont la valeur est null. Une exception reflète généralement l’erreur NullReferenceException du développeur et est levée dans les scénarios suivants :

Note

Vous pouvez éviter la plupart des NullReferenceException exceptions en C# à l’aide de l’opérateur conditionnel Null (?.) ou de l’opérateur de fusion Null (??). Pour plus d’informations, consultez Types de références annulables. Les exemples C# suivants supposent que le contexte nullable est désactivé (non recommandé).

Vous avez oublié d’instancier un type de référence. Dans l’exemple suivant, names est déclaré mais jamais instancié (la ligne affectée est commentée dans l’exemple C#, car elle n’est pas compilée) :

using System.Collections.Generic;

public class UseBeforeAssignExample
{
    public static void Main(string[] args)
    {
        int value = int.Parse(args[0]);
        List<string> names;
        if (value > 0)
            names = [];

        //names.Add("Major Major Major");
    }
}

// Compilation displays a warning like the following:
//    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 UseBeforeAssignExample.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()

Certains compilateurs émettent un avertissement lorsqu’ils compilent ce code. D’autres émettent une erreur et la compilation échoue. Pour résoudre ce problème, instanciez l’objet afin que sa valeur ne soit plus null. L’exemple suivant effectue cette opération en appelant le constructeur de classe d’un type.

using System.Collections.Generic;

public class AnotherExample
{
    public static void Main()
    {
        List<string> names = ["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

Vous avez oublié de dimensionr un tableau avant de l’initialiser. Dans l’exemple suivant, values est déclaré comme un tableau entier, mais le nombre d’éléments qu’il contient n’est jamais spécifié. La tentative d’initialisation de ses valeurs lève donc une NullReferenceException exception.

int[] values = null;
for (int ctr = 0; ctr <= 9; ctr++)
    values[ctr] = ctr * 2;

foreach (int 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 Array3Example.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()

Vous pouvez éliminer l’exception en déclarant le nombre d’éléments dans le tableau avant de l’initialiser, comme l’illustre l’exemple suivant.

int[] values = new int[10];
for (int ctr = 0; ctr <= 9; ctr++)
    values[ctr] = ctr * 2;

foreach (int 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

Pour plus d’informations sur la déclaration et l’initialisation des tableaux, consultez Tableaux et tableaux.

Vous obtenez une valeur de retour Null à partir d’une méthode, puis appelez une méthode sur le type retourné. Il s’agit parfois du résultat d’une erreur de documentation ; la documentation ne parvient pas à noter qu’un appel de méthode peut retourner null. Dans d’autres cas, votre code suppose par erreur que la méthode retourne toujours une valeur non null.

Le code de l’exemple suivant suppose que la méthode retourne Person toujours un objet dont FirstName le Array.Find champ correspond à une chaîne de recherche. Étant donné qu’il n’y a pas de correspondance, le runtime lève une NullReferenceException exception.

public static void NoCheckExample()
{
    Person[] persons = Person.AddRange([ "Abigail", "Abra",
                                      "Abraham", "Adrian", "Ariella",
                                      "Arnold", "Aston", "Astor" ]);
    string nameToFind = "Robert";
    Person found = Array.Find(persons, p => p.FirstName == nameToFind);
    Console.WriteLine(found.FirstName);
}

// The example displays the following output:
//       Unhandled Exception: System.NullReferenceException:
//       Object reference not set to an instance of an object.

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

Pour résoudre ce problème, testez la valeur de retour de la méthode pour vous assurer qu’elle n’est pas null avant d’appeler un de ses membres, comme l’illustre l’exemple suivant.

public static void ExampleWithNullCheck()
{
    Person[] persons = Person.AddRange([ "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($"'{nameToFind}' not found.");
}

// 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

Vous utilisez une expression (par exemple, vous avez chaîné une liste de méthodes ou de propriétés ensemble) pour récupérer une valeur et, bien que vous vérifiiez si la valeur est null, le runtime lève toujours une NullReferenceException exception. Cela se produit parce qu’une des valeurs intermédiaires de l’expression retourne null. Par conséquent, votre test n’est null jamais évalué.

L’exemple suivant définit un Pages objet qui met en cache des informations sur les pages web, qui sont présentées par Page des objets. La Example.Main méthode vérifie si la page web active a un titre non null et, le cas échéant, affiche le titre. Malgré cette vérification, toutefois, la méthode lève une NullReferenceException exception.

public class Chain1Example
{
    public static void Main()
    {
        var pages = new Pages();
        if (!string.IsNullOrEmpty(pages.CurrentPage.Title))
        {
            string title = pages.CurrentPage.Title;
            Console.WriteLine($"Current title: '{title}'");
        }
    }
}

public class Pages
{
    readonly 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] is 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 Chain1Example.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()

L’exception est levée, car pages.CurrentPage elle retourne null si aucune information de page n’est stockée dans le cache. Cette exception peut être corrigée en testant la valeur de la CurrentPage propriété avant de récupérer la propriété de Title l’objet actuelPage, comme l’exemple suivant :

var pages = new Pages();
Page current = pages.CurrentPage;
if (current != null)
{
    string title = current.Title;
    Console.WriteLine($"Current title: '{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.

Vous énumérez les éléments d’un tableau qui contient des types de référence et votre tentative de traitement de l’un des éléments lève une NullReferenceException exception.

L’exemple suivant définit un tableau de chaînes. Une for instruction énumère les éléments du tableau et appelle la méthode de Trim chaque chaîne avant d’afficher la chaîne.

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.

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

Cette exception se produit si vous supposez que chaque élément du tableau doit contenir une valeur non null et que la valeur de l’élément de tableau est en fait null. L’exception peut être éliminée en testant si l’élément est null avant d’effectuer une opération sur cet élément, comme l’illustre l’exemple suivant.

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

Méthode lorsqu’elle accède à un membre de l’un de ses arguments, mais cet argument est null. La PopulateNames méthode de l’exemple suivant lève l’exception à la ligne names.Add(arrName);.

using System.Collections.Generic;

public class NRE2Example
{
    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 (string 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 NRE2Example.PopulateNames(List`1 names)
//       at NRE2Example.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()

Pour résoudre ce problème, assurez-vous que l’argument passé à la méthode n’est pas null, ou gérez l’exception levée dans un try…catch…finally bloc. Pour plus d’informations, consultez Exceptions.

Une liste est créée sans connaître le type et la liste n’a pas été initialisée. La GetList méthode de l’exemple suivant lève l’exception à la ligne emptyList.Add(value).

using System;
using System.Collections.Generic;
using System.Collections;
using System.Runtime.Serialization;

public class NullReferenceExample
{
    public static void Main()
    {
        var listType = GetListType();
        _ = GetList(listType);
    }

    private static Type GetListType()
    {
        return typeof(List<int>);
    }

    private static IList GetList(Type type)
    {
        var emptyList = (IList)FormatterServices.GetUninitializedObject(type); // Does not call list constructor
        var value = 1;
        emptyList.Add(value);
        return emptyList;
    }
}
// The example displays output like the following:
//    Unhandled Exception: System.NullReferenceException: 'Object reference
//    not set to an instance of an object.'
//    at System.Collections.Generic.List`1.System.Collections.IList.Add(Object item)
//    at NullReferenceExample.GetList(Type type): line 24

Pour résoudre ce problème, assurez-vous que la liste est initialisée (une façon de procéder consiste à appeler Activator.CreateInstance au lieu de FormatterServices.GetUninitializedObject), ou à gérer l’exception levée dans un try…catch…finally bloc. Pour plus d’informations, consultez Exceptions.

Les instructions msIL (Microsoft intermediate language) suivantes lèvent NullReferenceException : callvirt, cpblk, cpobj, initblk, ldelem.<type>, ldelema, ldfld, ldflda, ldind.<type>, ldlen, stelem.<type>, stfld, stind.<type>, throw et unbox.

NullReferenceException utilise HRESULT COR_E_NULLREFERENCE, qui a la valeur 0x80004003.

Pour obtenir la liste des valeurs de propriété initiales d’une instance de NullReferenceException, consultez les NullReferenceException constructeurs.

Quand gérer les exceptions NullReferenceException

Il est généralement préférable d’éviter une exception NullReferenceException que de la gérer une fois qu’elle se produit. La gestion d’une exception peut rendre votre code plus difficile à gérer et à comprendre, et peut parfois introduire d’autres bogues. Une exception NullReferenceException est souvent une erreur non récupérable. Dans ces cas, laisser l’exception arrêter l’application peut être la meilleure alternative.

Toutefois, il existe de nombreuses situations où la gestion de l’erreur peut être utile :

Votre application peut ignorer les objets null. Par exemple, si votre application récupère et traite des enregistrements dans une base de données, vous pouvez ignorer un certain nombre d’enregistrements incorrects qui entraînent des objets Null. L’enregistrement des données incorrectes dans un fichier journal ou dans l’interface utilisateur de l’application peut être tout ce que vous devez faire.
Vous pouvez récupérer à partir de l’exception. Par exemple, un appel à un service web qui retourne un type de référence peut retourner null si la connexion est perdue ou si la connexion expire. Vous pouvez tenter de rétablir la connexion et réessayer d’appeler.
Vous pouvez restaurer l’état de votre application à un état valide. Par exemple, vous pouvez effectuer une tâche en plusieurs étapes qui vous oblige à enregistrer des informations dans un magasin de données avant d’appeler une méthode qui lève une exception NullReferenceException. Si l’objet non initialisé endommage l’enregistrement de données, vous pouvez supprimer les données précédentes avant de fermer l’application.
Vous souhaitez signaler l’exception. Par exemple, si l’erreur a été causée par une erreur de l’utilisateur de votre application, vous pouvez générer un message pour les aider à fournir les informations appropriées. Vous pouvez également consigner des informations sur l’erreur pour vous aider à résoudre le problème. Certains frameworks, comme ASP.NET, ont un gestionnaire d’exceptions de haut niveau qui capture toutes les erreurs auxquelles l’application ne se bloque jamais ; dans ce cas, la journalisation de l’exception peut être la seule façon de savoir qu’elle se produit.

Constructeurs

Nom	Description
NullReferenceException()	Initialise une nouvelle instance de la NullReferenceException classe, en définissant la Message propriété de la nouvelle instance sur un message fourni par le système qui décrit l’erreur, par exemple « La valeur « Null » a été trouvée où une instance d’un objet a été requise. » Ce message prend en compte la culture système actuelle.
NullReferenceException(SerializationInfo, StreamingContext)	Obsolète. Initialise une nouvelle instance de la classe NullReferenceException avec des données sérialisées.
NullReferenceException(String, Exception)	Initialise une nouvelle instance de la NullReferenceException classe avec un message d’erreur spécifié et une référence à l’exception interne qui est la cause de cette exception.
NullReferenceException(String)	Initialise une nouvelle instance de la NullReferenceException classe avec un message d’erreur spécifié.

Propriétés

Nom	Description
Data	Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception. (Hérité de Exception)
HelpLink	Obtient ou définit un lien vers le fichier d’aide associé à cette exception. (Hérité de Exception)
HResult	Obtient ou définit HRESULT, valeur numérique codée affectée à une exception spécifique. (Hérité de Exception)
InnerException	Obtient l’instance Exception qui a provoqué l’exception actuelle. (Hérité de Exception)
Message	Obtient un message qui décrit l’exception actuelle. (Hérité de Exception)
Source	Obtient ou définit le nom de l’application ou de l’objet qui provoque l’erreur. (Hérité de Exception)
StackTrace	Obtient une représentation sous forme de chaîne des images immédiates sur la pile des appels. (Hérité de Exception)
TargetSite	Obtient la méthode qui lève l’exception actuelle. (Hérité de Exception)

Méthodes

Nom	Description
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetBaseException()	En cas de substitution dans une classe dérivée, retourne la Exception qui est la cause racine d’une ou plusieurs exceptions ultérieures. (Hérité de Exception)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsolète. En cas de substitution dans une classe dérivée, définit l'SerializationInfo avec des informations sur l’exception. (Hérité de Exception)
GetType()	Obtient le type d’exécution de l’instance actuelle. (Hérité de Exception)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ToString()	Crée et retourne une représentation sous forme de chaîne de l’exception actuelle. (Hérité de Exception)

Événements

Nom	Description
SerializeObjectState	Obsolète. Se produit lorsqu’une exception est sérialisée pour créer un objet d’état d’exception qui contient des données sérialisées sur l’exception. (Hérité de Exception)

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?