Object.ToString Object.ToString Object.ToString Object.ToString Method

定義

傳回代表目前物件的字串。Returns a string that represents the current object.

public:
 virtual System::String ^ ToString();
public virtual string ToString ();
abstract member ToString : unit -> string
override this.ToString : unit -> string
Public Overridable Function ToString () As String

傳回

表示目前物件的字串。A string that represents the current object.

備註

Object.ToString 主要格式設定.NET Framework 中的方法。is the major formatting method in the .NET Framework. 使其適合顯示,它可以轉換為其字串表示的物件。It converts an object to its string representation so that it is suitable for display. (如需.NET Framework 中的支援的格式資訊,請參閱格式化型別。)預設實作Object.ToString方法傳回的物件型別的完整的名稱。(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.

重要

您可以依照下列連結,從另一種類型的成員清單到達此頁面。You may have reached this page by following the link from the member list of another type. 這是因為該類型不覆寫Object.ToStringThat is because that type does not override Object.ToString. 相反地,它所繼承的功能Object.ToString方法。Instead, it inherits the functionality of the Object.ToString method.

經常覆寫類型Object.ToString方法,以提供更適合的字串表示,特定的類型。Types frequently override the Object.ToString method to provide a more suitable string representation of a particular type. 型別也經常多載Object.ToString方法,以提供支援的格式字串,或區分文化特性格式。Types also frequently overload the Object.ToString method to provide support for format strings or culture-sensitive formatting.

本節內容:In this section:

預設 object.tostring () 方法The default Object.ToString() method
覆寫 object.tostring () 方法Overriding the Object.ToString() method
ToString 方法多載化Overloading the ToString method
擴充 Object.ToString 方法Extending the Object.ToString method
Windows 執行階段的相關資訊Notes for the Windows Runtime

預設 object.tostring () 方法The default Object.ToString() method

預設實作ToString方法會傳回之型別的完整格式的名稱Object,如下列範例所示。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

因為Object的基底類別的所有參考型別在.NET Framework 中,此行為由參考型別,不會覆寫繼承ToString方法。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. 下列範例將說明這點。The following example illustrates this. 它會定義名為類別Object1它會接受所有的預設實作Object成員。It defines a class named Object1 that accepts the default implementation of all Object members. ToString方法會傳回物件的完整型別名稱。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

覆寫 object.tostring () 方法Overriding the Object.ToString() method

型別通常覆寫Object.ToString方法來傳回字串,表示物件執行個體。Types commonly override the Object.ToString method to return a string that represents the object instance. 例如,基底類型,例如CharInt32,並String提供ToString傳回該物件所代表之值的字串形式的實作。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. 下列範例會定義類別Object2,會覆寫ToString方法,以傳回型別名稱和其值。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

下表列出.NET Framework 中的類型分類,並指出是否在覆寫Object.ToString方法。The following table lists the type categories in the .NET Framework and indicates whether or not they override the Object.ToString method.

型別分類Type category Overrides Object.ToString()Overrides Object.ToString() 行為Behavior
類別Class N/An/a N/An/a
結構Structure Yes (ValueType.ToString) 相同 object.tostring ()Same as Object.ToString()
列舉Enumeration Yes (Enum.ToString()) 成員名稱The member name
介面Interface No N/An/a
Delegate - 委派Delegate No N/An/a

請參閱注意事項繼承者注意事項 > 一節,如需詳細資訊,在覆寫ToStringSee the Notes to Inheritors section for additional information on overriding ToString.

ToString 方法多載化Overloading the ToString method

除了無參數的覆寫Object.ToString()方法中,許多型別多載ToString方法,以提供的方法接受參數的版本。In addition to overriding the parameterless Object.ToString() method, many types overload the ToString method to provide versions of the method that accept parameters. 大多數情況下,這是為了提供變數的格式和區分文化特性的格式化支援。Most commonly, this is done to provide support for variable formatting and culture-sensitive formatting.

下列範例會多載ToString方法,以傳回結果字串,其中包含的各種欄位的值Automobile類別。The following example overloads the ToString method to return a result string that includes the value of various fields of an Automobile class. 它會定義四個格式字串:G,會傳回年份; 與模型名稱D,傳回模型名稱、 年和機門; 數目C,傳回模型名稱、 年的磁柱; 數目和 A,它會傳回所有的四個欄位值的字串。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

下列範例會呼叫多載Decimal.ToString(String, IFormatProvider)方法來顯示文化特性的貨幣值的格式。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

如需有關格式字串和文化特性格式的詳細資訊,請參閱格式化型別For more information on format strings and culture-sensitive formatting, see Formatting Types. 針對支援的數值格式字串,請參閱標準數值格式字串自訂數值格式字串For the format strings supported by numeric values, see Standard Numeric Format Strings and Custom Numeric 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.

擴充 Object.ToString 方法Extending the Object.ToString method

因為型別會繼承預設Object.ToString方法中,您可以找到它的行為不想要並想要加以變更。Because a type inherits the default Object.ToString method, you may find its behavior undesirable and want to change it. 這是特別的陣列和集合類別。This is particularly true of arrays and collection classes. 雖然您可能會預期ToString方法的陣列或集合類別,以顯示其成員的值,它改為顯示類型的完整型別名稱,如下列範例所示。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]

