ValueType.ToString Método

public:
 override System::String ^ ToString();

public override string ToString();

public override string? ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Devoluciones

Nombre de tipo completo.

Comentarios

El ValueType.ToString método invalida el Object.ToString método y proporciona la implementación predeterminada del ToString método para los tipos de valor. (Los tipos de valor son tipos definidos por la palabra clave struct en C#y por el Structure... End Structure construcción en Visual Basic). Sin embargo, funcionalmente, la implementación es la misma que la de Object.ToString: el método devuelve el nombre de tipo completo.

Tipos de valor definidos por la palabra clave struct en C# y el Structure... End Structure construcción en Visual Basic normalmente invalidan el método ValueType.ToString para proporcionar una representación de cadena más significativa del tipo de valor. En el siguiente ejemplo se ilustra la diferencia. Define dos tipos de valor, EmployeeA y EmployeeB, crea una instancia de cada y llama a su ToString método . Dado que la EmployeeA estructura no invalida el ValueType.ToString método , solo muestra el nombre de tipo completo. Por otro lado, el EmployeeB.ToString método proporciona información significativa sobre el objeto .

using System;
using Corporate.EmployeeObjects;

public class Example
{
   public static void Main()
   {
      var empA = new EmployeeA{ Name = "Robert",};
      Console.WriteLine(empA.ToString());
      
      var empB = new EmployeeB{ Name = "Robert",};
      Console.WriteLine(empB.ToString());
   }
}

namespace Corporate.EmployeeObjects
{
    public struct EmployeeA
    {
         public String Name { get; set; }
    }
    
    public struct EmployeeB
    {
         public String Name { get; set; }

         public override String ToString()
         {
              return Name;
         }
    }  
}
// The example displays the following output:
//     Corporate.EmployeeObjects.EmployeeA
//     Robert

namespace Corporate.EmployeeObjects

[<Struct>]
type EmployeeA =
    val mutable Name : string

[<Struct>]
type EmployeeB =
    val mutable Name : string
    override this.ToString() = 
          this.Name

module Example =
     let empA = EmployeeA(Name="Robert")
     printfn $"{empA}"

     let empB = EmployeeB(Name="Robert")
     printfn $"{empB}"
// The example displays the following output:
//     Corporate.EmployeeObjects.EmployeeA
//     Robert

Imports Corporate.EmployeeObjects

Module Example
   Public Sub Main()
      Dim empA As New EmployeeA With { .Name = "Robert" }
      Console.WriteLine(empA.ToString())
      
      Dim empB = new EmployeeB With { .Name = "Robert" }
      Console.WriteLine(empB.ToString())
   End Sub
End Module

Namespace Corporate.EmployeeObjects
    Public Structure EmployeeA
         Public Property Name As String 
    End Structure
    
    Public Structure EmployeeB
         Public Property Name As String 

         Public Overrides Function ToString() As String 
              Return Name
         End Function
    End Structure  
End Namespace
' The example displays the following output:
'     Corporate.EmployeeObjects.EmployeeA
'     Robert

Tenga en cuenta que, aunque los tipos de enumeración también son tipos de valor, derivan de la Enum clase , que invalida ValueType.ToString.

Notas para el tiempo de ejecución de Windows

Al llamar al método ToString en una estructura de Windows Runtime, proporciona el comportamiento predeterminado para los tipos de valor que no invalidan ToString. Esto forma parte de la compatibilidad que .NET proporciona para Windows Runtime (consulte Compatibilidad de .NET con aplicaciones de la Tienda Windows y Windows Runtime). Windows Runtime estructuras no pueden invalidar ToString, incluso si se escriben con C# o Visual Basic, ya que no pueden tener métodos. (Además, las estructuras de la propia Windows Runtime no heredan ValueType). Sin embargo, parecen tener ToString, Equals y métodos GetHashCode cuando los usa en el código de C# o Visual Basic, y .NET proporciona el comportamiento predeterminado para estos métodos.