Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Object.ToString ()

 

Data di pubblicazione: ottobre 2016

Restituisce una stringa che rappresenta l'oggetto corrente.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public virtual string ToString()

Valore restituito

Type: System.String

Stringa che rappresenta l'oggetto corrente.

Object.ToString è la versione principale metodo di formattazione in .NET Framework. Converte un oggetto nella relativa rappresentazione di stringa in modo che sia adatto per la visualizzazione. (Per informazioni sulla formattazione di supporto in .NET Framework, vedere Formattazione di tipi in .NET Framework.) Le implementazioni predefinite di Object.ToString metodo restituisce il nome completo del tipo dell'oggetto.

System_CAPS_importantImportante

È possibile che questa pagina seguendo il collegamento dall'elenco dei membri di un altro tipo. Ciò accade perché tale tipo non esegue l'override Object.ToString. Al contrario, eredita la funzionalità di Object.ToString metodo.

Tipi spesso eseguono l'override di Object.ToString metodo per fornire una rappresentazione di stringa più adatta di un determinato tipo. Tipi di overload spesso il Object.ToString metodo per fornire supporto per le stringhe di formato o la formattazione dipendente dalle impostazioni cultura.

Contenuto della sezione:

Il metodo ToString predefinito
L'override del metodo ToString
L'overload del metodo ToString
Estendere il metodo ToString
Note per Windows Runtime

L'implementazione predefinita di ToString metodo restituisce il nome completo del tipo di Object, come illustrato nell'esempio seguente.

using System;

public class Example
{
   public static void Main()
   {
      Object obj = new Object();
      Console.WriteLine(obj.ToString());
   }
}
// The example displays the following output:
//      System.Object

Poiché Object è la classe base di tutti i tipi di riferimento in .NET Framework, questo comportamento viene ereditato dai tipi di riferimento che non eseguono l'override di ToString metodo. Questa condizione è illustrata nell'esempio seguente. Definisce una classe denominata Object1 che accetta l'implementazione predefinita di tutte Object membri. Il ToString metodo restituisce il nome completo del tipo dell'oggetto.

using System;
using Examples;

namespace Examples
{
   public class Object1
   {
   }
}

public class Example
{
   public static void Main()
   {
      object obj1 = new Object1();
      Console.WriteLine(obj1.ToString());
   }
}
// The example displays the following output:
//   Examples.Object1

Tipi spesso eseguono l'override di Object.ToString per restituire una stringa che rappresenta l'istanza dell'oggetto. Ad esempio, i tipi di base, ad esempio Char, Int32, e String forniscono ToString implementazioni che restituiscono il formato di stringa del valore che rappresenta l'oggetto. Nell'esempio seguente viene definita una classe, Object2, che esegue l'override di ToString per restituire il nome del tipo insieme al relativo valore.

using System;

public class Object2
{
   private object value;

   public Object2(object value)
   {
      this.value = value;
   }

   public override string ToString()
   {
      return base.ToString() + ": " + value.ToString();
   }
}

public class Example
{
   public static void Main()
   {
      Object2 obj2 = new Object2('a');
      Console.WriteLine(obj2.ToString());
   }
}
// The example displays the following output:
//       Object2: a

Nella tabella seguente sono elencate le categorie di tipi in .NET Framework e indica se l'override di Object.ToString metodo.

Categoria di tipi

Esegue l'override di ToString

Comportamento

Classe

n/d

n/d

Struttura

Sì (ValueType.ToString)

Identico ToString

Enumerazione

Sì (Enum.ToString())

Il nome del membro

Interfaccia

No

n/d

delegate

No

n/d

Vedere le note per eredi per ulteriori informazioni sull'override ToString.

Oltre a sostituire senza parametri Object.ToString() overload del metodo, molti tipi di ToString metodo per fornire versioni del metodo che accettano parametri. Ciò avviene in genere, per fornire il supporto per la formattazione variabile e la formattazione dipendente dalle impostazioni cultura.

Gli overload di esempio seguente il ToString per restituire una stringa di risultato che include il valore di diversi campi di un Automobile (classe). Definisce quattro stringhe di formato: G, che restituisce il nome del modello e l'anno; D, che restituisce il nome del modello, anno e numero di porte; C, che restituisce il nome del modello, anno e numero di cilindri; e che restituisce una stringa con tutti i valori di campo quattro.

using System;

public class Automobile
{
   private int _doors;
   private String _cylinders;
   private int _year;
   private String _model;

   public Automobile(String model, int year , int doors,
                     String cylinders)
   {
      _model = model;
      _year = year;
      _doors = doors;
      _cylinders = cylinders;
   }

   public int Doors
   { get { return _doors; } }

   public String Model
   { get { return _model; } }

   public int Year
   { get { return _year; } }

   public String Cylinders
   { get { return _cylinders; } }

   public override String ToString()
   {
      return ToString("G");
   }

   public String ToString(String fmt)
   {
      if (String.IsNullOrEmpty(fmt))
         fmt = "G";

      switch (fmt.ToUpperInvariant())
      {
         case "G":
            return String.Format("{0} {1}", _year, _model);
         case "D":
            return String.Format("{0} {1}, {2} dr.",
                                 _year, _model, _doors);
         case "C":
            return String.Format("{0} {1}, {2}",
                                 _year, _model, _cylinders);
         case "A":
            return String.Format("{0} {1}, {2} dr. {3}",
                                 _year, _model, _doors, _cylinders);
         default:
            String msg = String.Format("'{0}' is an invalid format string",
                                       fmt);
            throw new ArgumentException(msg);
      }
   }
}

public class Example
{
   public static void Main()
   {
      var auto = new Automobile("Lynx", 2016, 4, "V8");
      Console.WriteLine(auto.ToString());
      Console.WriteLine(auto.ToString("A"));
   }
}
// The example displays the following output:
//       2016 Lynx
//       2016 Lynx, 4 dr. V8

Nell'esempio seguente chiama il metodo di overload Decimal.ToString(String, IFormatProvider) metodo per visualizzare le impostazioni cultura formattazione del valore di valuta.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "en-US", "en-GB", "fr-FR",
                                "hr-HR", "ja-JP" };
      Decimal value = 1603.49m;
      foreach (var cultureName in cultureNames) {
         CultureInfo culture = new CultureInfo(cultureName);
         Console.WriteLine("{0}: {1}", culture.Name,
                           value.ToString("C2", culture));
      }
   }
}
// The example displays the following output:
//       en-US: $1,603.49
//       en-GB: £1,603.49
//       fr-FR: 1 603,49 €
//       hr-HR: 1.603,49 kn
//       ja-JP: ¥1,603.49

Per informazioni sulle stringhe di formato e la formattazione dipendente dalle impostazioni cultura, vedere Formattazione di tipi in .NET Framework. Per le stringhe di formato supportate da valori numerici, vedere stringhe di formato numerico Standard e stringhe di formato numerico personalizzato. Per le stringhe di formato supportate da valori di data e ora, vedere Standard Date and Time Format Strings e Custom Date and Time Format Strings.

Poiché un tipo eredita il valore predefinito Object.ToString (metodo), è possibile trovare il relativo comportamento indesiderato e per modificarlo. Ciò è particolarmente vero di matrici e classi di raccolte. Anche se si prevede di ToString metodo di una classe di matrice o raccolta per visualizzare i valori dei relativi membri, viene invece visualizzato il nome completo del tipo tipo, come illustrato nell'esempio seguente.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int[] values = { 1, 2, 4, 8, 16, 32, 64, 128 };
      Console.WriteLine(values.ToString());

      List<int> list = new List<int>(values);
      Console.WriteLine(list.ToString());
   }
}
// The example displays the following output:
//       System.Int32[]
//       System.Collections.Generic.List`1[System.Int32]

