Suche…


Einführung

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

Syntax

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

Parameter

Parameter Einzelheiten
Format Eine zusammengesetzte Formatzeichenfolge , die definiert, wie die Argumente in einer Zeichenfolge kombiniert werden sollen.
args Eine Folge von Objekten, die zu einem String zusammengefasst werden sollen. Da dies ein params Argument verwendet, können Sie entweder eine durch Kommas getrennte Liste von Argumenten oder ein tatsächliches Objektarray verwenden.
Anbieter Eine Sammlung von Möglichkeiten zum Formatieren von Objekten in Strings. Typische Werte sind CultureInfo.InvariantCulture und CultureInfo.CurrentCulture .

Bemerkungen

Anmerkungen:

  • String.Format() verarbeitet null Argumente, ohne eine Ausnahme String.Format() .
  • Es gibt Überladungen, die den Parameter args durch einen, zwei oder drei Objektparameter ersetzen.

Orte, an denen String.Format im Framework "eingebettet" ist

Es gibt mehrere Orte, an denen Sie String.Format indirekt verwenden können : Das Geheimnis besteht darin, die Überladung mit dem Signaturzeichenfolgenformat 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 auch String.Format zB:

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

Benutzerdefiniertes Zahlenformat verwenden

NumberFormatInfo kann zum Formatieren von Ganzzahl- und NumberFormatInfo 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);

Erstellen Sie einen benutzerdefinierten Formatanbieter

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

Verwendungszweck:

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

Ausgabe:

-> dlroW olleH <-

Der zweite Wert in den geschweiften Klammern gibt die Länge der Ersatzzeichenfolge an. Durch Einstellen des zweiten Werts auf positiv oder negativ 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%

Währungsformatierung

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

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

Präzision

Die Standardeinstellung 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ährungszeichen

  1. CultureInfo Instanz, um ein benutzerdefiniertes CultureInfo 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 $

Negative Musterverwendung ist dasselbe wie positives Muster. Viel mehr Anwendungsfälle finden Sie im Original-Link.

Benutzerdefiniertes Dezimaltrennzeichen

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

Seit C # 6.0

6,0

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

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

Hallo John Doe!

Weitere Beispiele hierzu unter dem Thema C # 6.0-Features: Zeichenketteninterpolation .

Lockige geschweifte Klammern innerhalb eines String.Format () - Ausdrucks

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"

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);
6,0
Console.Write($"{date:ddd}");

Ausgabe :

06
Лхагва
06
Bezeichner Bedeutung Probe Ergebnis
d Datum {0:d} 7/6/2016
dd Tag, null gepolstert {0:dd} 06
ddd Kurzer Tagesname {0:ddd} Heiraten
dddd Ganztägiger Name {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 Zweite Brüche, 2-stellig {0:ff} 20
F f f Zweite Brüche, 3-stellig {0:fff} 201
ffff Zweite Brüche, 4-stellig {0:ffff} 2016
F Volles Datum und volle Zeit {0:F} Mittwoch, 6. Juli 2016 18:30:14 PM
G Standarddatum und -uhrzeit {0:g} 06.07.2016 18:30 Uhr
gg Epoche {0:gg} ANZEIGE
hh Stunde (2-stellig, 12H) {0:hh} 06
HH Stunde (2-stellig, 24H) {0:HH} 18
M Monat und Tag {0:M} 6. Juli
mm Minuten, null aufgefüllt {0:mm} 30
MM Monat, null aufgefüllt {0:MM} 07
MMM 3-stelliger Monatsname {0:MMM} Jul
MMMM Vollständiger Monatsname {0:MMMM} Juli
ss Sekunden {0:ss} 14
r RFC1123 Datum {0:r} Mi, 06. Jul 2016 18:30:14 GMT
s Sortierbare Datumszeichenfolge {0:s} 2016-07-06T18: 30: 14
t Kurze Zeit {0:t} 6:30 ABENDS
T Lange Zeit {0:T} 18:30:14 Uhr
tt AM / PM {0:tt} PM
u Universelle sortierbare Ortszeit {0:u} 2016-07-06 18: 30: 14Z
U Universal GMT {0:U} Mittwoch, 6. Juli 2016 09:30:14 vormittags
Y Monat und Jahr {0:Y} Juli 2016
yy 2 stelliges Jahr {0:yy} 16
yyyy 4 stelliges Jahr {0:yyyy} 2016
zz 2-stelliger Zeitzonen-Offset {0:zz} +09
zzz Full Time Zone Offset {0:zzz} +09: 00

ToString ()

Die ToString () -Methode ist für alle Referenzobjekttypen vorhanden. Dies ist darauf zurückzuführen, dass alle Referenztypen von Object abgeleitet sind, das die ToString () - Methode enthält. Die ToString () -Methode der Objektbasisklasse gibt den Typnamen zurück. Das Fragment unten gibt "User" auf der 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 ToString () überschreiben, um die zurückgegebene Zeichenfolge 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 zu ToString ()

Während die String.Format() -Methode sicherlich zum Formatieren von Daten als Strings nützlich ist, kann es oft etwas übertrieben sein, insbesondere wenn ein einzelnes Objekt behandelt wird, wie unten gezeigt:

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

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

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

Einschränkungen und Formatierungsbeschränkungen

Während dieser Ansatz in einigen Szenarien möglicherweise einfacher ist, ist der ToString() Ansatz in Bezug auf das Hinzufügen von linkem oder rechtem Abstand wie in der String.Format() -Methode beschränkt:

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

Um dasselbe Verhalten mit der ToString() -Methode zu erreichen, müssen Sie eine andere Methode wie PadLeft() bzw. PadRight() verwenden:

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


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow