System.Object.ToString-metod

Den här artikeln innehåller ytterligare kommentarer till referensdokumentationen för det här API:et.

Object.ToString är en vanlig formateringsmetod i .NET. Det konverterar ett objekt till dess strängrepresentation så att det är lämpligt för visning. (Information om formateringsstöd i .NET finns iFormateringstyper.) Standardimplementeringar av Object.ToString metoden returnerar det fullständigt kvalificerade namnet på objektets typ.

Viktigt!

Du kan ha nått den här sidan genom att följa länken från medlemslistan av en annan typ. Det beror på att den typen inte åsidosätter Object.ToString. I stället ärver den metodens Object.ToString funktioner.

Typer åsidosätter Object.ToString ofta metoden för att ge en lämpligare strängrepresentation av en viss typ. Typer överbelastar Object.ToString också ofta metoden för att ge stöd för formatsträngar eller kulturkänslig formatering.

Standardmetoden Object.ToString()

Standardimplementeringen av ToString metoden returnerar det fullständigt kvalificerade namnet på typen av Object, som i följande exempel visas.

Object obj = new Object();
Console.WriteLine(obj.ToString());

// The example displays the following output:
//      System.Object

let obj = obj ()
printfn $"{obj.ToString()}"
// printfn $"{obj}" // Equivalent

// The example displays the following output:
//      System.Object

Module Example3
    Public Sub Main()
        Dim obj As New Object()
        Console.WriteLine(obj.ToString())
    End Sub
End Module
' The example displays the following output:
'      System.Object

Eftersom Object är basklassen för alla referenstyper i .NET ärvs det här beteendet av referenstyper som inte åsidosätter ToString metoden. I följande exempel visas detta. Den definierar en klass med namnet Object1 som accepterar standardimplementeringen av alla Object medlemmar. Dess ToString metod returnerar objektets fullständigt kvalificerade typnamn.

using System;
using Examples;

namespace Examples
{
   public class Object1
   {
   }
}

public class Example5
{
   public static void Main()
   {
      object obj1 = new Object1();
      Console.WriteLine(obj1.ToString());
   }
}
// The example displays the following output:
//   Examples.Object1

type Object1() = class end

let obj1 = Object1()
printfn $"{obj1.ToString()}"
// The example displays the following output:
//   Examples.Object1

Public Class Object1
End Class

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

Åsidosätt metoden Object.ToString()

Typer åsidosätter Object.ToString ofta metoden för att returnera en sträng som representerar objektinstansen. Till exempel bastyperna, till Charexempel , Int32och String tillhandahålla ToString implementeringar som returnerar strängformen för det värde som objektet representerar. I följande exempel definieras en klass, Object2, som åsidosätter ToString metoden för att returnera typnamnet tillsammans med dess värde.

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 Example6
{
   public static void Main()
   {
      Object2 obj2 = new Object2('a');
      Console.WriteLine(obj2.ToString());
   }
}
// The example displays the following output:
//       Object2: a

type Object2(value: obj) =
    inherit obj ()
    override _.ToString() =
        base.ToString() + ": " + value.ToString()

let obj2 = Object2 'a'
printfn $"{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 Example5
    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

I följande tabell visas typkategorierna i .NET och anger om de åsidosätter Object.ToString metoden eller inte.

Typkategori	Åsidosätter Object.ToString()	Funktionssätt
Klass	saknas	saknas
Struktur	Ja (ValueType.ToString)	Samma som Object.ToString()
Uppräkning	Ja (Enum.ToString())	Medlemsnamnet
Gränssnitt	Nej	saknas
Delegera	Nej	saknas

Mer information om att åsidosätta ToStringfinns i avsnittet Anteckningar till arvtagare.

Överbelasta ToString-metoden

Förutom att åsidosätta den parameterlösa Object.ToString() metoden överbelastar ToString många typer metoden för att tillhandahålla versioner av metoden som accepterar parametrar. Oftast görs detta för att ge stöd för variabel formatering och kulturkänslig formatering.

I följande exempel överbelastas ToString metoden för att returnera en resultatsträng som innehåller värdet för olika fält i en Automobile klass. Den definierar fyra formatsträngar: G, som returnerar modellnamnet och året; D, som returnerar modellnamnet, året och antalet dörrar; C, som returnerar modellnamnet, året och antalet cylindrar; och A, som returnerar en sträng med alla fyra fältvärdena.

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 Example7
{
   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

open System

type Automobile(model: string, year: int, doors: int, cylinders: string) =
    member _.Doors = doors
    member _.Model = model
    member _.Year = year
    member _.Cylinders = cylinders

    override this.ToString() =
        this.ToString "G"

    member _.ToString(fmt) =
        let fmt = 
            if String.IsNullOrEmpty fmt then "G"
            else fmt.ToUpperInvariant()

        match fmt with
        | "G" ->
            $"{year} {model}"
        | "D" ->
            $"{year} {model}, {doors} dr."
        | "C" ->
            $"{year} {model}, {cylinders}"
        | "A" ->
            $"{year} {model}, {doors} dr. {cylinders}"
        | _ ->
            raise (ArgumentException $"'{fmt}' is an invalid format string")

let auto = Automobile("Lynx", 2016, 4, "V8")
printfn $"{auto}"
printfn $"""{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 Example6
    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

I följande exempel anropas den överlagrade Decimal.ToString(String, IFormatProvider) metoden för att visa kulturkänslig formatering av ett valutavärde.

using System;
using System.Globalization;

public class Example8
{
   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

open System.Globalization

let cultureNames =
    [| "en-US"; "en-GB"; "fr-FR"; "hr-HR"; "ja-JP" |]
let value = 1603.49m
for cultureName in cultureNames do
    let culture = CultureInfo cultureName
    printfn $"""{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 Example7
    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

Mer information om formatsträngar och kulturkänslig formatering finns i Formateringstyper. De formatsträngar som stöds av numeriska värden finns i Standard numeriska formatsträngar och Anpassade numeriska formatsträngar. De formatsträngar som stöds av datum- och tidsvärden finns i Standardformatsträngar för datum och tid och anpassade datum- och tidsformatsträngar.

Utöka metoden Object.ToString

Eftersom en typ ärver standardmetoden Object.ToString kan det hända att dess beteende är oönskat och vill ändra den. Detta gäller särskilt matriser och samlingsklasser. Även om du kan förvänta dig ToString att metoden för en matris eller samlingsklass visar värdena för dess medlemmar, visas i stället typen fullständigt kvalificerat typnamn, som i följande exempel visas.

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]

let values = [| 1; 2; 4; 8; 16; 32; 64; 128 |]
printfn $"{values}"

let list = ResizeArray values
printfn $"{list}"

// 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]

Du har flera alternativ för att skapa den resultatsträng som du vill ha.

• Om typen är en matris, ett samlingsobjekt eller ett objekt som implementerar gränssnitten IEnumerable eller IEnumerable<T> kan du räkna upp dess element med hjälp av -instruktionen foreach i C# eller konstruktionen For Each...Next i Visual Basic.

• Om klassen inte sealed är (i C#) eller NotInheritable (i Visual Basic) kan du utveckla en omslutningsklass som ärver från basklassen vars Object.ToString metod du vill anpassa. Detta kräver minst att du gör följande:

  1. Implementera alla nödvändiga konstruktorer. Härledda klasser ärver inte sina basklasskonstruktorer.
  2. Åsidosätt Object.ToString metoden för att returnera den resultatsträng som du vill ha.

  I följande exempel definieras en omslutningsklass för List<T> klassen. Den åsidosätter Object.ToString metoden för att visa värdet för varje metod i samlingen i stället för det fullständigt kvalificerade typnamnet.

  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 Example2
  {
     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
  

  open System
  open System.Collections.Generic
  
  type CList<'T>() = 
      inherit ResizeArray<'T>()
      
      override this.ToString() =
          let mutable retVal = String.Empty
          for item in this do
              if String.IsNullOrEmpty retVal then
                  retVal <- retVal + string item
              else
                  retVal <- retVal + $", {item}"
          retVal
  
  let list2 = CList()
  list2.Add 1000
  list2.Add 2000
  printfn $"{list2}"
  // 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 Example1
      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
  

• Utveckla en tilläggsmetod som returnerar den resultatsträng som du vill använda. Observera att du inte kan åsidosätta standardmetoden Object.ToString på det här sättet, dvs. tilläggsklassen (i C#) eller modulen (i Visual Basic) kan inte ha en parameterlös metod med namnet ToString som anropas i stället för den ursprungliga typens ToString metod. Du måste ange ett annat namn för den parameterlösa ToString ersättningen.

  I följande exempel definieras två metoder som utökar List<T> klassen: en parameterlös ToString2 metod och en ToString metod med en String parameter som representerar en formatsträng.

  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 Example3
  {
     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 }
  

  open System
  open System.Collections.Generic
  
  type List<'T> with
      member this.ToString2<'T>() = 
          let mutable retVal = String.Empty
          for item in this do
             retVal <- retVal + $"""{if String.IsNullOrEmpty retVal then "" else ", "}{item}"""
          if String.IsNullOrEmpty retVal then "{}" else "{ " + retVal + " }"
  
      member this.ToString<'T>(fmt: string) =
          let mutable retVal = String.Empty
          for item in this do
              match box item with
              | :? IFormattable as ifmt ->
                  retVal <- retVal + $"""{if String.IsNullOrEmpty retVal then "" else ", "}{ifmt.ToString(fmt, null)}"""
              | _ ->
                  retVal <- retVal + this.ToString2()
          if String.IsNullOrEmpty retVal then "{}" else "{ " + retVal + " }"
  
  let list = ResizeArray()
  list.Add 1000
  list.Add 2000
  printfn $"{list.ToString2()}"
  printfn $"""{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 Example2
      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 }
  

Anteckningar för Windows Runtime

När du anropar ToString metoden på en klass i Windows Runtime, ger den standardbeteendet för klasser som inte åsidosätter ToString. Detta är en del av det stöd som .NET tillhandahåller för Windows Runtime (se .NET-stöd för Windows Store-appar och Windows Runtime). Klasser i Windows Runtime ärver Objectinte och implementerar inte alltid en ToString. De verkar dock alltid ha ToString, Equals(Object)och GetHashCode -metoder när du använder dem i C# eller Visual Basic-koden, och .NET tillhandahåller ett standardbeteende för dessa metoder.

Den vanliga språkkörningen använder IStringable.ToString på ett Windows Runtime-objekt innan det återgår till standardimplementeringen av Object.ToString.

Kommentar

Windows Runtime-klasser som är skrivna i C# eller Visual Basic kan åsidosätta ToString metoden.

Windows Runtime och IStringable-gränssnittet

Windows Runtime innehåller ett IStringable-gränssnitt vars enda metod, IStringable.ToString, ger grundläggande formateringsstöd som är jämförbart med det som tillhandahålls av Object.ToString. För att förhindra tvetydighet bör du inte implementera IStringable på hanterade typer.

När hanterade objekt anropas med inbyggd kod eller kod som skrivits på språk som JavaScript eller C++/CX, verkar de implementera IStringable. Common Language Runtime dirigerar automatiskt anrop från IStringable.ToString till Object.ToString om IStringable inte implementeras på det hanterade objektet.

Varning

Eftersom den vanliga språkkörningen implementerar IStringable automatiskt för alla hanterade typer i Windows Store-appar rekommenderar vi att du inte tillhandahåller din egen IStringable implementering. Implementering IStringable kan leda till oavsiktligt beteende när du anropar ToString från Windows Runtime, C++/CX eller JavaScript.

Om du väljer att implementera IStringable i en offentlig hanterad typ som exporteras i en Windows Runtime-komponent gäller följande begränsningar:

• Du kan bara definiera IStringable-gränssnittet i en "klass implementerar"-relation på följande sätt:

  public class NewClass : IStringable
  

  Public Class NewClass : Implements IStringable
  

• Du kan inte implementera IStringable i ett gränssnitt.

• Du kan inte deklarera att en parameter är av typen IStringable.

• IStringable kan inte vara returtypen för en metod, egenskap eller ett fält.

• Du kan inte dölja din IStringable-implementering från basklasser med hjälp av en metoddefinition, till exempel följande:

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

  I stället måste implementeringen IStringable.ToString alltid åsidosätta basklassimplementeringen. Du kan bara dölja en ToString implementering genom att anropa den på en starkt skriven klassinstans.

Under en mängd olika förhållanden kan anrop från inbyggd kod till en hanterad typ som implementerar IStringable eller döljer dess ToString-implementering ge oväntat beteende.