Cadena.Formato

El Format Los métodos son un conjunto de sobrecargas en el System.String clase utilizada para crear cadenas que combinan objetos en representaciones de cadenas específicas. Esta información se puede aplicar a String.Format , varios WriteLine así como otros métodos en el marco .NET.

# Desde C# 6.0

Desde C# 6.0 es posible usar la interpolación de cadenas en lugar de String.Format .

string name = "John";
string lastname = "Doe";
Console.WriteLine($"Hello {name} {lastname}!");

¡Hola John Doe!

^{Más ejemplos de esto en el tema Características de C# 6.0:interpolación de cadenas.}

# Lugares donde String.Format está 'incrustado' en el marco

Hay varios lugares donde puedes usar String.Format indirectamente :El secreto es buscar la sobrecarga con la firma string format, params object[] args , por ejemplo:

Console.WriteLine(String.Format("{0} - {1}", name, value));

Se puede reemplazar con una versión más corta:

Console.WriteLine("{0} - {1}", name, value);

Hay otros métodos que también usan String.Format por ejemplo:

Debug.WriteLine(); // and Print()
StringBuilder.AppendFormat();

# Crea un proveedor de formato personalizado

public class CustomFormat : IFormatProvider, ICustomFormatter
{
    public string Format(string format, object arg, IFormatProvider formatProvider)
    {
        if (!this.Equals(formatProvider))
        {
            return null;
        }

        if (format == "Reverse")
        {
            return String.Join("", arg.ToString().Reverse());
        }

        return arg.ToString();
    }

    public object GetFormat(Type formatType)
    {
        return formatType==typeof(ICustomFormatter) ? this:null;
    }
}

Uso:

String.Format(new CustomFormat(), "-> {0:Reverse} <-", "Hello World");

Salida:

-> dlroW olleH <-

# Formato de fecha

DateTime date = new DateTime(2016, 07, 06, 18, 30, 14);
// Format: year, month, day hours, minutes, seconds

Console.Write(String.Format("{0:dd}",date)); 

//Format by Culture info
String.Format(new System.Globalization.CultureInfo("mn-MN"),"{0:dddd}",date);

Console.Write($"{date:ddd}");

salida:

06
Лхагва
06

# Formato de moneda

El especificador de formato "c" (o moneda) convierte un número en una cadena que representa una cantidad de moneda.

string.Format("{0:c}", 112.236677) // $112.23 - defaults to system

# Precisión

El valor predeterminado es 2. Utilice c1, c2, c3, etc. para controlar la precisión.

string.Format("{0:C1}", 112.236677) //$112.2
string.Format("{0:C3}", 112.236677) //$112.237
string.Format("{0:C4}", 112.236677) //$112.2367
string.Format("{0:C9}", 112.236677) //$112.236677000

# símbolo de moneda

1. Pase CultureInfo instancia para usar el símbolo cultural personalizado.

string.Format(new CultureInfo("en-US"), "{0:c}", 112.236677); //$112.24
string.Format(new CultureInfo("de-DE"), "{0:c}", 112.236677); //112,24 €
string.Format(new CultureInfo("hi-IN"), "{0:c}", 112.236677); //₹ 112.24

1. Utilice cualquier cadena como símbolo de moneda. Usa NumberFormatInfo como para personalizar el símbolo de moneda.

NumberFormatInfo nfi = new CultureInfo( "en-US", false ).NumberFormat;
nfi = (NumberFormatInfo) nfi.Clone();
nfi.CurrencySymbol = "?";
string.Format(nfi, "{0:C}", 112.236677); //?112.24
nfi.CurrencySymbol = "?%^&";
string.Format(nfi, "{0:C}", 112.236677); //?%^&112.24

# Posición del símbolo de moneda

Use CurrencyPositivePattern para valores positivos y CurrencyNegativePattern para valores negativos.

NumberFormatInfo nfi = new CultureInfo( "en-US", false ).NumberFormat;        
nfi.CurrencyPositivePattern = 0;
string.Format(nfi, "{0:C}", 112.236677); //$112.24 - default
nfi.CurrencyPositivePattern = 1;
string.Format(nfi, "{0:C}", 112.236677); //112.24$
nfi.CurrencyPositivePattern = 2;
string.Format(nfi, "{0:C}", 112.236677); //$ 112.24
nfi.CurrencyPositivePattern = 3; 
string.Format(nfi, "{0:C}", 112.236677); //112.24 $

El uso del patrón negativo es el mismo que el patrón positivo. Muchos más casos de uso, consulte el enlace original.

# Separador decimal personalizado

NumberFormatInfo nfi = new CultureInfo( "en-US", false ).NumberFormat;        
nfi.CurrencyPositivePattern = 0;
nfi.CurrencyDecimalSeparator = "..";
string.Format(nfi, "{0:C}", 112.236677); //$112..24

# Uso de formato de número personalizado

NumberFormatInfo se puede utilizar para dar formato a números enteros y flotantes.

// invariantResult is "1,234,567.89"
var invarianResult = string.Format(CultureInfo.InvariantCulture, "{0:#,###,##}", 1234567.89);

// NumberFormatInfo is one of classes that implement IFormatProvider
var customProvider = new NumberFormatInfo
{
    NumberDecimalSeparator = "_NS_", // will be used instead of ','
    NumberGroupSeparator = "_GS_", // will be used instead of '.'
};

// customResult is "1_GS_234_GS_567_NS_89"
var customResult = string.Format(customProvider, "{0:#,###.##}", 1234567.89);

# Alinear a la izquierda/derecha, rellenar con espacios

El segundo valor entre llaves dicta la longitud de la cadena de reemplazo. Al ajustar el segundo valor para que sea positivo o negativo, se puede cambiar la alineación de la cadena.

string.Format("LEFT:  string: ->{0,-5}<- int: ->{1,-5}<-", "abc", 123);
string.Format("RIGHT: string: ->{0,5}<- int: ->{1,5}<-", "abc", 123);

Salida:

LEFT:  string: ->abc  <- int: ->123  <-
RIGHT: string: ->  abc<- int: ->  123<-

# formatos numéricos

// Integral types as hex
string.Format("Hexadecimal: byte2: {0:x2}; byte4: {0:X4}; char: {1:x2}", 123, (int)'A');

// Integers with thousand separators
string.Format("Integer, thousand sep.: {0:#,#}; fixed length: >{0,10:#,#}<", 1234567);

// Integer with leading zeroes
string.Format("Integer, leading zeroes: {0:00}; ", 1);

// Decimals
string.Format("Decimal, fixed precision: {0:0.000}; as percents: {0:0.00%}", 0.12);

Salida:

Hexadecimal: byte2: 7b; byte4: 007B; char: 41
Integer, thousand sep.: 1,234,567; fixed length: > 1,234,567<
Integer, leading zeroes: 01; 
Decimal, fixed precision: 0.120; as percents: 12.00%

# Escapar de corchetes dentro de una expresión String.Format()

string outsidetext = "I am outside of bracket";
string.Format("{{I am in brackets!}} {0}", outsidetext);

//Outputs "{I am in brackets!} I am outside of bracket"

#ToString()

El método ToString() está presente en todos los tipos de objetos de referencia. Esto se debe a que todos los tipos de referencia se derivan de Object que tiene el método ToString(). El método ToString() en la clase base del objeto devuelve el nombre del tipo. El siguiente fragmento imprimirá "Usuario" en la consola.

public class User
{
    public string Name { get; set; }
    public int Id { get; set; }
}

...

var user = new User {Name = "User1", Id = 5};
Console.WriteLine(user.ToString());

Sin embargo, la clase User también puede anular ToString() para modificar la cadena que devuelve. El siguiente fragmento de código imprime "Id:5, Nombre:Usuario1" en la consola.

public class User
{
    public string Name { get; set; }
    public int Id { get; set; }
    public override ToString()
    {
        return string.Format("Id: {0}, Name: {1}", Id, Name);
    }
}

...

var user = new User {Name = "User1", Id = 5};
Console.WriteLine(user.ToString());

# Relación con ToString()

Mientras que el String.Format() El método es ciertamente útil para formatear datos como cadenas, a menudo puede ser un poco exagerado, especialmente cuando se trata de un solo objeto como se ve a continuación:

String.Format("{0:C}", money);  // yields "$42.00"

Un enfoque más fácil podría ser simplemente usar el ToString() disponible en todos los objetos dentro de C#. Admite todas las mismas cadenas de formato estándar y personalizadas, pero no requiere la asignación de parámetros necesaria ya que solo habrá un único argumento:

money.ToString("C");  // yields "$42.00"

# Advertencias y restricciones de formato

Si bien este enfoque puede ser más simple en algunos escenarios, el ToString() el enfoque está limitado con respecto a agregar relleno izquierdo o derecho como lo haría dentro del String.Format() método :

String.Format("{0,10:C}", money);  // yields "    $42.00"

Para lograr este mismo comportamiento con el ToString() método, necesitaría usar otro método como PadLeft() o PadRight() respectivamente :

money.ToString("C").PadLeft(10);  // yields "    $42.00"

# Sintaxis

• string.Format(formato de cadena, objeto params[] argumentos)
• cadena.Format(proveedor IFormatProvider, formato de cadena, objeto params[] argumentos)
• $"cadena {texto} blablabla" // Desde C#6

# Parámetros

# Comentarios

Notas:

• String.Format() maneja null argumentos sin lanzar una excepción.
• Hay sobrecargas que reemplazan el args parámetro con uno, dos o tres parámetros de objeto.