ToString Método
Collapse the table of content
Expand the table of content
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Object.ToString (Método) ()

 

Retorna una cadena que representa al objeto actual.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public virtual string ToString()

Valor devuelto

Type: System.String

Una cadena que representa el objeto actual.

Object.ToString es el principal formato método en .NET Framework. Convierte un objeto en su representación de cadena para que sea apropiada para su presentación. (Para obtener información acerca del formato de soporte técnico de .NET Framework, consulte Aplicar formato a tipos en .NET Framework.) Las implementaciones de predeterminadas el Object.ToString método devuelve el nombre completo del tipo de objeto.

System_CAPS_importantImportante

Podría haber alcanzado esta página mediante el vínculo de la lista de miembros de otro tipo. Eso es porque ese tipo no reemplaza Object.ToString. En su lugar, hereda la funcionalidad de la Object.ToString (método).

Tipos se reemplazan con frecuencia el Object.ToString método para proporcionar una representación de cadena más adecuada de un tipo determinado. Tipos también suelen sobrecargar el Object.ToString método para proporcionar compatibilidad con cadenas de formato o el formato dependiente de la referencia cultural.

En esta sección:

El método predeterminado de Object.ToString)
Invalida el método Object.ToString)
Sobrecarga del método ToString
Extender el método Object.ToString
Notas para el tiempo de ejecución de Windows

La implementación predeterminada de la ToString método devuelve el nombre completo del tipo de la Object, como se muestra en el ejemplo siguiente.

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

Porque Object es la clase base de todos los tipos de referencia en .NET Framework, este comportamiento es heredada por los tipos de referencia que no reemplazan el ToString método. Esto se ilustra en el siguiente ejemplo: Se define una clase denominada Object1 que acepta la implementación predeterminada de todos los Object miembros. Su ToString método devuelve el nombre de tipo completo del objeto.

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

Los tipos comúnmente invalidar el Object.ToString método para devolver una cadena que representa la instancia del objeto. Por ejemplo, los tipos base como Char, Int32, y String proporcionar ToString implementaciones que devuelven el formato de cadena del valor que representa el objeto. En el ejemplo siguiente se define una clase Object2, que reemplaza el ToString para devolver el nombre de tipo junto con su valor.

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

En la tabla siguiente enumera las categorías de tipos de .NET Framework e indica si se permite o no invalidan los Object.ToString método.

Categoría de tipo

Invalida Object.ToString)

Comportamiento

Clase

no disponible

no disponible

Estructura

Sí (ValueType.ToString)

Igual a Object.ToString)

Enumeración

Sí (Enum.ToString())

El nombre de miembro

Interface

No

no disponible

delegate

No

no disponible

Consulte la sección Notas a herederos para obtener información adicional sobre cómo reemplazar ToString.

Además de invalidar sin parámetros Object.ToString() sobrecarga del método, muchos tipos el ToString método para proporcionar versiones del método que aceptan parámetros. Normalmente, esto se hace para proporcionar compatibilidad con el formato de variable y la referencia cultural.

El ejemplo siguiente se sobrecarga el ToString para devolver una cadena de resultado que incluye el valor de varios campos de una Automobile clase. Define cuatro cadenas de formato: G, que devuelve el nombre del modelo y el año; D., que devuelve el nombre del modelo, el año y el número de puertas; C, que devuelve el nombre del modelo, el año y el número de cilindros; y A, que devuelve una cadena con todos los valores de los cuatro campos.

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

En el ejemplo siguiente se llama sobrecargado Decimal.ToString(String, IFormatProvider) método para mostrar el formato de la referencia cultural de un valor de moneda.

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

Para obtener más información sobre cadenas de formato y el formato de la referencia cultural, consulte Aplicar formato a tipos en .NET Framework. Para las cadenas de formato compatibles con valores numéricos, vea cadenas de formato numérico estándar y cadenas de formato numérico personalizado. Para las cadenas de formato compatibles con los valores de fecha y hora, vea cadenas de formato de hora y fecha estándar y cadenas de formato de hora y fecha personalizada.

Puesto que un tipo hereda el valor predeterminado Object.ToString (método), puede buscar su comportamiento no deseado y desea cambiarlo. Esto es especialmente cierto para las matrices y las clases de colección. Mientras que puede esperar el ToString método de una clase de colección o matriz para mostrar los valores de sus miembros, en su lugar, muestra el nombre de tipo completo del tipo, como se muestra en el ejemplo siguiente.

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]

