Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Object.ToString méthode ()

 

Date de publication : novembre 2016

Retourne une chaîne qui représente l'objet actuel.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public virtual string ToString()

Valeur de retour

Type: System.String

Chaîne qui représente l'objet actuel.

Object.ToString principales est mise en forme de méthode dans le .NET Framework. Il convertit un objet en sa représentation de chaîne afin qu’il soit adapté à l’affichage. (Pour plus d’informations sur la mise en forme de prise en charge dans le .NET Framework, consultez Mise en forme des types dans .NET Framework.) Implémentations par défaut de la Object.ToString méthode retourne le nom qualifié complet du type de l’objet.

System_CAPS_importantImportant

Vous avez atteint cette page en suivant le lien dans la liste des membres d’un autre type. C’est parce que ce type ne remplace pas Object.ToString. À la place, il hérite des fonctionnalités de la Object.ToString méthode.

Types remplacent fréquemment le Object.ToString méthode pour fournir une représentation de chaîne plus appropriée d’un type particulier. Types de surcharge aussi fréquemment le Object.ToString méthode pour prendre en charge les chaînes de format ou la mise en forme dépendante de la culture.

Dans cette section :

La méthode Object.ToString () par défaut
Substitution de la méthode Object.ToString)
La surcharge de la méthode ToString
Extension de la méthode Object.ToString
Notes de publication pour Windows Runtime

L’implémentation par défaut de la ToString méthode retourne le nom qualifié complet du type de la Object, comme illustré dans l’exemple suivant.

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

Étant donné que Object est la classe de base de tous les types de référence dans le .NET Framework, ce comportement est hérité par les types référence qui ne substituent pas la ToString méthode. L'exemple suivant illustre ce comportement. Il définit une classe nommée Object1 qui accepte l’implémentation par défaut de tous les Object membres. Son ToString méthode retourne le nom de type qualifié complet de l’objet.

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

Les types couramment substituer la Object.ToString méthode pour retourner une chaîne qui représente l’instance d’objet. Par exemple, les types de base telles que Char, Int32, et String fournir ToString qu’il retourne la forme de chaîne de la valeur qui représente l’objet. L’exemple suivant définit une classe, Object2, qui remplace la ToString le nom de type ainsi que sa valeur de retour de méthode.

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

Le tableau suivant répertorie les catégories de type dans le .NET Framework et indique si elles remplacent la Object.ToString méthode.

Catégorie de type

Remplacements Object.ToString)

Comportement

class

N/A

N/A

Structure

Oui (ValueType.ToString)

Identique à Object.ToString)

Énumération

Oui (Enum.ToString())

Le nom de membre

Interface

Non

N/A

delegate

Non

N/A

Voir les Notes section héritiers pour plus d’informations sur la substitution de ToString.

Outre l’écrasement sans paramètre Object.ToString() surcharge de nombreux types de méthode, la ToString méthode pour fournir des versions de la méthode qui acceptent des paramètres. En règle générale, cela pour prendre en charge la mise en forme variable et la mise en forme dépendante de la culture.

L’exemple suivant surcharge le ToString méthode pour retourner une chaîne de résultat qui inclut la valeur des différents champs d’un Automobile (classe). Il définit quatre chaînes de format : G, qui retourne le nom du modèle et l’année ; D, qui retourne le nom du modèle, année et nombre de portes ; C, qui retourne le nom du modèle, année et le nombre de cylindres ; et, qui retourne une chaîne avec toutes les valeurs de champ de quatre.

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

L’exemple suivant appelle surchargées Decimal.ToString(String, IFormatProvider) méthode pour afficher la mise en forme dépendante de la culture d’une valeur monétaire.

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

Pour plus d’informations sur les chaînes de format et la mise en forme dépendante de la culture, consultez Mise en forme des types dans .NET Framework. Pour les chaînes de format pris en charge par les valeurs numériques, consultez la page les chaînes de Format numériques Standard et les chaînes de Format numériques personnalisées. Pour les chaînes de format pris en charge par les valeurs de date et d’heure, consultez Standard Date and Time Format Strings et Custom Date and Time Format Strings.

Parce qu’un type hérite de la valeur par défaut Object.ToString (méthode), vous pouvez trouver son comportement indésirable et pour la modifier. Cela est particulièrement vrai des tableaux et des classes de collection. Bien que vous pouvez attendre la ToString méthode d’une classe de collection ou du tableau pour afficher les valeurs de ses membres, il affiche à la place le nom de type qualifié complet de type, comme le montre l’exemple suivant.

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]

