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

Definition

返回表示当前对象的字符串。 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

Returns

表示当前对象的字符串。 A string that represents the current object.

Remarks

Object.ToString 主版本号,格式设置.NET Framework 中的方法。Object.ToString 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 重写 object.tostring ()Overrides Object.ToString() 行为Behavior
Class n/an/a n/an/a
结构Structure 是 (ValueType.ToString)Yes (ValueType.ToString) Object.tostring () 相同Same as Object.ToString()
枚举Enumeration 是 (Enum.ToString())Yes (Enum.ToString()) 成员名称The member name
接口Interface No n/an/a
委托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,它将返回模型名称、 两年和柱面;和一个,它将返回所有四个字段值的字符串。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.

  • 如果类型是数组、 集合对象或实现的对象IEnumerableIEnumerable<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,将使用公共语言运行时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上托管类型。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. 公共语言运行时自动将路由从调用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.

警告

因为公共语言运行时自动实现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中导出的公共托管类型中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  
    

    in C#, or

    Public Class NewClass : Implements IStringable  
    

    口。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.

请注意,在各种条件下对实现的托管类型的本机代码中调用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.

Notes to Inheritors

当实现你自己的类型时,应重写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. -如果你的类型实现分析方法 (或ParseTryParse方法、 构造函数或某些其他实例化从字符串类型的实例的静态方法),应确保返回的字符串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.

Applies to

See Also