Object.ToString Method

Definition

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. Returns a string that represents the current object.

public virtual string ToString ();
Gibt zurück

Eine Zeichenfolge, die das aktuelle Objekt darstellt. A string that represents the current object.

Hinweise

Object.ToString ist die wichtigsten-Methode in der .NET Framework formatieren.Object.ToString is the major formatting method in the .NET Framework. Konvertiert ein Objekt in seine Zeichenfolgendarstellung, damit es für die Anzeige geeignet ist.It converts an object to its string representation so that it is suitable for display. (Weitere Informationen zur Formatierung-Unterstützung in .NET Framework finden Sie unter Formatierung von Typen.) Standardimplementierungen der der Object.ToString Methode zurück, der vollqualifizierte Name, der den Typ des Objekts.(For information about formatting support in the .NET Framework, see Formatting Types.) Default implementations of the Object.ToString method return the fully qualified name of the object's type.

Wichtig

Sie können diese Seite erreicht, über den Link aus der Memberliste eines anderen Typs.You may have reached this page by following the link from the member list of another type. Dies liegt daran dieses Typs nicht überschreibt Object.ToString.That is because that type does not override Object.ToString. Stattdessen erbt es die Funktionalität der Object.ToString Methode.Instead, it inherits the functionality of the Object.ToString method.

Typen, die häufig überschreiben die Object.ToString Methode, um ein geeigneter Zeichenfolgendarstellung eines bestimmten Typs bereitzustellen.Types frequently override the Object.ToString method to provide a more suitable string representation of a particular type. Typen auch häufig überladen der Object.ToString Methode, um die Formatzeichenfolgen oder kulturabhängige Formatierung zu unterstützen.Types also frequently overload the Object.ToString method to provide support for format strings or culture-sensitive formatting.

In diesem AbschnittIn this section:

Die Standardmethode für die Object.ToString() The default Object.ToString() method
Überschreiben der Object.ToString()-Methode Overriding the Object.ToString() method
Überladen die ToString-Methode Overloading the ToString method
Erweitern Sie die Object.ToString-Methode Extending the Object.ToString method
Anmerkungen zu dieser Version für die Windows-RuntimeNotes for the Windows Runtime

Die Standardmethode für die Object.ToString()The default Object.ToString() method

Die standardmäßige Implementierung des der ToString Methode gibt den vollqualifizierten Namen des Typs von der Object, wie im folgende Beispiel gezeigt.The default implementation of the ToString method returns the fully qualified name of the type of the Object, as the following example shows.

using namespace System;

void main()
{
   Object^ obj = gcnew Object();
   Console::WriteLine(obj->ToString());
}
// The example displays the following output:
//      System.Object
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
Module Example
   Public Sub Main()
      Dim obj As New Object()
      Console.WriteLine(obj.ToString())
   End Sub
End Module
' The example displays the following output:
'      System.Object

Da Object ist die Basisklasse aller Verweistypen in .NET Framework wird dieses Verhalten von Verweistypen, die nicht außer Kraft setzen geerbt der ToString Methode.Because Object is the base class of all reference types in the .NET Framework, this behavior is inherited by reference types that do not override the ToString method. Dies wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this. Es definiert eine Klasse namens Object1 , akzeptiert die standardmäßige Implementierung aller Object Member.It defines a class named Object1 that accepts the default implementation of all Object members. Die ToString Methode gibt den vollqualifizierten Typnamen des Objekts zurück.Its ToString method returns the object's fully qualified type name.

using namespace System;

namespace Examples
{
   ref class Object1
   {
   };
}

void main()
{
   Object^ obj1 = gcnew Examples::Object1();
   Console::WriteLine(obj1->ToString());
}
// The example displays the following output:
//   Examples.Object1
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
Imports Examples

Namespace Examples
   Public Class Object1
   End Class
End Namespace

Module Example
   Public Sub Main()
      Dim obj1 As New Object1()
      Console.WriteLine(obj1.ToString())
   End Sub