Vous avez plusieurs options pour produire la chaîne de résultat que vous souhaitez.

  • Si le type est un tableau, un objet collection ou un objet qui implémente le IEnumerable ou IEnumerable<T> interfaces, vous pouvez énumérer ses éléments à l’aide de la foreach instruction en langage c# ou For Each...Next construire dans Visual Basic.

  • Si la classe n’est pas sealed (en c#) ou NotInheritable (en Visual Basic), vous pouvez développer une classe wrapper qui hérite de la classe de base dont Object.ToString méthode que vous souhaitez personnaliser. Au minimum, cela requiert que vous procédez comme suit :

    1. Implémentez des constructeurs nécessaires. Les classes dérivées n’héritent pas de leurs constructeurs de classe de base.

    2. Remplacer la Object.ToString méthode pour retourner la chaîne de résultat que vous souhaitez.

    L’exemple suivant définit une classe wrapper pour la List<T> classe. Il remplace le Object.ToString méthode pour afficher la valeur de chaque méthode de la collection plutôt que le nom de type qualifié complet.

    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
    
  • Développer un méthode d’extension qui retourne la chaîne de résultat souhaité. Notez que vous ne pouvez pas substituer la valeur par défaut Object.ToString méthode ainsi (autrement dit, votre classe d’extension (en c#) ou un module (Visual Basic) ne peut pas avoir une méthode sans paramètre nommée ToString qui est appelée à la place du type d’origine ToString (méthode). Vous devrez fournir un autre nom pour votre sans paramètre ToString remplacement.

    L’exemple suivant définit deux méthodes qui étendent la List<T> classe : un sans paramètre ToString2 (méthode) et un ToString méthode avec un String paramètre qui représente une chaîne de format.

    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 }
    

Lorsque vous appelez le ToString méthode sur une classe dans le Windows Runtime, il fournit le comportement par défaut pour les classes qui ne remplacent pas ToString. Ceci fait partie du support que le .NET Framework fournit pour Windows Runtime (voir Prise en charge .NET Framework pour les applications Windows Store et Windows Runtime). Classes de la Windows Runtime n’hérite pas de Object, et vous n’implémentez pas toujours un ToString. Toutefois, ils semblent toujours avoir ToString, Equals(Object), et GetHashCode méthodes lorsque vous les utilisez dans votre code c# ou Visual Basic et le .NET Framework fournit un comportement par défaut pour ces méthodes.

Compter les .NET Framework 4.5.1, le common language runtime utilise IStringable.ToString sur une Windows Runtime objet avant de revenir à l’implémentation par défaut de Object.ToString.

System_CAPS_noteRemarque

Windows Runtime les classes qui sont écrits en c# ou Visual Basic peuvent remplacer les ToString (méthode).

Commençant par Windows 8.1, la Windows Runtime inclut un IStringable de l’interface dont la méthode unique, IStringable.ToString, fournit le support de mise en forme base comparable à celles fournies par Object.ToString. Pour éviter toute ambiguïté, vous ne devez pas implémenter IStringable sur des types managés.

Lorsque les objets gérés sont appelées par du code natif ou par du code écrit dans des langages tels que JavaScript ou C + c++ / CX, ils apparaissent pour implémenter IStringable. Le common language runtime afin d’acheminer automatiquement les appels de IStringable.ToString à Object.ToString dans l’événement IStringable n’est pas implémentée sur l’objet managé.

System_CAPS_warningAvertissement

Étant donné que le common language runtime auto-implémente IStringable pour tous les types dans gérés Windows Store applications, nous recommandons que vous ne fournissez pas votre propre IStringable mise en œuvre. L’implémentation de IStringable peut entraîner un comportement inattendu lors de l’appel ToString à partir de la Windows Runtime, C + c++ / CX ou JavaScript.

Si vous choisissez d’implémenter IStringable dans un type managé public qui est exporté dans un Windows Runtime composant, les restrictions suivantes s’appliquent :

  • Vous pouvez définir le IStringable interface uniquement dans une relation « classe implémente », tels que

    public class NewClass : IStringable
    

    en C#, ou

    Public Class NewClass : Implements IStringable
    

    en Visual Basic.

  • Vous ne pouvez pas implémenter IStringable sur une interface.

  • Vous ne pouvez pas déclarer un paramètre de type IStringable.

  • IStringable ne peut pas être le type de retour d’une méthode, une propriété ou un champ.

  • Vous ne pouvez pas masquer votre IStringable implémentation de classes de base à l’aide d’une définition de méthode telle que la suivante :

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

    Au lieu de cela, le IStringable.ToString implémentation doit toujours remplacer l’implémentation de classe de base. Vous pouvez masquer une implémentation ToString uniquement en l'appelant sur une instance de classe fortement typée.

Notez que dans diverses conditions, les appels de code natif à un type managé qui implémente IStringable ou masque son ToString implémentation peut entraîner un comportement inattendu.

Remarques à l’attention des héritiers :

Lorsque vous implémentez vos propres types, vous devez substituer la ToString méthode pour retourner des valeurs explicites pour ces types. Classes dérivées qui requièrent plus de contrôle sur la mise en forme que ToString fournit peut implémenter la IFormattable interface. Son IFormattable.ToString(String, IFormatProvider) méthode vous permet de définir les chaînes de format qui contrôlent la mise en forme et d’utiliser un IFormatProvider objet qui peut fournir la mise en forme propres à la culture.

Les remplacements de la ToString méthode suivez ces instructions :

  • La chaîne retournée doit être convivial et lisible par les humains.

  • La chaîne retournée doit identifier de manière unique la valeur de l’instance d’objet.

  • La chaîne retournée doit être aussi courte que possible afin qu’il soit adapté à l’affichage par un débogueur.

  • Votre ToString substitution ne doit pas retourner String.Empty ou une chaîne vide.

  • Votre ToString remplacement ne doit pas lever d’exception.

  • Si la représentation sous forme de chaîne d’une instance est dépendante de la culture ou peut être mise en forme de plusieurs façons, implémentez le IFormattable interface.

  • Si la chaîne retournée inclut des informations sensibles, vous devez tout d’abord demander une autorisation appropriée. Si la demande réussit, vous pouvez retourner des informations sensibles. dans le cas contraire, vous devez retourner une chaîne qui exclut les informations sensibles.

  • Votre ToString remplacement ne doit avoir aucun effet secondaire observable afin d’éviter des complications lors du débogage. Par exemple, un appel à la ToString méthode ne doit pas modifier la valeur des champs d’instance.

  • Si le type implémente une méthode d’analyse (ou Parse ou TryParse (méthode), un constructeur ou une autre méthode statique qui crée une instance du type à partir d’une chaîne), vous devez vous assurer que la chaîne retournée par la ToString méthode peut être convertie en une instance d’objet.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: