C# Language
String.Format

Introduktion

Syntax

• string.Format (strängformat, paramsobjekt [] args)
• string.Format (IFormatProvider-leverantör, strängformat, params-objekt [] args)
• $ "string {text} blablabla" // Sedan C # 6

parametrar

Anmärkningar

Platser där String.Format är "inbäddat" i ramen

Det finns flera platser där du kan använda String.Format indirekt : Hemligheten är att leta efter överbelastningen med signatursträngformatet string format, params object[] args , t.ex.:

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

Kan ersättas med kortare version:

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

Det finns andra metoder som också använder String.Format t.ex.:

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

Med hjälp av anpassat nummerformat

NumberFormatInfo kan användas för att formatera både heltal och floatnummer.

// 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);

Skapa en anpassad leverantör av format

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;
    }
}

Användande:

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

Produktion:

-> dlroW olleH <-

Rikta in vänster / höger, dyna med mellanslag

Det andra värdet i de lockiga hängslen dikterar längden på ersättningssträngen. Genom att justera det andra värdet för att vara positivt eller negativt kan strängen justeras.

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

Produktion:

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

Numeriska format

// 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);

Produktion:

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%

Valutaformatering

Specifikatorn "c" (eller valuta) omvandlar ett nummer till en sträng som representerar ett valutabelopp.

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

Precision

Standard är 2. Använd c1, c2, c3 och så vidare för att kontrollera precisionen.

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

Valutasymbol

1. Passera CultureInfo instansen för att använda anpassad kultursymbol.

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. Använd vilken sträng som valutasymbol. Använd NumberFormatInfo att anpassa valutasymbolen.

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

Valutasymbolets placering

Använd CurrencyPositivePattern för positiva värden och CurrencyNegativePattern för negativa värden.

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 $

Negativ mönsteranvändning är densamma som positivt mönster. Mycket mer användningsfall hänvisas till originallänken.

Anpassad decimal separator

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

Sedan C # 6.0

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

Rymmer lockiga parenteser i ett String.Format () -uttryck

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"

Datumformatering

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}");

utgång:

06
Лхагва
06

Att stränga()

Metoden ToString () finns på alla referensobjekttyper. Detta beror på att alla referenstyper härrör från Object som har metoden ToString (). Metoden ToString () i objektbasklassen returnerar typnamnet. Fragmentet nedan skriver ut "Användare" till konsolen.

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());

Klassen Användare kan dock åsidosätta ToString () för att ändra strängen som den returnerar. Kodfragmentet nedan skriver ut "Id: 5, Namn: Användare1" på konsolen.

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());

Förhållande till ToString ()

Medan String.Format() -metoden verkligen är användbar vid formatering av data som strängar, kan det ofta vara lite överdrivet, särskilt när man hanterar ett enda objekt som ses nedan:

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

En enklare metod kan vara att helt enkelt använda ToString() -metoden som är tillgänglig på alla objekt inom C #. Det stöder alla samma standard- och anpassade formateringssträngar , men kräver inte den nödvändiga parameterkartläggningen eftersom det bara kommer att finnas ett enda argument:

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

Varningar och begränsningar för formatering

Även om detta tillvägagångssätt kan vara enklare i vissa scenarier är ToString() -metoden begränsad när det gäller att lägga till vänster eller höger polstring som du kan göra inom String.Format() -metoden:

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

För att uppnå samma beteende med ToString() , måste du använda en annan metod som PadLeft() respektive PadRight() :

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