您有數個選項,以產生您想要的結果字串。You have several options to produce the result string that you'd like.

  • 如果類型是陣列、 集合物件或該物件會實作IEnumerable或是IEnumerable<T>介面,您可以使用,以列舉其項目foreachC# 中的陳述式或For Each...Next建構在 Visual Basic 中。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.

  • 如果類別不是sealed(在 C# 中) 或NotInheritable(在 Visual Basic 中),您可以開發其繼承自基底類別的包裝函數類別Object.ToString您想要自訂的方法。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. 至少,這需要您下列:At a minimum, this requires that you do the following:

    1. 實作任何所需的建構函式。Implement any necessary constructors. 在衍生的類別不會繼承其基底類別建構函式。Derived classes do not inherit their base class constructors.

    2. 覆寫Object.ToString方法,以傳回您想要的結果字串。Override the Object.ToString method to return the result string that you'd like.

    下列範例會定義包裝函式類別List<T>類別。The following example defines a wrapper class for the List<T> class. 它會覆寫Object.ToString方法,以顯示每個方法的集合,而不是完整的類型名稱的值。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
    
  • 開發擴充方法傳回您想要的結果字串。Develop an extension method that returns the result string that you want. 請注意,您無法覆寫預設值Object.ToString方法,以這種方式 (也就是您的延伸模組類別 (在 C# 中) 或 (在 Visual Basic) 的模組不能有一個名為的無參數方法ToString呼叫取代原始的型別ToString方法.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. 您必須提供一些其他的程式無參數的名稱,ToString取代。You'll have to provide some other name for your parameterless ToString replacement.

    下列範例會定義兩個方法,擴充List<T>類別: 無參數ToString2方法,並ToString方法String表示格式字串參數。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 }
    

資訊 Windows 執行階段Windows RuntimeNotes for the Windows 執行階段Windows Runtime

當您呼叫ToString中之類別的方法Windows 執行階段Windows Runtime,它不會覆寫的類別提供的預設行為ToStringWhen you call the ToString method on a class in the Windows 執行階段Windows Runtime, it provides the default behavior for classes that don't override ToString. 這是.NET Framework 提供的支援之一Windows 執行階段Windows Runtime(請參閱 < .NET Framework 支援的 Windows 市集應用程式和 Windows 執行階段)。This is part of the support that the .NET Framework provides for the Windows 執行階段Windows Runtime (see .NET Framework Support for Windows Store Apps and Windows Runtime). 中的類別Windows 執行階段Windows Runtime不繼承Object,且永遠不要只實作ToStringClasses in the Windows 執行階段Windows Runtime don't inherit Object, and don't always implement a ToString. 不過,它們一律出現有ToStringEquals(Object),和GetHashCode方法時您用於您的 C# 或 Visual Basic 程式碼,和.NET Framework 會提供這些方法中的預設行為。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.

開頭.NET Framework 4.5.1.NET Framework 4.5.1,將會使用 common language runtime IStringable.ToStringWindows 執行階段Windows Runtime再切換回預設實作的物件Object.ToStringStarting with the .NET Framework 4.5.1.NET Framework 4.5.1, the common language runtime will use IStringable.ToString on a Windows 執行階段Windows Runtime object before falling back to the default implementation of Object.ToString.

注意

Windows 執行階段Windows Runtime 類別所撰寫的C#或 Visual Basic 可以覆寫ToString方法。classes that are written in C# or Visual Basic can override the ToString method.

Windows 執行階段Windows Runtime和 IStringable 介面The Windows 執行階段Windows Runtime and the IStringable Interface

開頭Windows 8.1Windows 8.1,則Windows 執行階段Windows Runtime包含IStringable介面方法IStringable.ToString,提供基本格式支援能夠與所提供Object.ToStringStarting with Windows 8.1Windows 8.1, the Windows 執行階段Windows Runtime includes an IStringable interface whose single method, IStringable.ToString, provides basic formatting support comparable to that provided by Object.ToString. 若要避免模稜兩可,您不應該實作IStringable managed 類型上。To prevent ambiguity, you should not implement IStringable on managed types.

受管理的物件由原生程式碼或以 JavaScript 或 C + 等語言撰寫的程式碼的呼叫時 + /CX 中,看起來就像實作IStringableWhen managed objects are called by native code or by code written in languages such as JavaScript or C++/CX, they appear to implement IStringable. Common language runtime 會自動將路由來電IStringable.ToStringObject.ToString在事件IStringable上受管理的物件未實作。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.

警告

因為 common language runtime 自動實作IStringable所有受管理中的型別Windows 市集Windows Store應用程式,我們建議您不要不提供您自己IStringable實作。Because the common language runtime auto-implements IStringable for all managed types in Windows 市集Windows Store apps, we recommend that you do not provide your own IStringable implementation. 實作IStringable呼叫時,可能會導致非預期的行為ToStringWindows 執行階段Windows Runtime, C++/CX 或 JavaScript。Implementing IStringable may result in unintended behavior when calling ToString from the Windows 執行階段Windows Runtime, C++/CX, or JavaScript.

如果您選擇實作IStringable匯出在公用 managed 類型中Windows 執行階段Windows Runtime元件,適用下列限制:If you do choose to implement IStringable in a public managed type that is exported in a Windows 執行階段Windows Runtime component, the following restrictions apply:

  • 您可以定義IStringable介面只能在 「 類別實作 」 關聯性,例如You can define the IStringable interface only in a "class implements" relationship, such as

    public class NewClass : IStringable  
    

    在 C# 中,或in C#, or

    Public Class NewClass : Implements IStringable  
    

    在 Visual Basic 中。in Visual Basic.

  • 您不能實作IStringable介面上。You cannot implement IStringable on an interface.

  • 您不能宣告為類型參數IStringableYou cannot declare a parameter to be of type IStringable.

  • IStringable不可為方法、 屬性或欄位的傳回型別。IStringable cannot be the return type of a method, property, or field.

  • 您無法隱藏您IStringable實作基底類別使用的方法定義,如下所示: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";  
       }  
    }  
    

    相反地, IStringable.ToString實作一律必須覆寫基底類別實作。Instead, the IStringable.ToString implementation must always override the base class implementation. 您只能藉由針對強型別類別執行個體叫用 ToString 實作來隱藏該實作。You can hide a ToString implementation only by invoking it on a strongly typed class instance.

