Exception.ToString Exception.ToString Exception.ToString Exception.ToString Method

Définition

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

public:
 override System::String ^ ToString();
public override string ToString ();
override this.ToString : unit -> string
Public Overrides Function ToString () As String

Retours

Représentation sous forme de chaîne de l'exception actuelle.A string representation of the current exception.

Implémente

Exemples

L’exemple suivant provoque une exception et affiche le résultat de l' ToString appel de sur cette exception.The following example causes an exception and displays the result of calling ToString on that exception. Notez que la Exception.ToString méthode est appelée implicitement lorsque l’instance de la classe d’exception apparaît dans la liste Console.WriteLine d’arguments de la méthode.Note that the Exception.ToString method is called implicitly when the Exception class instance appears in the argument list of the Console.WriteLine method.

using namespace System;

public ref class TestClass{};

int main()
{
   TestClass^ test = gcnew TestClass;
   array<Object^>^ objectsToCompare = { test, test->ToString(), 123,
                                        (123).ToString(), "some text",
                                        "Some Text" };
   String^ s = "some text";
   for each (Object^ objectToCompare in objectsToCompare) {
      try {
         Int32 i = s->CompareTo(objectToCompare);
         Console::WriteLine("Comparing '{0}' with '{1}': {2}",
                            s, objectToCompare, i);
      }
      catch (ArgumentException^ e) {
            Console::WriteLine("Bad argument: {0} (type {1})",
                              objectToCompare,
                              objectToCompare->GetType()->Name);
            Console::WriteLine("Exception information: {0}", e);
      }
      Console::WriteLine();
   }
}
// The example displays the following output:
//     Bad argument: TestClass (type TestClass)
//     Exception information: System.ArgumentException: Object must be of type String.
//        at System.String.CompareTo(Object value)
//        at Example.Main()
//     
//     Comparing 'some text' with 'TestClass': -1
//     
//     Bad argument: 123 (type Int32)
//     Exception information: System.ArgumentException: Object must be of type String.
//        at System.String.CompareTo(Object value)
//        at Example.Main()
//     
//     Comparing 'some text' with '123': 1
//     
//     Comparing 'some text' with 'some text': 0
//     
//     Comparing 'some text' with 'Some Text': -1
using System;

public class TestClass
{}

public class Example 
{
   public static void Main()
   {
      var test = new TestClass();
      Object[] objectsToCompare = { test, test.ToString(), 123,
                                    123.ToString(), "some text",
                                    "Some Text" };
      string s = "some text";
      foreach (var objectToCompare in objectsToCompare) {
         try {
            int i = s.CompareTo(objectToCompare);
            Console.WriteLine("Comparing '{0}' with '{1}': {2}",
                              s, objectToCompare, i);
         }
         catch (ArgumentException e) {
            Console.WriteLine("Bad argument: {0} (type {1})",
                              objectToCompare,
                              objectToCompare.GetType().Name);
            Console.WriteLine("Exception information: {0}", e);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//     Bad argument: TestClass (type TestClass)
//     Exception information: System.ArgumentException: Object must be of type String.
//        at System.String.CompareTo(Object value)
//        at Example.Main()
//     
//     Comparing 'some text' with 'TestClass': -1
//     
//     Bad argument: 123 (type Int32)
//     Exception information: System.ArgumentException: Object must be of type String.
//        at System.String.CompareTo(Object value)
//        at Example.Main()
//     
//     Comparing 'some text' with '123': 1
//     
//     Comparing 'some text' with 'some text': 0
//     
//     Comparing 'some text' with 'Some Text': -1
Public Class TestClass
End Class 

Public Class Example
   Public Shared Sub Main()
      Dim test As New TestClass()
      Dim objectsToCompare() As Object = { test, test.ToString(), 123,
                                           123.ToString(), "some text",
                                           "Some Text" }
      Dim s As String = "some text"
      For Each objectToCompare In objectsToCompare
         Try
            Dim i As Integer = s.CompareTo(objectToCompare)
            Console.WriteLine("Comparing '{0}' with '{1}': {2}",
                              s, objectToCompare, i)
         Catch e As ArgumentException
            Console.WriteLine("Bad argument: {0} (type {1})",
                              objectToCompare,
                              objectToCompare.GetType().Name)
            Console.WriteLine("Exception information: {0}", e)
         End Try
         Console.WriteLine()
      Next
   End Sub 
End Class 
' The example displays the following output:
'     Bad argument: TestClass (type TestClass)
'     Exception information: System.ArgumentException: Object must be of type String.
'        at System.String.CompareTo(Object value)
'        at Example.Main()
'     
'     Comparing 'some text' with 'TestClass': -1
'     
'     Bad argument: 123 (type Int32)
'     Exception information: System.ArgumentException: Object must be of type String.
'        at System.String.CompareTo(Object value)
'        at Example.Main()
'     
'     Comparing 'some text' with '123': 1
'     
'     Comparing 'some text' with 'some text': 0
'     
'     Comparing 'some text' with 'Some Text': -1

Remarques

ToStringretourne une représentation de l’exception actuelle qui doit être comprise par les êtres humains.ToString returns a representation of the current exception that is intended to be understood by humans. Lorsque l’exception contient des données dépendantes de la culture, la ToString représentation sous forme de chaîne retournée par est requise pour prendre en compte la culture système actuelle.Where the exception contains culture-sensitive data, the string representation returned by ToString is required to take into account the current system culture. Bien qu’il n’existe aucune exigence exacte pour le format de la chaîne retournée, elle doit tenter de refléter la valeur de l’objet tel qu’il est perçu par l’utilisateur.Although there are no exact requirements for the format of the returned string, it should attempt to reflect the value of the object as perceived by the user.

L’implémentation par défaut ToString de obtient le nom de la classe qui a levé l’exception actuelle, le message, le résultat de ToString l’appel de sur l’exception interne et le résultat Environment.StackTracede l’appel de.The default implementation of ToString obtains the name of the class that threw the current exception, the message, the result of calling ToString on the inner exception, and the result of calling Environment.StackTrace. Si l’un de ces membres nullest, sa valeur n’est pas incluse dans la chaîne retournée.If any of these members is null, its value is not included in the returned string.

S’il n’y a aucun message d’erreur ou s’il s’agit d’une chaîne vide (""), aucun message d’erreur n’est retourné.If there is no error message or if it is an empty string (""), then no error message is returned. Le nom de l’exception interne et la trace de la pile sont retournés uniquement nulls’ils ne le sont pas.The name of the inner exception and the stack trace are returned only if they are not null.

Cette méthode se substitue à Object.ToString.This method overrides Object.ToString.

S’applique à