End Module
' The example displays the following output:
'   Examples.Object1

Überschreiben der Object.ToString()-MethodeOverriding the Object.ToString() method

Überschreiben Sie die Typen im Allgemeinen die Object.ToString Methode, um eine Zeichenfolge zurückzugeben, die die Objektinstanz darstellt.Types commonly override the Object.ToString method to return a string that represents the object instance. Beispielsweise Basistypen wie z. B. Char, Int32, und String bieten ToString Implementierungen, die die Zeichenfolgendarstellung des Werts zurückzugeben, die das Objekt darstellt.For example, the base types such as Char, Int32, and String provide ToString implementations that return the string form of the value that the object represents. Das folgende Beispiel definiert eine Klasse, Object2, überschreibt die ToString Methode, um den Typnamen zusammen mit seinem Wert zurückzugeben.The following example defines a class, Object2, that overrides the ToString method to return the type name along with its value.

using namespace System;

ref class Object2
{
   private:
      Object^ value;

   public:
      Object2(Object^ value)
      {
         this->value = value;
      }

      virtual String^ ToString() override
      {
         return Object::ToString() + ": " + value->ToString();
      }
};

void main()
{
   Object2^ obj2 = gcnew Object2(L'a');
   Console::WriteLine(obj2->ToString());
 
}
// The example displays the following output:
//       Object2: a
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
Public Class Object2
   Private value As Object
   
   Public Sub New(value As Object)
      Me.value = value
   End Sub
   
   Public Overrides Function ToString() As String
      Return MyBase.ToString + ": " + value.ToString()
   End Function
End Class

Module Example
   Public Sub Main()
      Dim obj2 As New Object2("a"c)
      Console.WriteLine(obj2.ToString())
   End Sub
End Module
' The example displays the following output:
'       Object2: a

Die folgende Tabelle listet die Kategorien in .NET Framework und gibt an, und zwar unabhängig davon, ob sie überschreiben die Object.ToString Methode.The following table lists the type categories in the .NET Framework and indicates whether or not they override the Object.ToString method.

TypkategorieType category Außerkraftsetzungen Object.ToString()Overrides Object.ToString() VerhaltenBehavior
KlasseClass n/vn/a n/vn/a
StrukturStructure Ja (ValueType.ToString)Yes (ValueType.ToString) Identisch mit Object.ToString()Same as Object.ToString()
EnumerationEnumeration Ja (Enum.ToString())Yes (Enum.ToString()) Den Namen des MembersThe member name
InterfaceInterface NeinNo n/vn/a
delegateDelegate NeinNo n/vn/a

Finden Sie die Hinweise für Vererber-Abschnitt, um weitere Informationen zum Überschreiben ToString.See the Notes to Inheritors section for additional information on overriding ToString.

Überladen die ToString-MethodeOverloading the ToString method

Zusätzlich zum Überschreiben der parameterlosen Object.ToString() Methode überladen, viele Arten der ToString Methode, um Versionen der-Methode bereitzustellen, die Parameter akzeptieren.In addition to overriding the parameterless Object.ToString() method, many types overload the ToString method to provide versions of the method that accept parameters. Dies erfolgt in den meisten Fällen um für die Variable Formatierung und kulturabhängige Formatierung zu unterstützen.Most commonly, this is done to provide support for variable formatting and culture-sensitive formatting.

Das folgende Beispiel überlädt die ToString Methode, um eine Ergebniszeichenfolge zurückzugeben, die den Wert verschiedener Felder dieses enthält ein Automobile Klasse.The following example overloads the ToString method to return a result string that includes the value of various fields of an Automobile class. Er definiert vier Formatzeichenfolgen: G, die den Modellnamen und Jahr zurückgibt. D, die den Modellnamen, Jahr und Anzahl von Türen zurückgibt; C, die den Modellnamen, Jahr und Anzahl der Zylinder zurückgibt; und ein, die eine Zeichenfolge mit allen vier Feldwerten zurückgibt.It defines four format strings: G, which returns the model name and year; D, which returns the model name, year, and number of doors; C, which returns the model name, year, and number of cylinders; and A, which returns a string with all four field values.

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
Public Class Automobile
   Private _doors As Integer
   Private _cylinders As String
   Private _year As Integer
   Private _model As String
   
   Public Sub New(model As String, year As Integer, doors As Integer,
                  cylinders As String)
      _model = model
      _year = year
      _doors = doors
      _cylinders = cylinders
   End Sub
   
   Public ReadOnly Property Doors As Integer
      Get
          Return _doors
      End Get
   End Property
   
   Public ReadOnly Property Model As String
      Get
         Return _model
      End Get
   End Property
   
   Public ReadOnly Property Year As Integer
      Get
         Return _year
      End Get
   End Property
   
   Public ReadOnly Property Cylinders As String
      Get
         Return _cylinders
      End Get
   End Property
   
   Public Overrides Function ToString() As String
      Return ToString("G")
   End Function
   
   Public Overloads Function ToString(fmt As String) As String
      If String.IsNullOrEmpty(fmt) Then fmt = "G"
      
      Select Case 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)
         Case Else
            Dim msg As String = String.Format("'{0}' is an invalid format string",
                                              fmt)
            Throw New ArgumentException(msg)
      End Select
   End Function
End Class

Module Example
   Public Sub Main()
      Dim auto As New Automobile("Lynx", 2016, 4, "V8")
      Console.WriteLine(auto.ToString())
      Console.WriteLine(auto.ToString("A"))
   End Sub
End Module
' The example displays the following output:
'       2016 Lynx
'       2016 Lynx, 4 dr. V8

Im folgenden Beispiel wird die überladene Decimal.ToString(String, IFormatProvider) Methode, um anzuzeigen, kulturabhängige Formatierung, der einen Währungswert.The following example calls the overloaded Decimal.ToString(String, IFormatProvider) method to display culture-sensitive formatting of a currency value.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "en-GB", "fr-FR",
                                       "hr-HR", "ja-JP" }
      Dim value As Decimal = 1603.49d
      For Each cultureName In cultureNames
         Dim culture As New CultureInfo(cultureName)
         Console.WriteLine("{0}: {1}", culture.Name,
                           value.ToString("C2", culture))
      Next
   End Sub
End Module
' 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

Weitere Informationen zu Formatzeichenfolgen und kulturabhängige Formatierung, finden Sie unter Formatierung von Typen.For more information on format strings and culture-sensitive formatting, see Formatting Types. Die Formatzeichenfolgen, die von numerischen Werten unterstützt, finden Sie unter Standard Numeric Format Strings und Custom Numeric Format Strings.For the format strings supported by numeric values, see Standard Numeric Format Strings and Custom Numeric Format Strings. Die Formatzeichenfolgen, die von Datums-und Uhrzeitwerte unterstützt werden, finden Sie unter Standardformatzeichenfolgen für Datum und Uhrzeit-Formatzeichenfolgen und Custom Date and Time Format Strings.For the format strings supported by date and time values, see Standard Date and Time Format Strings and Custom Date and Time Format Strings.

Erweitern Sie die Object.ToString-MethodeExtending the Object.ToString method

Da der Standardwert erbt Object.ToString -Methode, Sie können finden Sie das Verhalten nicht erwünscht und ihn ändern möchten.Because a type inherits the default Object.ToString method, you may find its behavior undesirable and want to change it. Dies gilt insbesondere für Arrays und Auflistungsklassen.This is particularly true of arrays and collection classes. Während Sie erwarten, dass möglicherweise die ToString Methode ein Array oder eine Auflistung der Klasse zur Anzeige der Werte von Membern, stattdessen wird der vollqualifizierte Typname, wie im folgenden Beispiel gezeigt.While you may expect the ToString method of an array or collection class to display the values of its members, it instead displays the type fully qualified type name, as the following example shows.

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]
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim values() As Integer = { 1, 2, 4, 8, 16, 32, 64, 128 }
      Console.WriteLine(values.ToString())
      
      Dim list As New List(Of Integer)(values)
      Console.WriteLine(list.ToString())
   End Sub