請注意,在各種不同的條件,從原生程式碼於 managed 類型可實作IStringable或隱藏其ToString實作可能會產生非預期的行為。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.

給繼承者的注意事項

當您實作您自己的類型時,您應該覆寫ToString()方法傳回對於這些類型有意義的值。When you implement your own types, you should override the ToString() method to return values that are meaningful for those types. 衍生的類別需要更充分掌控格式比ToString()提供可實作IFormattable介面。Derived classes that require more control over formatting than ToString() provides can implement the IFormattable interface. ToString(String, IFormatProvider)方法可讓您定義控制格式的格式字串,並使用IFormatProvider可以提供特定文化特性的格式化物件。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.

覆寫ToString()方法應遵循這些指導方針: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.

-您ToString()覆寫不應該傳回Empty或 null 字串。- Your ToString() override should not return Empty or a null string.

-您ToString()覆寫不應該擲回例外狀況。- Your ToString() override should not throw an exception.

-如果執行個體的字串表示區分文化特性,或可以多種方式進行格式化,實作IFormattable介面。- 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.

-您ToString()覆寫應該沒有任何可預見的副作用以避免在偵錯的複雜性。- Your ToString() override should have no observable side effects to avoid complications in debugging. 例如,若要呼叫ToString()方法不應該變更執行個體欄位的值。For example, a call to the ToString() method should not change the value of instance fields.

-如果您的型別實作的剖析方法 (或Parse或是TryParse方法、 建構函式或其他靜態方法,從字串型別的執行個體具現化),您應該確保所傳回的字串ToString()方法可以是轉換成物件執行個體。- 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.

適用於

另請參閱