Ten artykuł został przetłumaczony przez maszynę. Aby wyświetlić jego treść w języku angielskim, zaznacz pole wyboru Angielski. Możesz też wyświetlić angielski tekst w okienku wyskakującym, przesuwając wskaźnik myszy nad konkretny tekst”.
Tłumaczenie
Angielski

Metoda Object.ToString — ()

.NET Framework (current version)
 

Data opublikowania: październik 2016

Zwraca łańcuch znaków, reprezentujący aktualny obiekt.

Przestrzeń nazw:   System
Zestaw:  mscorlib (w mscorlib.dll)

public virtual string ToString()

Wartość zwracana

Type: System.String

Ciąg, który reprezentuje bieżący obiekt.

Object.ToString głównych formatuje metoda w programie .NET Framework. Konwertuje obiekt na jego reprezentację ciągu, aby była odpowiednia dla ekranu. (Informacje na temat formatowania pomocy technicznej w programie .NET Framework, zobacz Typy formatowania w programie .NET Framework.) Domyślne implementacje Object.ToString Metoda zwraca pełną nazwę typu obiektu.

System_CAPS_importantWażne

Możliwe, że osiągnięto tej strony, klikając łącze z listy elementów członkowskich innego typu. Wynika to z tego typu nie zastępuje Object.ToString. Zamiast tego, dziedziczy funkcje Object.ToString metody.

Typy często zastąpienie Object.ToString metodę, aby zapewnić bardziej odpowiedni ciąg reprezentujący określonego typu. Typy również często przeciążenia Object.ToString metoda zapewnia obsługę ciągi formatu lub kulturowych formatowania.

W tej sekcji:

Domyślną metodą Object.ToString()
Zastępowanie metody Object.ToString()
Przeciążenie metody ToString
Rozszerzanie metoda Object.ToString
Uwagi dla środowiska wykonawczego systemu Windows

Domyślna implementacja ToString Metoda zwraca w pełni kwalifikowana nazwa typ Object, jak pokazano w poniższym przykładzie.

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

Ponieważ Object jest klasą podstawową wszystkich typów odwołań w programie .NET Framework to zachowanie jest dziedziczona przez typy odwołań, które nie zastępują ToString metody. W poniższym przykładzie pokazano to. Definiuje klasę o nazwie Object1 która akceptuje Domyślna implementacja wszystkich Object elementów członkowskich. Jego ToString Metoda zwraca obiekt w pełni kwalifikowanej nazwy typu.

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

Typy powszechnie zastąpienie Object.ToString Metoda zwraca ciąg, który reprezentuje wystąpienie obiektu. Na przykład, takich jak podstawowe typy Char, Int32, i String zapewniają ToString implementacje zwracanych w postaci ciągu wartości, który reprezentuje obiekt. W poniższym przykładzie zdefiniowano klasę, Object2, która zastępuje ToString metodę, aby zwrócić nazwę typu wraz z jego wartość.

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

W poniższej tabeli wymieniono kategorie typu w programie .NET Framework i wskazuje, czy zastępują one Object.ToString metody.

Typ kategorii

Zastępuje Object.ToString()

Zachowanie

Class

n/d

n/d

Struktura

Tak (ValueType.ToString)

Takie same jak Object.ToString()

Wyliczenie

Tak (Enum.ToString())

Nazwa elementu członkowskiego

Interface

Nie

n/d

Delegate

Nie

n/d

Zobacz uwagi dotyczące obiektów dziedziczących sekcji, aby uzyskać dodatkowe informacje na zastępowanie ToString.

Oprócz zastępowania bezparametrowego Object.ToString() przeciążenia wiele typów metody, ToString Metoda zapewnienie wersji metody, które akceptują parametrów. Najczęściej jest to zapewnia obsługę formatowanie zmiennych i formatowanie kulturowych.

Następujący przykład przeciążeń ToString Metoda zwraca ciąg wyniku zawierający wartość z różnymi polami Automobile klasy. Definiuje cztery ciągi formatu: G, która zwraca nazwę modelu i roku; D, która zwraca nazwę modelu, roku i liczba drzwi; C, która zwraca nazwę modelu, roku i liczba cylindrów; i A, która zwraca ciąg zawierający wszystkie wartości czterech pól.

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

Poniższy przykład wywołuje przeciążonych Decimal.ToString(String, IFormatProvider) Wyświetla kulturowych formatowania wartości waluty.

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

