C# Language
String.Format

Wprowadzenie

Składnia

• string.Format (format ciągu, parametry params [] argumenty)
• string.Format (dostawca IFormatProvider, format ciągu, obiekt params [] argumenty)
• $ "string {text} blablabla" // Od C # 6

Parametry

Uwagi

Miejsca, w których String.Format jest „osadzony” w ramach

Istnieje kilka miejsc, w których można użyć String.Format pośrednio : Sekret polega na szukaniu przeciążenia string format, params object[] args podpisu string format, params object[] args , np .:

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

Można zastąpić krótszą wersją:

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

Istnieją inne metody, które również wykorzystują String.Format np .:

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

Korzystanie z niestandardowego formatu liczb

NumberFormatInfo może służyć do formatowania liczb całkowitych i liczb zmiennoprzecinkowych.

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

Utwórz niestandardowego dostawcę formatu

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

Stosowanie:

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

Wynik:

-> dlroW olleH <-

Wyrównaj do lewej / prawej, pad ze spacjami

Druga wartość w nawiasach klamrowych określa długość łańcucha zastępczego. Dostosowując drugą wartość do dodatniej lub ujemnej, można zmienić wyrównanie ciągu.

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

Wynik:

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

Formaty numeryczne

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

Wynik:

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%

Formatowanie walut

Specyfikator formatu „c” (lub waluta) konwertuje liczbę na ciąg znaków reprezentujący kwotę waluty.

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

Precyzja

Domyślnie jest to 2. Użyj c1, c2, c3 i tak dalej, aby kontrolować precyzję.

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

Symbol waluty

1. Przekaż instancję CultureInfo aby użyć niestandardowego symbolu kultury.

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. Użyj dowolnego łańcucha jako symbolu waluty. Użyj NumberFormatInfo jako, aby dostosować symbol waluty.

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

Pozycja symbolu waluty

Użyj CurrencyPositivePattern dla wartości dodatnich i CurrencyNegativePattern dla wartości ujemnych.

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 $

Użycie wzorca ujemnego jest takie samo jak wzorca dodatniego. O wiele więcej przypadków użycia można znaleźć w oryginalnym linku.

Niestandardowy separator dziesiętny

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

Od wersji C # 6.0

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

Ucieczka nawiasów klamrowych wewnątrz wyrażenia 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"

Formatowanie daty

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

wynik :

06
Лхагва
06

ToString ()

Metoda ToString () jest obecna na wszystkich typach obiektów referencyjnych. Wynika to z faktu, że wszystkie typy referencji pochodzą z Object, na którym znajduje się metoda ToString (). Metoda ToString () w klasie bazowej obiektu zwraca nazwę typu. Poniższy fragment wydrukuje „User” na konsoli.

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

Jednak klasa Użytkownik może również przesłonić ToString () w celu zmiany zwracanego ciągu. Poniższy fragment kodu wypisuje na konsoli „Id: 5, Nazwa: Użytkownik1”.

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

Relacja z ToString ()

Chociaż metoda String.Format() jest z pewnością przydatna w formatowaniu danych jako ciągów, często może być nieco przesadna, szczególnie w przypadku pojedynczego obiektu, jak pokazano poniżej:

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

Łatwiejszym podejściem może być po prostu użycie metody ToString() dostępnej dla wszystkich obiektów w C #. Obsługuje wszystkie te same standardowe i niestandardowe ciągi formatujące , ale nie wymaga koniecznego mapowania parametrów, ponieważ będzie tylko jeden argument:

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

Ostrzeżenia i ograniczenia dotyczące formatowania

Podczas gdy takie podejście może być prostsze w niektórych scenariuszach, podejście ToString() jest ograniczone w odniesieniu do dodawania lewego lub prawego dopełnienia, tak jak możesz to zrobić w ramach metody String.Format() :

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

Aby osiągnąć to samo zachowanie za pomocą metody ToString() , należy użyć innej metody, takiej jak odpowiednio PadLeft() lub PadRight() :

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