End Module
' The example displays the following output:
'    System.Int32[]
'    System.Collections.Generic.List`1[System.Int32]

Sie haben mehrere Optionen für die resultierende Zeichenfolge zu erzeugen, die Sie möchten.You have several options to produce the result string that you'd like.

  • Wenn der Typ ist ein Array, ein Auflistungsobjekt oder ein Objekt, das implementiert der IEnumerable oder IEnumerable<T> Schnittstellen, Sie können die Elemente auflisten, mit der foreach -Anweisung in c# oder die For Each...Next in Visual Basic erstellen.If the type is an array, a collection object, or an object that implements the IEnumerable or IEnumerable<T> interfaces, you can enumerate its elements by using the foreach statement in C# or the For Each...Next construct in Visual Basic.

  • Wenn die Klasse nicht sealed (in c#) oder NotInheritable (in Visual Basic), können Sie eine Wrapperklasse, die von der Basisklasse, deren erbt entwickeln Object.ToString Methode, die Sie anpassen möchten.If the class is not sealed (in C#) or NotInheritable (in Visual Basic), you can develop a wrapper class that inherits from the base class whose Object.ToString method you want to customize. Mindestens erfordert dies, dass Sie die folgenden Schritte ausführen:At a minimum, this requires that you do the following:

    1. Implementieren Sie alle erforderlichen Konstruktoren.Implement any necessary constructors. Abgeleitete Klassen erben nicht die Konstruktoren ihrer Basisklasse.Derived classes do not inherit their base class constructors.

    2. Überschreiben der Object.ToString Methode, um die Ergebniszeichenfolge zurückzugeben, die Sie möchten.Override the Object.ToString method to return the result string that you'd like.

    Das folgende Beispiel definiert eine Wrapperklasse für die List<T> Klasse.The following example defines a wrapper class for the List<T> class. Es überschreibt die Object.ToString Methode, um den Wert der einzelnen Methoden von der Sammlung anstelle der vollqualifizierte Typname anzuzeigen.It overrides the Object.ToString method to display the value of each method of the collection rather than the fully qualified type name.

    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
    
    Imports System.Collections.Generic
    
    Public Class CList(Of T) : Inherits List(Of T)
       Public Sub New(capacity As Integer)
          MyBase.New(capacity)
       End Sub
    
       Public Sub New(collection As IEnumerable(Of T))
          MyBase.New(collection)
       End Sub
    
       Public Sub New()
          MyBase.New()
       End Sub
    
       Public Overrides Function ToString() As String
          Dim retVal As String = String.Empty
          For Each item As T In Me
             If String.IsNullOrEmpty(retval) Then
                retVal += item.ToString()
             Else
                retval += String.Format(", {0}", item)
             End If
          Next
          Return retVal
       End Function
    End Class
    
    Module Example
       Public Sub Main()
          Dim list2 As New CList(Of Integer)
          list2.Add(1000)
          list2.Add(2000)
          Console.WriteLine(list2.ToString())
       End Sub
    End Module
    ' The example displays the following output:
    '       1000, 2000
    
  • Entwickeln einer Erweiterungsmethode , die die Ergebniszeichenfolge, die Sie möchten zurückgibt.Develop an extension method that returns the result string that you want. Beachten Sie, dass Sie die Standardeinstellung außer Kraft setzen können nicht Object.ToString -Methode in der auf diese Weise (d. h. der Erweiterungsklasse (in c#) oder dem Modul (in Visual Basic) sind keine parameterlose Methode namens ToString , der anstelle des ursprünglichen Typs aufgerufen ToString Methode .Note that you can't override the default Object.ToString method in this way (that is, your extension class (in C#) or module (in Visual Basic) cannot have a parameterless method named ToString that is called in place of the original type's ToString method. Sie müssen einen anderen Namen für Ihre parameterlosen bieten ToString Ersatz.You'll have to provide some other name for your parameterless ToString replacement.

    Das folgende Beispiel definiert zwei Methoden, die erweitert die List<T> Klasse: eine parameterlose ToString2 -Methode, und ein ToString -Methode mit einer String Parameter, der eine Formatzeichenfolge darstellt.The following example defines two methods that extend the List<T> class: a parameterless ToString2 method, and a ToString method with a String parameter that represents a format string.

    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 }
    
    Imports System.Collections.Generic
    Imports System.Runtime.CompilerServices
    
    Public Module StringExtensions
       <Extension()>
       Public Function ToString2(Of T)(l As List(Of T)) As String
          Dim retVal As String = ""
          For Each item As T In l
             retVal += String.Format("{0}{1}", If(String.IsNullOrEmpty(retVal),
                                                         "", ", "),
                                      item)
          Next
          Return If(String.IsNullOrEmpty(retVal), "{}", "{ " + retVal + " }")
       End Function
    
       <Extension()>
       Public Function ToString(Of T)(l As List(Of T), fmt As String) As String
          Dim retVal As String = String.Empty
          For Each item In l
             Dim ifmt As IFormattable = TryCast(item, IFormattable)
             If ifmt IsNot Nothing Then
                retVal += String.Format("{0}{1}",
                                        If(String.IsNullOrEmpty(retval),
                                           "", ", "), ifmt.ToString(fmt, Nothing))
             Else
                retVal += ToString2(l)
             End If
          Next
          Return If(String.IsNullOrEmpty(retVal), "{}", "{ " + retVal + " }")
       End Function
    End Module
    
    Module Example
       Public Sub Main()
          Dim list As New List(Of Integer)
          list.Add(1000)
          list.Add(2000)
          Console.WriteLine(list.ToString2())
          Console.WriteLine(list.ToString("N0"))
       End Sub
    End Module
    ' The example displays the following output:
    '       { 1000, 2000 }
    '       { 1,000, 2,000 }
    

Anmerkungen zu dieser von der Windows-RuntimeWindows RuntimeNotes for the Windows-RuntimeWindows Runtime

Beim Aufrufen der ToString Methode einer Klasse in der Windows-RuntimeWindows Runtime, es ist das Standardverhalten für Klassen, die nicht außer Kraft setzen ToString.When you call the ToString method on a class in the Windows-RuntimeWindows Runtime, it provides the default behavior for classes that don’t override ToString. Dies ist Teil der Unterstützung von .NET Framework für die Windows-RuntimeWindows Runtime (finden Sie unter .NET Framework Unterstützung für Windows Store-Apps und Windows-Runtime).This is part of the support that the .NET Framework provides for the Windows-RuntimeWindows Runtime (see .NET Framework Support for Windows Store Apps and Windows Runtime). Klassen in der Windows-RuntimeWindows Runtime nicht erben Object, und implementieren nicht immer eine ToString.Classes in the Windows-RuntimeWindows Runtime don’t inherit Object, and don’t always implement a ToString. Allerdings sie immer anscheinend ToString, Equals(Object), und GetHashCode Methoden ein, wenn Sie diese in Ihrem C#- oder Visual Basic-Code verwenden und .NET Framework ein Standardverhalten für diese Methoden bietet.However, they always appear to have ToString, Equals(Object), and GetHashCode methods when you use them in your C# or Visual Basic code, and the .NET Framework provides a default behavior for these methods.

Beginnend mit der .NET Framework 4.5.1.NET Framework 4.5.1, verwendet die common Language Runtime IStringable.ToString auf eine Windows-RuntimeWindows Runtime Objekt vor dem Fallback auf die standardmäßige Implementierung des Object.ToString.Starting with the .NET Framework 4.5.1.NET Framework 4.5.1, the common language runtime will use IStringable.ToString on a Windows-RuntimeWindows Runtime object before falling back to the default implementation of Object.ToString.

Hinweis

Windows-RuntimeWindows Runtime Klassen, die in c# oder Visual Basic geschrieben sind, können außer Kraft setzen der ToString Methode. classes that are written in C# or Visual Basic can override the ToString method.

Die Windows-RuntimeWindows Runtime und die IStringable-SchnittstelleThe Windows-RuntimeWindows Runtime and the IStringable Interface

Beginnend mit Windows 8.1Windows 8.1, Windows-RuntimeWindows Runtime enthält ein IStringable Schnittstelle, deren einzige Methode, IStringable.ToString, eine grundlegende formatierungsunterstützung vergleichbar mit der bietet von bereitgestellten Object.ToString.Starting with Windows 8.1Windows 8.1, the Windows-RuntimeWindows Runtime includes an IStringable interface whose single method, IStringable.ToString, provides basic formatting support comparable to that provided by Object.ToString. Sie sollten nicht implementieren, um Mehrdeutigkeit zu vermeiden, IStringable für verwaltete Typen.To prevent ambiguity, you should not implement IStringable on managed types.

Wenn verwaltete Objekte heißen durch systemeigenen Code oder durch Code in Sprachen wie JavaScript oder C++ / CX können sie sich wie implementieren IStringable.When managed objects are called by native code or by code written in languages such as JavaScript or C++/CX, they appear to implement IStringable. Die common Language Runtime leitet automatisch Aufrufe von IStringable.ToString zu Object.ToString im IStringable ist für das verwaltete Objekt nicht implementiert.The common language runtime will automatically route calls from IStringable.ToString to Object.ToString in the event IStringable is not implemented on the managed object.

Warnung

Da die common Language Runtime automatisch-implementiert IStringable für alle verwalteten Typen im Windows StoreWindows Store -apps, es wird empfohlen, dass Sie keine eigene haben IStringable Implementierung.Because the common language runtime auto-implements IStringable for all managed types in Windows StoreWindows Store apps, we recommend that you do not provide your own IStringable implementation. Implementieren von IStringable strafbar unerwartetem Verhalten beim Aufrufen von ToString aus der Windows-RuntimeWindows Runtime, C++ / CX oder JavaScript.Implementing IStringable may result in unintended behavior when calling ToString from the Windows-RuntimeWindows Runtime, C++/CX, or JavaScript.

Wenn Sie sich entschließen, implementieren Sie IStringable in einem öffentlich verwalteten Typ, der im exportiert wird eine Windows-RuntimeWindows Runtime -Komponente, die folgenden Einschränkungen gelten:If you do choose to implement IStringable in a public managed type that is exported in a Windows-RuntimeWindows Runtime component, the following restrictions apply:

  • Sie können definieren, die IStringable -Schnittstelle nur in einer "class Implements"-Beziehung, z. B.You can define the IStringable interface only in a "class implements" relationship, such as

    public class NewClass : IStringable  
    

    in C# oderin C#, or

    Public Class NewClass : Implements IStringable  
    

    in Visual Basic.in Visual Basic.

  • Sie können nicht implementieren IStringable auf einer Schnittstelle.You cannot implement IStringable on an interface.

  • Sie können einen Parameter vom Typ nicht deklarieren IStringable.You cannot declare a parameter to be of type IStringable.

  • IStringable darf nicht der Rückgabetyp einer Methode, eine Eigenschaft oder ein Feld sein.IStringable cannot be the return type of a method, property, or field.

  • Sie können nicht ausgeblendet werden Ihre IStringable Implementierung von Basisklassen mithilfe eine Methodendefinition wie die folgende:You cannot hide your IStringable implementation from base classes by using a method definition such as the following:

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

    Stattdessen die IStringable.ToString Implementierung muss die basisklassenimplementierung immer überschreiben.Instead, the IStringable.ToString implementation must always override the base class implementation. Sie können eine ToString-Implementierung nur ausblenden, indem Sie sie auf einer stark typisierten Klasseninstanz aufrufen.You can hide a ToString implementation only by invoking it on a strongly typed class instance.

Beachten Sie, die unter einer Vielzahl von Bedingungen Aufrufe von nativem Code zu einem verwalteten Typ, der implementiert IStringable oder blendet Sie aus der ToString Implementierung kann zu unerwartetem Verhalten führen.Note that under a variety of conditions, calls from native code to a managed type that implements IStringable or hides its ToString implementation can produce unexpected behavior.

Hinweise für Vererber

Wenn Sie Ihre eigenen Typen implementieren, sollten Sie Sie überschreiben die ToString() Methode zum Zurückgeben von Werten, die für diese Typen von Bedeutung sind. Abgeleitete Klassen, die mehr Kontrolle über die Formatierung als erfordern ToString() bietet können implementieren die IFormattable Schnittstelle. Die ToString(String, IFormatProvider) Methode ermöglicht es Ihnen, die Formatzeichenfolgen zu definieren, die die Formatierung steuern und Verwenden einer IFormatProvider -Objekt, das für die kulturabhängige Formatierung bereitstellen kann. Der überschreibt die ToString() Methode sollte die folgenden Richtlinien:-die zurückgegebene Zeichenfolge sollte sein, benutzerfreundliche und von Menschen gelesen werden. -Die zurückgegebene Zeichenfolge sollte den Wert der Objektinstanz eindeutig identifizieren. -Die zurückgegebene Zeichenfolge sollte so kurz wie möglich sein, damit es für die Anzeige von einem Debugger geeignet ist. -Für Ihre ToString() außer Kraft setzen sollten keine zurückgeben Empty oder ein null-Zeichenfolge. -Für Ihre ToString() außer Kraft setzen sollte keine Ausnahme ausgelöst. – Wenn die angegebene Zeichenfolgendarstellung einer Instanz kulturabhängig ist oder auf verschiedene Weise formatiert werden kann, implementieren die IFormattable Schnittstelle. – Wenn die zurückgegebene Zeichenfolge vertrauliche Informationen enthält, sollten Sie zunächst eine entsprechende Berechtigung anfordern. Wenn die Anforderung erfolgreich ist, können Sie die vertrauliche Informationen zurückgegeben wird. Andernfalls sollten Sie eine Zeichenfolge zurückgeben, die vertrauliche Informationen ausschließt. -Für Ihre ToString() außer Kraft setzen müssen keine wahrnehmbaren Nebeneffekte zu schwierigkeiten beim Debuggen zu vermeiden. Z. B. einen Aufruf der ToString() Methode sollte den Wert der Instanzfelder nicht ändern. – Wenn der Typ eine Analysemethode implementiert (oder Parse oder TryParse -Methode, einen Konstruktor oder eine andere statische Methode, die eine Instanz des Typs aus einer Zeichenfolge instanziiert), Sie sollten sicherstellen, dass die zurückgegebene Zeichenfolge den ToString() Methode kann sein, Konvertiert eine Objektinstanz.

When you implement your own types, you should override the ToString() method to return values that are meaningful for those types. Derived classes that require more control over formatting than ToString() provides can implement the IFormattable interface. Its ToString(String, IFormatProvider) method enables you to define format strings that control formatting and to use an IFormatProvider object that can provide for culture-specific formatting. Overrides of the ToString() method should follow these guidelines: - The returned string should be friendly and readable by humans. - The returned string should uniquely identify the value of the object instance. - The returned string should be as short as possible so that it is suitable for display by a debugger. - Your ToString() override should not return Empty or a null string. - Your ToString() override should not throw an exception. - If the string representation of an instance is culture-sensitive or can be formatted in multiple ways, implement the IFormattable interface. - If the returned string includes sensitive information, you should first demand an appropriate permission. If the demand succeeds, you can return the sensitive information; otherwise, you should return a string that excludes the sensitive information. - Your ToString() override should have no observable side effects to avoid complications in debugging. For example, a call to the ToString() method should not change the value of instance fields. - If your type implements a parsing method (or Parse or TryParse method, a constructor, or some other static method that instantiates an instance of the type from a string), you should ensure that the string returned by the ToString() method can be converted to an object instance.

Gilt für: