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 i Formateringstyper.) Standardimplementeringar av metoden Object.ToString 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 funktionerna i metoden Object.ToString.

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

Standardmetoden Object.ToString()

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

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 metoden ToString. 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 ofta metoden Object.ToString för att returnera en sträng som representerar objektinstansen. Bastyperna, till exempel Char, 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 metoden ToString 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 metoden Object.ToString.

Typkategori	Åsidosätter Object.ToString()	Uppförande
Klass	ej tillämpligt	ej tillämpligt
Struktur	Ja (ValueType.ToString)	Samma som Object.ToString()
Uppräkning	Ja (Enum.ToString())	Medlemsnamnet
Gränssnitt	Nej	ej tillämpligt
Delegera	Nej	ej tillämpligt

Mer information om hur du åsidosätter ToStringfinns i avsnittet Anteckningar till arvtagare .

Överbelasta ToString-metoden

Förutom att åsidosätta den parameterlösa Object.ToString()-metoden överbelastar många typer ToString-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 metoden ToString 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 metoden Decimal.ToString(String, IFormatProvider) 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($"{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ärdena 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 att metoden ToString för en matris eller samlingsklass visar värdena för dess medlemmar, visas i stället typen fullständigt kvalificerat typnamn, vilket visas i följande exempel.

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 foreach-instruktionen i C# eller For Each...Next-konstruktionen i Visual Basic.

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

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

  I följande exempel definieras en omslutningsklass för klassen List<T>. Den åsidosätter metoden Object.ToString 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 du vill ha. 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 din parameterlösa ToString ersättare.

  I följande exempel definieras två metoder som utökar klassen List<T>: 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 metoden ToString på en klass i Windows Runtime, tillhandahåller 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 inte Objectoch 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 du återgår till standardimplementeringen av Object.ToString.

Anmärkning

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

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. Den vanliga språkkörningen dirigerar automatiskt anrop från IStringable.ToString till Object.ToString om IStringable- inte implementeras på det hanterade objektet.

Varning

Eftersom det gemensamma språkens körning automatiskt implementerar IStringable för alla hanterade typer i Windows Store-appar, rekommenderar vi att du inte tillhandahåller en egen IStringable-implementering. Implementering av 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.