String.Format

String.Format

Der Format Methoden sind eine Reihe von Überladungen im System.String Klasse zum Erstellen von Zeichenfolgen, die Objekte zu bestimmten Zeichenfolgendarstellungen kombinieren. Diese Informationen können auf String.Format angewendet werden , verschiedene WriteLine Methoden sowie andere Methoden im .NET-Framework.

# Seit C# 6.0

Seit C# 6.0 ist es möglich, String-Interpolation anstelle von String.Format zu verwenden .

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

Hallo John Doe!

Weitere Beispiele dazu unter dem Thema C# 6.0 Features:String-Interpolation .

# Orte, an denen String.Format in das Framework „eingebettet“ ist

Es gibt mehrere Stellen, an denen Sie String.Format verwenden können indirekt :Das Geheimnis besteht darin, nach der Überladung mit der Signatur string format, params object[] args zu suchen , z. B.:

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

Kann durch eine kürzere Version ersetzt werden:

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

Es gibt andere Methoden, die ebenfalls String.Format verwenden zB:

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

# Einen benutzerdefinierten Formatanbieter erstellen

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

Verwendung:

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

Ausgabe:

-> dlroW olleH <-

# Datumsformatierung

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

Ausgabe :

06
Лхагва
06

Bezeichner Bedeutung Probe Ergebnis
d Datum {0:d} 6.7.2016
dd Tag, mit Nullen aufgefüllt {0:dd} 06
ddd Kurzer Tagesname {0:ddd} Mi
dddd Vollständiger Tagesname {0:dddd} Mittwoch
D Langes Datum {0:D} Mittwoch, 6. Juli 2016
f Vollständiges Datum und Uhrzeit, kurz {0:f} Mittwoch, 6. Juli 2016, 18:30 Uhr
ff Sekundenbruch, 2 Ziffern {0:ff} 20
fff Sekundenbruch, 3 Ziffern {0:fff} 201
ffff Sekundenbruch, 4 Ziffern {0:ffff} 2016
F Vollständiges Datum und Uhrzeit, lang {0:F} Mittwoch, 6. Juli 2016 18:30:14 Uhr
g Standarddatum und -uhrzeit {0:g} 6.7.2016 18:30 Uhr
gg Ära {0:gg} A.D.
hh Stunde (2 Ziffern, 12H) {0:hh} 06
HH Stunde (2 Ziffern, 24H) {0:HH} 18
M Monat und Tag {0:M} 6. Juli
mm Minuten, mit Nullen aufgefüllt {0:mm} 30
MM Monat, mit Nullen aufgefüllt {0:MM} 07
MMM Monatsname aus 3 Buchstaben {0:MMM} Juli
MMMM Vollständiger Monatsname {0:MMMM} Juli
ss Sekunden {0:ss} 14
r RFC1123-Datum {0:r} Mittwoch, 6. Juli 2016 18:30:14 GMT
s Sortierbarer Datumsstring {0:s} 2016-07-06T18:30:14
t Kurze Zeit {0:t} 18:30 Uhr
T Lange Zeit {0:T} 18:30:14 Uhr
tt AM/PM {0:tt} PN
du Universelle sortierbare Ortszeit {0:u} 2016-07-06 18:30:14Z
U Universelle GMT {0:U} Mittwoch, 6. Juli 2016 09:30:14 Uhr
J Monat und Jahr {0:Y} Juli 2016
jj zweistelliges Jahr {0:yy} 16
jjjj 4-stelliges Jahr {0:yyyy} 2016
zz 2-stelliger Zeitzonen-Offset {0:zz} +09
zzz vollständiger Zeitzonenausgleich {0:zzz} +09:00

# Währungsformatierung

Der Formatbezeichner "c" (oder Währung) wandelt eine Zahl in eine Zeichenfolge um, die einen Währungsbetrag darstellt.

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

# Genauigkeit

Der Standardwert ist 2. Verwenden Sie c1, c2, c3 usw., um die Genauigkeit zu steuern.

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

