Mots-clés throw en C#

Dans la section précédente, nous avons vu comment traiter les exceptions déclenchées automatiquement par CLR. Ici, nous allons voir comment déclencher manuellement des exceptions.

Vous pouvez utiliser le mot-clé throw pour lever manuellement des exceptions. Vous pouvez utiliser le mot-clé throw pour lever des exceptions dérivées deExceptionToute classe dérivée de Exception.

static void Main(string[] args)
{
　　　　Student std = null;
　　　　try
　　　　{
　　　　　　　　PrintStudentName(std);
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　Console.WriteLine(ex.Message);
　　　　}　　　　　　　　　　　　　　　　　　　　　　
　　　　Console.ReadKey();
}
private static void PrintStudentName(Student std)
{
　　　　if (std == null)
　　　　　　　　throw new NullReferenceException("L'objet Student est null");
　　　　　　　　
　　　　Console.WriteLine(std.StudentName);
}

L'objet Student est null

Dans l'exemple précédent, si l'objet Student est null, la méthode PrintStudentName() lève une NullReferenceException.

Veuillez noter que le mot-clé throw crée un objet de type d'exception valide. Le mot-clé throw ne peut pas être utilisé avec tout autre type qui n'est pas dérivé de la classe Exception.

Réthrows d'exception

Vous pouvez également réthrows une exception à partir d'un bloc catch pour la transmettre au appelant, afin que l'appelant puisse la traiter de la manière souhaitée. L'exemple suivant réthrows l'exception.

static void Main(string[] args)
{
　　　　try
　　　　{
　　　　　　　　Method1();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　Console.WriteLine(ex.StackTrace);
　　　　}　　　　　　　　　　　　　　　　　　　　　　
}
static void Method1()
{
　　　　try
　　　　{
　　　　　　　　Method2();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw;
　　　　}　
}
static void Method2()
{
　　　　string str = null;
　　　　try
　　　　{
　　　　　　　　Console.WriteLine(str[0]);
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw;
　　　　}　
}

Dans l'exemple précédent, la méthode Method2Une exception se produit dans (). Le bloc catch utilise uniquement le mot-clé throw (au lieu de throw e) pour lever cette exception. Cela se produira dans la méthode Method1Le bloc catch le traite, ici il réthrows à nouveau la même exception, et finalement il la traite dans la méthode Main(). Le stack trace de cette exception vous fournira la position exacte et des détails complets sur cette exception.

Si vous réthrows une exception en utilisant les paramètres d'exception, elle ne conservera pas l'exception originale et créera une nouvelle exception. L'exemple suivant en donne une démonstration.

static void Main(string[] args)
{
　　　　try
　　　　{
　　　　　　　　Method1();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　Console.WriteLine(ex.StackTrace);
　　　　}　　　　　　　　　　　　　　　　　　　　　　
}
static void Method1()
{
　　　　try
　　　　{
　　　　　　　　Method2();
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw ex;
　　　　}　
}
static void Method2()
{
　　　　string str = null;
　　　　try
　　　　{
　　　　　　　　Console.WriteLine(str[0]);
　　　　}
　　　　catch(Exception ex)
　　　　{
　　　　　　　　throw;
　　　　}　
}

dans l'exemple ci-dessus, l'exception capturée dans la méthode Main () affichera celle provenant de Method1et le suivi de pile de la méthode Main. Lorsque nous capturons une exception dans Method1Lorsque vous utilisez throw ex dans () pour relancer l'exception, elle ne montrera pas Method dans le suivi de pile.1Par conséquent, n'utilisez jamais throw < exception parameter parameter > pour lancer des exceptions.

Dans la prochaine section, apprenez comment créer un type d'exception personnalisé.