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 completo del tipo.

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 struct palabra clave en C#, y por la Structureconstrucción ...End Structure 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.

Los tipos de valor definidos por la struct palabra clave en C# y la Structureconstrucción ...End Structure en Visual Basic suelen invalidar el ValueType.ToString método 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 EmployeeB.ToString otro lado, el 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 de la Windows Runtime

Al llamar al ToString método 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 proporciona .NET para la 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 Windows Runtime en sí no heredan ValueType). Sin embargo, parecen tener ToStringmétodos , Equalsy GetHashCode cuando los usa en el código de C# o Visual Basic, y .NET proporciona el comportamiento predeterminado para estos métodos.

Se aplica a