Tiene varias opciones para generar la cadena de resultado que desea.

  • Si el tipo es una matriz, un objeto de colección o un objeto que implementa el IEnumerable o IEnumerable<T> interfaces, puede enumerar sus elementos mediante el foreach instrucción en C# o la For Each...Next construir en Visual Basic.

  • Si la clase no es sealed (en C#) o NotInheritable (en Visual Basic), puede desarrollar una clase contenedora que hereda de la clase base cuyo Object.ToString método que desee personalizar. Como mínimo, esto requiere que haga lo siguiente:

    1. Implementar todos los constructores necesarios. Las clases derivadas no heredan sus constructores de clase base.

    2. Invalidar el Object.ToString para devolver la cadena de resultado que desea.

    En el ejemplo siguiente se define una clase contenedora para la List<T> clase. Reemplaza el Object.ToString método para mostrar el valor de cada método de la colección en lugar de en el nombre de tipo completo.

    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
    
  • Desarrollar un método de extensión que devuelve la cadena de resultado que desee. Tenga en cuenta que no se puede reemplazar el valor predeterminado Object.ToString método de esta manera (es decir, la clase de extensión (en C#) o un módulo (en Visual Basic) no puede tener un método sin parámetros denominado ToString que se llama en lugar del tipo original ToString método. Tendrá que proporcionar otro nombre para su sin parámetros ToString reemplazo.

    El siguiente ejemplo define dos métodos que amplían la List<T> clase: una sin parámetros ToString2 (método) y un ToString método con un String parámetro que representa una cadena de 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 }
    

Cuando se llama a la ToString método en una clase en el Windows en tiempo de ejecución, proporciona el comportamiento predeterminado para las clases que no se invalidan ToString. Esto forma parte de la compatibilidad que .NET Framework proporciona para Windows en tiempo de ejecución (vea Compatibilidad de .NET Framework con las aplicaciones de la Tienda Windows y Windows en tiempo de ejecución). Las clases en el Windows en tiempo de ejecución no heredan Object, y no siempre se implementa un ToString. Sin embargo, siempre parece que tienen ToString, Equals(Object), y GetHashCode métodos cuando se utilizan en el código de C# o Visual Basic y .NET Framework proporciona un comportamiento predeterminado para estos métodos.

A partir de la .NET Framework 4.5.1, common language runtime usará IStringable.ToString en un Windows en tiempo de ejecución objeto antes de la implementación predeterminada de Object.ToString.

System_CAPS_noteNota

Windows en tiempo de ejecución las clases que están escritas en C# o Visual Basic pueden invalidar el ToString método.

A partir de Windows 8.1, el Windows en tiempo de ejecución incluye un IStringable interfaz cuyo único método, IStringable.ToString, proporciona compatibilidad básica de formato comparable a la proporcionada por Object.ToString. Para evitar la ambigüedad, debería implementar IStringable en tipos administrados.

Cuando se llama a los objetos administrados por código nativo o código escrito en lenguajes como JavaScript o C++ / CX, aparecen implementar IStringable. Common language runtime enrutará automáticamente las llamadas de IStringable.ToString a Object.ToString en el evento IStringable no está implementada en el objeto administrado.

System_CAPS_warningAdvertencia

Dado que common language runtime auto-implementa IStringable para todos los tipos de administrados Tienda Windows aplicaciones, le recomendamos que no proporcione su propio IStringable implementación. Implementación IStringable puede producir un comportamiento no deseado al llamar a ToString desde el Windows en tiempo de ejecución, C++ / CX o JavaScript.

Si decide implementar IStringable en un tipo público administrado que se exporte en un Windows en tiempo de ejecución componente, se aplican las restricciones siguientes:

  • Puede definir la IStringable sólo en una relación "la clase implementa", como la interfaz

    public class NewClass : IStringable
    

    en C# o

    Public Class NewClass : Implements IStringable
    

    en Visual Basic.

  • No se puede implementar IStringable en una interfaz.

  • No se puede declarar un parámetro de tipo IStringable.

  • IStringable no puede ser el tipo de valor devuelto de un método, propiedad o campo.

  • No se puede ocultar la IStringable implementación de las clases base mediante una definición de método como el siguiente:

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

    En su lugar, el IStringable.ToString implementación debe invalidar siempre la implementación de la clase base. Solo puede ocultar una implementación de ToString invocándola en una instancia de clase fuertemente tipada.

Tenga en cuenta que en una gran variedad de condiciones, las llamadas desde código nativo a un tipo administrado que implemente IStringable u oculta su ToString implementación puede producir un comportamiento inesperado.

Notas para los herederos:

Al implementar sus propios tipos, debe reemplazar el ToString para devolver valores que sean significativos para esos tipos. Las clases derivadas que requieren un control sobre el formato de ToString proporciona puede implementar la IFormattable interfaz. Su IFormattable.ToString(String, IFormatProvider) método le permite definir cadenas de formato que controlan el formato y usar un IFormatProvider objeto que puede proporcionar el formato específico de la referencia cultural.

Invalidaciones de la ToString método debe seguir estas directrices:

  • La cadena devuelta debe ser descriptivo y legible por el ojo humano.

  • La cadena devuelta debe identificar el valor de la instancia del objeto.

  • La cadena devuelta debe ser lo más corta posible para que sea apropiado para la presentación por un depurador.

  • Su ToString invalidación no debe devolver String.Empty o una cadena nula.

  • Su ToString invalidación no debería producir una excepción.

  • Si la representación de cadena de una instancia de la referencia cultural o se puede aplicar formato de varias maneras, implementar la IFormattable interfaz.

  • Si la cadena devuelta incluye información confidencial, primero debe solicitar un permiso adecuado. Si la solicitud tiene éxito, puede devolver la información confidencial; de lo contrario, debe devolver una cadena que excluye la información confidencial.

  • Su ToString reemplazo no debe tener efectos secundarios observables para evitar complicaciones en la depuración. Por ejemplo, una llamada a la ToString método no debería cambiar el valor de los campos de instancia.

  • Si el tipo implementa un método de análisis (o Parse o TryParse método, un constructor o algún otro método estático que crea una instancia del tipo de una cadena), debe asegurarse de que la cadena devuelta por la ToString método puede convertirse a una instancia de objeto.

Universal Windows Platform
Disponible desde 8
.NET Framework
Disponible desde 1.1
Portable Class Library
Compatible con: portable .NET platforms
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar:
© 2016 Microsoft