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 のメソッドを書式設定します。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.ToStringします。That 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 はいYes (ValueType.ToString) Object.ToString() と同じSame as Object.ToString()
列挙Enumeration はいYes (Enum.ToString()) メンバー名The member name
InterfaceInterface ×No N/An/a
DelegateDelegate ×No N/An/a

オーバーライドの詳細については、継承クラス「ノートを参照してくださいToStringします。See 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. 次の 4 つの書式指定文字列を定義します G で、モデルの名前と年度; を返します。D で、モデルの名前、year、および; のドアの数を返しますC で、モデルの名前、year、およびシリンダー; の数を返しますA で、すべての 4 つのフィールド値を持つ文字列を返します。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. 書式指定文字列を数値でサポートされている、次を参照してください。 Standard Numeric Format Stringsカスタム数値書式指定文字列します。For the format strings supported by numeric values, see Standard Numeric Format Strings and Custom Numeric Format Strings. 日付と時刻の値でサポートされている書式指定文字列を参照してください。 Standard Date and Time Format StringsCustom 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.

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>インターフェイスを使用してその要素を列挙することができます、 foreach (C#) ステートメントまたはFor Each...NextVisual 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.

    次の例を拡張する 2 つのメソッドを定義する、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、既定の動作をオーバーライドしないクラスを提供しますToStringします。When 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 (を参照してくださいフレームワークをサポートして Windows ストア アプリ用 .NET と 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、常に実装していないと、ToStringします。Classes 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.ToStringで、Windows ランタイム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.1Windows ランタイムWindows Runtimeが含まれています、 IStringableインターフェイスの 1 つのメソッドを持つIStringable.ToStringと同等の基本的な書式設定サポートを提供します。によって提供されるObject.ToStringします。Starting 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++ などの言語で記述されたコードでのマネージ オブジェクトを呼び出すときに/cli 実装するために表示される、CX 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. 共通言語ランタイムはからの呼び出しに自動的にルーティング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を呼び出すときに、予期しない動作可能性ToStringから、 Windows ランタイムWindows Runtime、C++/cli、/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  
    

    C# では、上記のようになります。in C#, or

    Public Class NewClass : Implements IStringable  
    

    Visual Basic では、上記のようになります。in Visual Basic.

  • 実装することはできませんIStringableインターフェイス。You cannot implement IStringable on an interface.

  • 型パラメーターを宣言することはできませんIStringableします。You 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.

注意 (継承者)

オーバーライドする独自の型を実装するときに、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.

適用対象

こちらもご覧ください