# Währungssymbol

  1. Übergeben Sie CultureInfo Instanz, um ein benutzerdefiniertes Kultursymbol zu verwenden.
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. Verwenden Sie eine beliebige Zeichenfolge als Währungssymbol. Verwenden Sie NumberFormatInfo um das Währungssymbol anzupassen.
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

# Position des Währungssymbols

Verwenden Sie CurrencyPositivePattern für positive Werte und CurrencyNegativePattern für negative Werte.

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 $

Die Verwendung negativer Muster entspricht der Verwendung positiver Muster. Viele weitere Anwendungsfälle entnehmen Sie bitte dem Originallink.

# Benutzerdefiniertes Dezimaltrennzeichen

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

# Benutzerdefiniertes Zahlenformat verwenden

NumberFormatInfo kann zum Formatieren von Integer- und Float-Zahlen verwendet werden.

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

# Links/rechts ausrichten, mit Leerzeichen auffüllen

Der zweite Wert in den geschweiften Klammern gibt die Länge der Ersatzzeichenfolge vor. Indem Sie den zweiten Wert positiv oder negativ einstellen, kann die Ausrichtung der Zeichenfolge geändert werden.

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

Ausgabe:

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

# Numerische Formate

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

Ausgabe:

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%

# Geschweifte Klammern innerhalb eines String.Format()-Ausdrucks maskieren

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

Die Methode ToString() ist für alle Referenzobjekttypen vorhanden. Dies liegt daran, dass alle Referenztypen von Object abgeleitet werden, auf dem sich die Methode ToString() befindet. Die ToString()-Methode der Objektbasisklasse gibt den Typnamen zurück. Das folgende Fragment gibt "User" an die Konsole aus.

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

Die Klasse User kann jedoch auch ToString() überschreiben, um den zurückgegebenen String zu ändern. Das folgende Codefragment gibt "Id:5, Name:User1" an die Konsole aus.

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

# Beziehung mit ToString()

Während die String.Format() Methode ist sicherlich nützlich beim Formatieren von Daten als Strings, kann aber oft etwas übertrieben sein, besonders wenn es um ein einzelnes Objekt geht, wie unten zu sehen ist:

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

Ein einfacherer Ansatz könnte darin bestehen, einfach den ToString() zu verwenden -Methode, die für alle Objekte in C# verfügbar ist. Es unterstützt dieselben standardmäßigen und benutzerdefinierten Formatierungszeichenfolgen , erfordert jedoch nicht die erforderliche Parameterzuordnung, da es nur ein einziges Argument gibt :

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

# Vorbehalte und Formatierungsbeschränkungen

Während dieser Ansatz in einigen Szenarien einfacher sein kann, ist der ToString() Der Ansatz ist in Bezug auf das Hinzufügen von linkem oder rechtem Padding begrenzt, wie Sie es in String.Format() tun könnten Methode:

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

Um dasselbe Verhalten mit dem ToString() zu erreichen Methode, müssten Sie eine andere Methode wie PadLeft() verwenden oder PadRight() bzw. :

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

#-Syntax

  • string.Format(string format, params object[] args)
  • string.Format(IFormatProvider-Anbieter, Zeichenfolgenformat, Params-Objekt[]-Argumente)
  • $"string {text} blablabla" // Seit C#6

# Parameter

Parameter Einzelheiten
Format Ein zusammengesetzter Formatstring , der die Art und Weise args definiert sollte zu einem String kombiniert werden.
Argumente Eine Folge von Objekten, die zu einer Zeichenfolge kombiniert werden sollen. Da dies einen params verwendet Argument können Sie entweder eine durch Kommas getrennte Liste von Argumenten oder ein tatsächliches Objekt-Array verwenden.
Anbieter Eine Sammlung von Möglichkeiten, Objekte in Zeichenketten zu formatieren. Typische Werte sind CultureInfo.InvariantCulture und CultureInfo.CurrentCulture .

# Bemerkungen

Hinweise:

  • String.Format() verarbeitet null Argumente, ohne eine Ausnahme auszulösen.
  • Es gibt Überladungen, die den args ersetzen Parameter mit einem, zwei oder drei Objektparametern.