C# Language
Cadena.Formato

Introducción

Sintaxis

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

Parámetros

Observaciones

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

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

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

Puede ser reemplazado por una versión más corta:

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

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

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

Usando formato de número personalizado

NumberFormatInfo se puede usar para formatear 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);

Crear 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 <-

Alinear izquierda / derecha, pad con espacios

El segundo valor en las llaves indica 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 numericos

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

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. Use 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 la instancia de CultureInfo para usar el símbolo de cultura 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

2. Utilice cualquier cadena como símbolo de moneda. Utilice NumberFormatInfo 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 negativo del patrón es el mismo que el patrón positivo. Muchos más casos de uso, por favor 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

Desde C # 6.0

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

Escape de llaves 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"

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

Encadenar()

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 fragmento a continuación 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 Usuario también puede anular ToString () para alterar la cadena que devuelve. El fragmento de código a continuación imprime "Id: 5, Name: User1" 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 ()

Si bien el método String.Format() es ciertamente útil para formatear datos como cadenas, a menudo puede ser un poco excesivo, 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 método 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 enfoque ToString() está limitado con respecto a la adición del relleno izquierdo o derecho, como lo haría con el método String.Format() :

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

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

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