Exception.ToString Method

Definition

Crea e restituisce una rappresentazione di stringa dell'eccezione corrente.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

Returns

String

Rappresentazione di stringa dell'eccezione corrente.A string representation of the current exception.

Implements

Examples

Nell'esempio seguente viene generata un'eccezione e viene visualizzato il risultato della chiamata di ToString sull'eccezione.The following example causes an exception and displays the result of calling ToString on that exception. Si noti che il metodo Exception.ToString viene chiamato in modo implicito quando l'istanza della classe di eccezione viene visualizzata nell'elenco di argomenti del metodo Console.WriteLine.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

Remarks

ToString restituisce una rappresentazione dell'eccezione corrente che deve essere riconosciuta dagli utenti.ToString returns a representation of the current exception that is intended to be understood by humans. Se l'eccezione contiene dati dipendenti dalle impostazioni cultura, la rappresentazione di stringa restituita da ToString è necessaria per prendere in considerazione le impostazioni cultura correnti del sistema.Where the exception contains culture-sensitive data, the string representation returned by ToString is required to take into account the current system culture. Sebbene non esistano requisiti esatti per il formato della stringa restituita, deve tentare di riflettere il valore dell'oggetto come percepito dall'utente.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'implementazione predefinita di ToString ottiene il nome della classe che ha generato l'eccezione corrente, il messaggio, il risultato della chiamata di ToString sull'eccezione interna e il risultato della chiamata di Environment.StackTrace.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. Se uno di questi membri è null, il relativo valore non viene incluso nella stringa restituita.If any of these members is null, its value is not included in the returned string.

Se non viene visualizzato alcun messaggio di errore o se è una stringa vuota (""), non viene restituito alcun messaggio di errore.If there is no error message or if it is an empty string (""), then no error message is returned. Il nome dell'eccezione interna e l'analisi dello stack vengono restituiti solo se non sono null.The name of the inner exception and the stack trace are returned only if they are not null.

Questo metodo esegue l'override di Object.ToString.This method overrides Object.ToString.

Applies to