Aby uzyskać więcej informacji na ciągi formatów i kulturowych formatowania, zobacz Typy formatowania w programie .NET Framework. Dla ciągów formatu obsługiwanych przez wartości liczbowych, zobacz Standard Numeric Format Strings i Custom Numeric Format Strings. Dla ciągów formatu obsługiwanych przez wartości daty i godziny, zobacz Standardowa ciągów daty i godziny Format i niestandardowe ciągi daty i godziny Format.

Ponieważ typ dziedziczy domyślnie Object.ToString Metoda, można znaleźć jego zachowanie niepożądanych i chcesz je zmienić. Jest to szczególnie istotne, tablice i klasy kolekcji. Gdy może oczekiwać ToString Metoda klasy tablicy lub kolekcji do wyświetlenia wartości jego członków, zamiast tego zawiera typ w pełni kwalifikowana nazwa typu, jak pokazano w poniższym przykładzie.

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]

Istnieje kilka możliwości do ciągu wynikowego, który chcesz utworzyć.

  • Jeśli typem jest tablica, obiekt kolekcji lub obiekt, który implementuje IEnumerable lub IEnumerable<T> interfejsów, jego elementy można wyliczyć przy użyciu foreach instrukcji w języku C# lub For Each...Next konstruowania w języku Visual Basic.

  • Jeśli klasa nie jest sealed (w języku C#) lub NotInheritable (w języku Visual Basic), można utworzyć klasy otoki, która dziedziczy z klasy podstawowej, których Object.ToString Metoda ma zostać dostosowany. Co najmniej wymaga, należy wykonać następujące czynności:

    1. Implementowanie wszelkie niezbędne konstruktorów. Klasy pochodne nie dziedziczą ich Konstruktory klasy podstawowej.

    2. Zastąpienie Object.ToString Metoda zwraca ciąg wynik, który ma zostać.

    W poniższym przykładzie zdefiniowano klasę otoki dla List<T> klasy. Zastępuje ona Object.ToString metodę, aby wyświetlić wartość każdej metody kolekcji, a nie w pełni kwalifikowana nazwa typu.

    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
    
  • Twórz Metoda rozszerzenia zwracającą ciąg wyniku, który ma. Należy zauważyć, że nie można zastąpić domyślną Object.ToString Metoda w ten sposób (, Twojego rozszerzenia klasy (w języku C#) lub modułu (w języku Visual Basic) nie może mieć bez parametrów metody o nazwie ToString jest to zamiast oryginalnego typu ToString metody. Musisz podać inną nazwę dla użytkownika bez parametrów ToString zastępczy.

    W poniższym przykładzie zdefiniowano dwie metody, które rozszerzają List<T> klasy: bezparametrowego ToString2 metody i ToString metody z String parametr, który reprezentuje ciągu formatu.

    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 }
    

Gdy zostanie wywołana ToString metody w klasie w Środowisko wykonawcze systemu Windows, zapewnia domyślne zachowanie dla klas, które nie powoduje zmiany ToString. Jest to część obsługi, który .NET Framework zapewnia Środowisko wykonawcze systemu Windows (zobacz Obsługa .NET Framework dla aplikacji sklepu Windows Store i środowiska wykonawczego systemu Windows). Klasy w Środowisko wykonawcze systemu Windows nie dziedziczą Object, a nie zawsze implementują ToString. Jednak zawsze pojawiają się mieć ToString, Equals(Object), i GetHashCode metody można użyć w kodzie języka C# lub Visual Basic, gdy program .NET Framework oferuje domyślne zachowanie dla tych metod.

Począwszy od .NET Framework 4.5.1, będą używane środowisko uruchomieniowe języka wspólnego IStringable.ToString na Środowisko wykonawcze systemu Windows obiekt przed powrotem do Domyślna implementacja Object.ToString.

System_CAPS_noteUwaga

Środowisko wykonawcze systemu Windows klasy, które zostały napisane w języku C# lub Visual Basic można zastąpić ToString metody.

Począwszy od Windows 8.1, Środowisko wykonawcze systemu Windows obejmuje IStringable których jednej metody interfejsu IStringable.ToString, zapewnia podstawową obsługę formatowania porównywalne dostarczony przez Object.ToString. Aby uniknąć niejednoznaczności, nie należy implementować IStringable na typy zarządzane.

Kiedy zarządzane obiekty są wywoływane przez kod natywny lub kodu napisanego w językach takich jak JavaScript lub C + +/ CX, pojawią się do zaimplementowania IStringable. Środowisko uruchomieniowe języka wspólnego będzie automatycznie rozesłać wywołania z IStringable.ToString do Object.ToString w zdarzeniu IStringable nie została zaimplementowana do zarządzanego obiektu.

System_CAPS_warningOstrzeżenie

Ponieważ środowisko uruchomieniowe języka wspólnego auto implementuje IStringable dla wszystkich typów w zarządzanych Sklep Windows aplikacji, firma Microsoft zaleca, że nie podano własne IStringable implementacji. Implementowanie IStringable może spowodować niezamierzone zachowanie podczas wywoływania ToString z Środowisko wykonawcze systemu Windows, C + +/ CX lub JavaScript.

Jeśli zostanie wybrana do zaimplementowania IStringable w publicznych typu zarządzanego wyeksportowany w Środowisko wykonawcze systemu Windows składnika, obowiązują następujące ograniczenia:

  • Można zdefiniować IStringable interfejsu tylko w relacji "klasy implementuje", takich jak

    public class NewClass : IStringable
    

    w języku C# lub

    Public Class NewClass : Implements IStringable
    

    w języku Visual Basic.

  • Nie można zaimplementować IStringable w interfejsie.

  • Nie można zadeklarować parametr będzie typu IStringable.

  • IStringable nie może być typem zwracanym metoda, właściwość lub pole.

  • Nie można ukryć swoje IStringable implementacja klas podstawowych za pomocą definicji metody, takich jak następujące:

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

    Zamiast tego IStringable.ToString musi zawsze zastąpić implementacji klasy podstawowej. Można ukryć ToString implementacji tylko za pomocą wywołania go w wystąpieniu silnie typizowanej klasy.

Należy zauważyć, że w różnych warunkach, wywołania z kodu macierzystego typu zarządzanego, który implementuje IStringable lub ukrywa jej ToString implementacja może spowodować nieoczekiwane zachowanie.

Uwagi dotyczące obiektów dziedziczących:

W przypadku implementowania własnych typów, należy zastąpić ToString metody do zwracania wartości, które powinny być opisowe dla tych typów. Pochodne klasy, które wymagają większą kontrolę nad formatowaniem niż ToString zapewnia można zaimplementować IFormattable interfejsu. Jego IFormattable.ToString(String, IFormatProvider) Metoda umożliwia definiowanie ciągów formatu, które kontrolują, formatowanie i użyć IFormatProvider obiekt, który można podać formatowania specyficznych dla kultury.

Zastępuje z ToString Metoda należy przestrzegać następujących wytycznych:

  • Zwracanego ciągu powinna być przyjazny i do odczytu przez ludzi.

  • Zwrócony ciąg musi jednoznacznie wskazywać wartość wystąpienia obiektu.

  • Zwracanego ciągu powinna być możliwie krótki, dzięki czemu jest ona odpowiednia dla wyświetlane przez debuger.

  • Twoje ToString zastąpienie nie powinny zwracać String.Empty lub ciąg pusty.

  • Twoje ToString zastąpienie nie powinien zgłosić wyjątek.

  • Jeśli ciąg reprezentujący wystąpienie jest uwzględniana kultura, mogą być sformatowane na różne sposoby zaimplementowania IFormattable interfejsu.

  • Jeśli zwracanego ciągu zawiera poufne informacje, należy najpierw zażądać odpowiednie uprawnienia. Jeśli żądanie zakończy się powodzeniem, może zwrócić informacji poufnych; w przeciwnym razie ma zwracać ciąg, który nie obejmuje poufne informacje.

  • Twoje ToString zastąpienie powinien mieć nie dostrzegalnych efekty uboczne, aby uniknąć komplikacji w debugowaniu. Na przykład, wywołanie ToString Metoda nie należy zmieniać wartości pól wystąpień.

  • Jeśli z danym typem implementuje metody analizy (lub Parse lub TryParse Metoda, Konstruktor lub niektóre statyczną metodę, która tworzy wystąpienie typu z ciągu), należy upewnić się, że ciąg zwracany przez ToString metody mogą być konwertowane na wystąpienie obiektu.

Platforma uniwersalna systemu Windows
Dostępne od 8
.NET Framework
Dostępne od 1.1
Biblioteka klas przenośnych
Obsługiwane w: przenośne platformy .NET
Silverlight
Dostępne od 2.0
Windows Phone Silverlight
Dostępne od 7.0
Windows Phone
Dostępne od 8.1
Powrót do początku
Pokaż: