Dépannage des exceptions : System.NullReferenceException
Une exception NullReferenceException se produit quand vous essayez d'utiliser une méthode ou propriété d'un type de référence (C#, Visual Basic) dont la valeur est null. Par exemple, vous avez peut-être essayé d'utiliser un objet sans utiliser d'abord le mot clé new (New en Visual Basic) ou un objet dont la valeur était null (Nothing en Visual Basic).
Sections de cet article
Classes utilisées dans cet article
Causes courantes de NullReferenceExceptions
Recherche de la source de NullReferenceExceptions durant le développement
Éviter les exceptions NullReferenceException
Gestion des exceptions NullReferenceException dans le code de publication
Classes utilisées dans cet article
La plupart des exemples de cet article utilisent l'une ou l'autre des classes suivantes, ou les deux :
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
.png "Retour au début")
Autres sections de cet article
Causes courantes de NullReferenceExceptions
Toute variable de type de référence peut avoir la valeur null. Les variables locales, les propriétés d'une classe, les paramètres de méthode et les valeurs de retour de méthode peuvent tous contenir une référence null. L'appel des méthodes ou des propriétés de ces variables quand elles ont une valeur null engendre une exception NullReferenceException. Cas spécifiques :
Un champ de variable ou membre local est déclaré mais non initialisé
Une propriété ou un champ a la valeur null
Un paramètre de méthode a la valeur null
La valeur de retour d'une méthode est null
Un objet dans une collection ou un tableau a la valeur null
Un objet n'est pas créé en raison d'une condition
Un objet passé par référence à une méthode est défini sur null
Un champ de variable ou membre local est déclaré mais non initialisé
Cette erreur simple se produit plus fréquemment dans le code Visual Basic. À part certaines situations comme la déclaration d'une variable devant être passée comme paramètre de sortie, le compilateur C# ne permet pas l'utilisation d'une variable de référence locale tant qu'elle n'est pas initialisée. Le compilateur Visual Basic génère un avertissement.
Dans le code C# suivant, la ligne en surbrillance génère cette erreur de compilation :
Utilisation d'une variable locale non assignée 'engine'
Dans du code Visual Basic, la ligne surlignée génère l'avertissement de compilation BC42104 :
La variable 'engine' est utilisée avant qu'une valeur ne lui ait été assignée. Une exception de référence null peut se produire au moment de l'exécution
La ligne lève une exception NullReferenceException quand elle est exécutée.
public void NullReferencFromUninitializedLocalVariable()
{
EngineInfo engine;
Console.WriteLine(engine.ToString());
}
Public Sub NullReferencFromUninitializedLocalVariable()
Dim engine As EngineInfo
Console.WriteLine(engine.ToString())
End Sub
Entrées de cette section
Sections de cet article
Une propriété ou un champ a la valeur null
Les champs et les propriétés d'une classe sont automatiquement initialisés sur leur valeur par défaut quand la classe est créée. La valeur par défaut d'un type de référence est null (Nothing en Visual Basic). L'appel des méthodes membres sur un champ ou une propriété d'une classe parente quand la valeur du champ ou de la propriété est null engendre une exception NullReferenceException.
Dans cet exemple, la ligne surlignée lève une exception NullReferenceException, car la propriété Engine de car est automatiquement initialisée sur la valeur null.
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
Entrées de cette section
Sections de cet article
Un paramètre de méthode a la valeur null
Un paramètre de méthode qui est un type de référence peut avoir la valeur null (Nothing en Visual Basic). L'appel des méthodes ou propriétés membres sur une valeur de paramètre null engendre une exception NullReferenceException.
Dans cet exemple, la ligne surlignée lève une exception NullReferenceException, car BadEngineInfoPassedToMethod appelle NullReferenceFromMethodParameter avec un paramètre dont la valeur est null.
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
Entrées de cette section
Sections de cet article
La valeur de retour d'une méthode est null
Une méthode qui retourne un type de référence peut retourner la valeur null (Nothing en Visual Basic). L'appel des méthodes ou propriétés du type de référence retourné engendre une exception NullReferenceException quand la référence a la valeur null.
Dans cet exemple, la ligne surlignée lève une exception NullReferenceException, car l'appel de BadGetEngineInfo retourne une référence null dans la méthode NullReferenceFromMethodParameter.
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
Entrées de cette section
Sections de cet article
Un objet dans une collection ou un tableau a la valeur null
Une liste ou un tableau de types de référence peut contenir un élément dont la valeur est null. L'appel des méthodes ou propriétés d'un élément d'une liste dont la valeur est null engendre une exception NullReferenceException.
Dans cet exemple, la ligne surlignée dans NullReferenceFromListItem() lève une exception NullReferenceException, car l'appel de BadGetCarList retourne un élément avec la valeur null.
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
Entrées de cette section
Sections de cet article
Un objet n'est pas créé en raison d'une condition
Si un type de référence est initialisé dans un bloc conditionnel, l'objet n'est pas créé quand la condition est false.
Dans cet exemple, la ligne surlignée dans NullReferenceFromConditionalCreation lève une exception NullReferenceException, car elle initialise la variable engine uniquement si la méthode DetermineTheCondition() retourne true.
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
Entrées de cette section
Sections de cet article
La propriété d'un objet passé à une méthode est définie sur la valeur null
Quand vous passez un objet en tant que paramètre à une méthode par valeur (sans utiliser le mot clé ref ou out en C#, ou le mot clé ByRef en Visual Basic), la méthode ne peut pas changer l'emplacement de la mémoire du paramètre (vers lequel pointe le paramètre), mais elle peut modifier les propriétés de l'objet.
Dans cet exemple, la méthode NullPropertyReferenceFromPassToMethod crée un objet Automobile et initialise la propriété Engine. Ensuite, elle appelle BadSwapCarEngine, en passant le nouvel objet en tant que paramètre. BadSwapCarEngine définit la propriété Engine sur null, ce qui pousse la ligne surlignée dans NullPropertyReferenceFromPassToMethod à lever une exception 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
Entrées de cette section
Sections de cet article
Un objet passé par référence à une méthode est défini sur null
Quand vous passez un type de référence en tant que paramètre à une méthode par référence (à l'aide du mot clé ref ou out en C#, ou du mot clé ByRef en Visual Basic), vous pouvez modifier l'emplacement de la mémoire vers lequel pointe le paramètre.
Si vous passez un type de référence par référence à une méthode, la méthode peut définir le type référencé sur null (Nothing en Visual Basic).
Dans cet exemple, la ligne surlignée dans NullReferenceFromPassToMethodByRef lève une exception NullReferenceException, car l'appel de la méthode BadEngineSwapByRef définit la variable stockEngine sur la valeur null.
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
Entrées de cette section
Sections de cet article
Recherche de la source d'une exception NullReferenceException pendant le développement
Utilisez les info-bulles, la fenêtre Variables locales et les fenêtres Espions pour afficher les valeurs des variables
Parcourez la pile des appels pour rechercher l'endroit où une variable de référence n'est pas initialisée ou est définie sur null
Définir des points d'arrêt conditionnels pour arrêter le débogage quand un objet est null (Nothing en Visual Basic)
Utilisez les info-bulles, la fenêtre Variables locales et les fenêtres Espions pour afficher les valeurs des variables
Pointez sur le nom de la variable pour afficher sa valeur dans une info-bulle. Si la variable fait référence à un objet ou une collection, vous pouvez développer le type de données pour examiner ses propriétés ou éléments.
Ouvrez la fenêtre Variables locales pour examiner toutes les variables actives dans le contexte actuel.
Utilisez une fenêtre Espion pour vous concentrer sur les modifications d'une variable quand vous examinez le code.
Entrées de cette section
Sections de cet article
Parcourez la pile des appels pour rechercher l'endroit où une variable de référence n'est pas initialisée ou est définie sur null
La fenêtre Pile des appels de Visual Studio affiche une liste des noms des méthodes non terminées à l'arrêt du débogueur sur une exception ou un point d'arrêt. Vous pouvez sélectionner un nom dans la fenêtre Pile des appels et choisir Basculer vers le frame pour changer le contexte d'exécution de la méthode et examiner ses variables.
Entrées de cette section
Sections de cet article
Définir des points d'arrêt conditionnels pour arrêter le débogage quand un objet est null (Nothing en Visual Basic)
Vous pouvez définir un point d'arrêt conditionnel pour arrêter le débogage quand une variable a la valeur null. Les points d'arrêt conditionnels peuvent être utiles quand la référence null ne se produit pas souvent, par exemple quand un élément d'une collection est null seulement par intermittence. Les points d'arrêt conditionnels présentent un autre avantage : ils vous permettent de déboguer une erreur avant de valider une routine de gestion spécifique.
Entrées de cette section
Sections de cet article
Éviter les exceptions NullReferenceException
Utiliser Debug.Assert pour confirmer une indifférente
Initialiser complètement les types de référence
Utiliser Debug.Assert pour confirmer une indifférente
Une indifférente est une condition pour laquelle vous êtes sûr qu'elle est vraie. Une instruction Debug.Assert (System.Diagnostics) n'est appelée que dans les versions debug de vos applications et n'est pas appelée dans le code de publication. Si la condition indifférente n'est pas vraie, le débogueur s'arrête à l'instruction Assert et affiche une boîte de dialogue. Debug.Assert vérifie que la condition n'a pas changé pendant le développement de l'application. Une assertion indique également aux autres personnes qui lisent votre code que la condition doit toujours être vraie.
Par exemple, la méthode MakeEngineFaster suppose que son paramètre engine ne sera jamais null, car sa seule méthode appelante (TheOnlyCallerOfMakeEngineFaster) est connue pour initialiser complètement EngineInfo. L'assertion dans MakeEngineFaster documente la supposition et vérifie qu'elle est vraie.
Si une personne ajoute une nouvelle méthode appelante (BadNewCallerOfMakeEngineFaster) qui n'initialise pas le paramètre, l'assertion est déclenchée.
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
Entrées de cette section
Sections de cet article
Initialiser complètement les types de référence
Pour éviter de nombreuses exceptions NullReferenceException, initialisez complètement les types de référence aussi près que possible de leur création.
Ajouter une initialisation complète à vos propres classes
Si vous contrôlez la classe qui lève une exception NullReferenceException, initialisez complètement l'objet dans le constructeur du type. Par exemple, voici une version révisée des exemples de classes qui garantit une initialisation complète :
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
Notes
Utiliser une initialisation tardive pour les propriétés de grande dimension ou rarement utilisées
Pour réduire l'encombrement mémoire de votre classe et augmenter ses performances, utilisez l'initialisation tardive des propriétés de type de référence.Consultez Initialisation tardive.
Gestion des exceptions NullReferenceException dans le code de publication
Rechercher la valeur null (Nothing en Visual Basic) avant d'utiliser un type de référence
Utiliser try – catch – finally (Try – Catch – Finally en Visual Basic) pour gérer l'exception
Il est préférable d'éviter une exception NullReferenceException plutôt que de la gérer une fois qu'elle s'est produite. La gestion d'une exception peut compliquer la tenue à jour et la compréhension de votre code. En outre, cela peut parfois introduire d'autres bogues. Une exception NullReferenceException est souvent une erreur non récupérable. Dans ce cas, la meilleure alternative peut consister à laisser l'exception arrêter l'application.
Toutefois, il existe de nombreuses situations où la gestion de l'erreur peut être utile.
Votre application peut ignorer des objets dont la valeur est 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 engendrent des objets null. L'enregistrement de données incorrectes dans un fichier journal ou dans l'interface utilisateur de l'application peut être la solution.
Vous pouvez vous remettre d'une exception. Par exemple, un appel d'un service web retournant un type de référence peut retourner la valeur null si la connexion est perdue ou expire. Vous pouvez tenter de rétablir la connexion et réessayer l'appel.
Vous pouvez restaurer l'état valide de votre application. Par exemple, vous pouvez effectuer une tâche en plusieurs étapes nécessitant l'enregistrement d'informations dans une banque de données avant d'appeler une méthode qui lève une exception NullReferenceException. Si l'objet non initialisé risque d'endommager l'enregistrement des données, supprimez les données précédentes avant de fermer l'application.
Vous voulez signaler l'exception. Par exemple, si l'erreur a été provoquée par une erreur de l'utilisateur de votre application, vous pouvez générer un message pour l'aider à fournir les informations correctes. Vous pouvez également enregistrer des informations sur l'erreur pour vous aider à corriger le problème. Certaines infrastructures, comme ASP.NET, disposent d'un gestionnaire d'exceptions de haut niveau qui capture toutes les erreurs pour éviter tout blocage de l'application. Dans ce cas, la journalisation de l'exception peut représenter pour vous la seule façon de savoir que cela se produit.
Voici deux façons de gérer l'exception NullReferenceException dans le code de version.
Rechercher la valeur null (Nothing en Visual Basic) avant d'utiliser un type référence
L'utilisation d'un test explicite pour rechercher la valeur null avant d'utiliser un objet évite de pénaliser les performances des constructions try-catch-finally. Toutefois, vous devez encore déterminer et implémenter ce qu'il faut faire pour répondre à l'objet non initialisé.
Dans cet exemple, CheckForNullReferenceFromMethodReturnValue teste la valeur de retour de la méthode BadGetEngineInfo. Si l'objet n'est pas null, il est utilisé. Sinon, la méthode signale l'erreur.
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
Entrées de cette section
Sections de cet article
Utiliser try-catch-finally (Try-Catch-Finally en Visual Basic) pour gérer l'exception
L'utilisation des constructions de gestion des exceptions intégrées (try, catch, finally en C#, Try, Catch, Finally en Visual Basic) offre davantage d'options pour gérer les exceptions NullReferenceException que de vérifier si un objet n'est pas null.
Dans cet exemple, CatchNullReferenceFromMethodCall utilise deux actifs pour confirmer la supposition selon laquelle son paramètre contient une automobile complète, y compris un moteur. Dans le bloc try, la ligne surlignée lève une exception NullReferenceException, car l'appel de RarelyBadEngineSwap peut détruire la propriété Engine de la voiture. Le bloc catch capture l'exception, écrit les informations de l'exception dans un fichier et signale l'erreur à l'utilisateur. Dans le bloc finally, la méthode assure que l'état de la voiture n'est pas pire qu'au début de la méthode.
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
Entrées de cette section
Sections de cet article
Articles connexes
Instructions de conception pour les exceptions (Instruction de conception .NET Framework)
Gestion et levée des exceptions (Notions de base de l'application .NET Framework)
Procédure : gérer des exceptions dans une requête PLINQ (guide de développement .NET Framework)
Exceptions dans les threads gérés (guide de développement .NET Framework)
Exceptions et gestion des exceptions (guide de programmation C#)
Instructions de gestion des exceptions (référence C#)
Instruction Try...Catch...Finally (Visual Basic)
Gestion des exceptions (bibliothèque parallèle de tâches)
Gestion des exceptions (débogage)
Procédure : gérer des erreurs et des exceptions qui se produisent avec Databinding (Windows Forms)
Gestion des exceptions dans les applications réseau (XAML) (Windows)
Sections de cet article