Sono disponibili diverse opzioni per ottenere la stringa di risultato che si desidera.

  • Se il tipo è una matrice, un oggetto raccolta o un oggetto che implementa il IEnumerable o IEnumerable<T> interfacce, è possibile enumerare i relativi elementi tramite il foreach istruzione in c# o For Each...Next costrutto in Visual Basic.

  • Se non è la classe sealed (in c#) o NotInheritable (in Visual Basic), è possibile sviluppare una classe wrapper che eredita dalla classe di base il cui Object.ToString metodo che si desidera personalizzare. Come minimo, è necessario procedere nel modo seguente:

    1. Implementare i costruttori necessari. Le classi derivate non ereditano i costruttori della classe base.

    2. Eseguire l'override di Object.ToString per restituire la stringa di risultato che si desidera.

    Nell'esempio seguente definisce una classe wrapper per la List<T> classe. Viene eseguito l'override di Object.ToString metodo per visualizzare il valore di ogni metodo dell'insieme anziché il nome completo del tipo.

    using System;
    using System.Collections.Generic;
    
    public class CList<T> : List<T>
    {
       public CList(IEnumerable<T> collection) : base(collection)
       { }
    
       public CList() : base()
       {}
    
       public override String ToString()
       {
          String retVal = String.Empty;
          foreach (T item in this) {
             if (String.IsNullOrEmpty(retVal))
                retVal += item.ToString();
             else
                retVal += String.Format(", {0}", item);
          }
          return retVal;
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          var list2 = new CList<int>();
          list2.Add(1000);
          list2.Add(2000);
          Console.WriteLine(list2.ToString());
       }
    }
    // The example displays the following output:
    //    1000, 2000
    
  • Sviluppare un metodo di estensione che restituisce la stringa di risultato che si desidera. Si noti che non è possibile ignorare il valore predefinito Object.ToString metodo in questo modo (ovvero, la classe di estensione (in c#) o un modulo (in Visual Basic) non può avere un metodo senza parametri denominato ToString che viene chiamato al posto del tipo originale ToString metodo. È necessario fornire un altro nome per il senza parametri ToString sostituzione.

    Nell'esempio seguente definisce due metodi che estendono la List<T> classe: un costruttore ToString2 (metodo) e un ToString metodo con un String parametro che rappresenta una stringa di formato.

    using System;
    using System.Collections.Generic;
    
    public static class StringExtensions
    {
       public static String ToString2<T>(this List<T> l)
       {
          String retVal = String.Empty;
          foreach (T item in l)
             retVal += String.Format("{0}{1}", String.IsNullOrEmpty(retVal) ?
                                                         "" : ", ",
                                      item);
          return String.IsNullOrEmpty(retVal) ? "{}" : "{ " + retVal + " }";
       }
    
       public static String ToString<T>(this List<T> l, String fmt)
       {
          String retVal = String.Empty;
          foreach (T item in l) {
             IFormattable ifmt = item as IFormattable;
             if (ifmt != null)
                retVal += String.Format("{0}{1}",
                                        String.IsNullOrEmpty(retVal) ?
                                           "" : ", ", ifmt.ToString(fmt, null));
             else
                retVal += ToString2(l);
          }
          return String.IsNullOrEmpty(retVal) ? "{}" : "{ " + retVal + " }";
       }
    }
    
    public class Example
    {
       public static void Main()
       {
          List<int> list = new List<int>();
          list.Add(1000);
          list.Add(2000);
          Console.WriteLine(list.ToString2());
          Console.WriteLine(list.ToString("N0"));
       }
    }
    // The example displays the following output:
    //       { 1000, 2000 }
    //       { 1,000, 2,000 }
    

Quando si chiama il ToString metodo in una classe di Windows Runtime, fornisce il comportamento predefinito per le classi che non esegue l'override ToString. Ciò fa parte del supporto fornito da .NET Framework per Windows Runtime (vedere Supporto .NET Framework per applicazioni Windows Store e Windows Runtime. Classi di Windows Runtime non ereditano Object, e non sempre implementare un ToString. Tuttavia, sempre sembrano disporre ToString, Equals(Object), e GetHashCode metodi quando utilizzarle nel codice c# o Visual Basic e .NET Framework fornisce un comportamento predefinito per questi metodi.

A partire dal .NET Framework 4.5.1, common language runtime utilizzerà IStringable.ToString su un Windows Runtime oggetto prima di eseguire il fallback per l'implementazione predefinita di Object.ToString.

System_CAPS_noteNota

Windows Runtime le classi che vengono scritti in c# o Visual Basic possono eseguire l'override di ToString metodo.

A partire da Windows 8,1, Windows Runtime include un IStringable il cui unico metodo di interfaccia IStringable.ToString, fornisce il supporto di formattazione base analogo a quello fornito da Object.ToString. Per evitare ambiguità, è consigliabile non implementare IStringable in tipi gestiti.

Quando gli oggetti gestiti vengono chiamati da codice nativo o dal codice scritto in linguaggi quali JavaScript o C + + CX, sembrano implementare IStringable. Common language runtime indirizzerà automaticamente le chiamate da IStringable.ToString per Object.ToString nell'evento IStringable non è implementato nell'oggetto gestito.

System_CAPS_warningAvviso

Poiché common language runtime auto-implementa IStringable per tutti i tipi in gestiti Windows Store App, è consigliabile che non si fornisce il proprio IStringable implementazione. Implementazione di IStringable può produrre comportamenti imprevisti quando si chiama ToString dal Windows Runtime, C + + CX o JavaScript.

Se si sceglie di implementare IStringable in un tipo gestito pubblico esportato in un Windows Runtime componenti, le limitazioni seguenti:

  • È possibile definire il IStringable interfaccia solo in una relazione "implementazione della classe", ad esempio

    public class NewClass : IStringable
    

    in C# oppure

    Public Class NewClass : Implements IStringable
    

    in Visual Basic.

  • Non è possibile implementare IStringable su un'interfaccia.

  • È possibile dichiarare un parametro di tipo IStringable.

  • IStringable non può essere il tipo restituito del metodo, proprietà o campo.

  • Non è possibile nascondere il IStringable implementazione dalle classi di base utilizzando una definizione di metodo, ad esempio le operazioni seguenti:

    
    public class NewClass : IStringable
    {
       public new string ToString()
       {
          return "New ToString in NewClass";
       }
    }
    
    

    Al contrario, il IStringable.ToString implementazione deve sempre eseguire l'override dell'implementazione della classe base. Puoi nascondere un'implementazione di ToString solo richiamandola sull'istanza di una classe fortemente tipizzata.

Si noti che in diverse circostanze le chiamate dal codice nativo a un tipo gestito che implementa IStringable o nasconde il ToString implementazione può produrre un comportamento imprevisto.

Note per gli eredi:

Quando si implementano i tipi personalizzati, è necessario eseguire l'override di ToString per restituire i valori più appropriati per tali tipi. Le classi derivate che richiedono un maggiore controllo sulla formattazione di ToString fornisce può implementare il IFormattable interfaccia. Il IFormattable.ToString(String, IFormatProvider) metodo consente di definire stringhe di formato che controllano la formattazione e di utilizzare un IFormatProvider oggetto che può fornire per la formattazione specifiche delle impostazioni cultura.

Esegue l'override di ToString metodo dovrebbe seguire queste linee guida:

  • La stringa restituita deve essere breve e leggibile dagli utenti.

  • La stringa restituita deve identificare in modo univoco il valore dell'istanza dell'oggetto.

  • La stringa restituita deve essere il più breve possibile in modo che sia adatto per la visualizzazione di un debugger.

  • Il ToString override non deve restituire String.Empty o una stringa null.

  • Il ToString override non deve generare un'eccezione.

  • Se la rappresentazione di stringa di un'istanza è dipendente dalla lingua o può essere formattata in diversi modi, implementare il IFormattable interfaccia.

  • Se la stringa restituita include informazioni riservate, è innanzitutto necessario richiedere un'autorizzazione appropriata. Se la richiesta ha esito positivo, è possibile restituire le informazioni riservate; in caso contrario, si deve restituire una stringa che esclude le informazioni riservate.

  • Il ToString sostituzione deve avere effetti collaterali osservabili per evitare complicazioni durante il debug. Ad esempio, una chiamata al ToString metodo non deve modificare il valore dei campi di istanza.

  • Se il tipo implementa un metodo di analisi (o Parse o TryParse (metodo), un costruttore o un altro metodo statico che crea un'istanza del tipo da una stringa), è necessario assicurarsi che la stringa restituita dal ToString metodo può essere convertito in un'istanza dell'oggetto.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: