.NET Formatieren Sie eine Zeichenfolge mit festen Leerzeichen

Ermöglicht die .NET String.Format-Methode die Platzierung eines Strings an einer festen Position innerhalb eines Strings mit fester Länge?

"String Goes Here"
"String Goes Here"
"String Goes Here"

Wie geht das mit .NET?

Bearbeiten - Ich habe Format / PadLeft / PadRight zu Tode versucht. Sie arbeiten nicht. Ich weiß nicht warum. Am Ende schrieb ich meine eigene Funktion, um dies zu tun.

Bearbeiten - Ich habe einen Fehler gemacht und im Formatbezeichner einen Doppelpunkt anstelle eines Kommas verwendet. Sollte "{0,20}" sein.

Vielen Dank für all die hervorragenden und richtigen Antworten.

Dadurch erhalten Sie genau die Zeichenfolgen, nach denen Sie gefragt haben:

string s = "String goes here";
string lineAlignedRight  = String.Format("{0,27}", s);
string lineAlignedCenter = String.Format("{0,-27}",
    String.Format("{0," + ((27 + s.Length) / 2).ToString() +  "}", s));
string lineAlignedLeft   = String.Format("{0,-27}", s);

Zumindest der erste und der letzte sind mit der folgenden Syntax möglich:

String.Format("{0,20}", "String goes here");
String.Format("{0,-20}", "String goes here");

Ab Visual Studio 2015 können Sie dies auch mit interpolierten Zeichenfolgen tun (dies ist ein Compilertrick, sodass es keine Rolle spielt, auf welche Version des .net-Frameworks Sie abzielen).

string value = "String goes here";
string txt1 = $"{value,20}";
string txt2 = $"{value,-20}";

Du wurdest gezeigt PadLeftund PadRight. Dies wird die fehlenden ausfüllen PadCenter.

public static class StringUtils
{
    public static string PadCenter(this string s, int width, char c)
    {
        if (s == null || width <= s.Length) return s;

        int padding = width - s.Length;
        return s.PadLeft(s.Length + padding / 2, c).PadRight(width, c);
    }
}

Hinweis für sich selbst: Vergessen Sie nicht, Ihren eigenen Lebenslauf zu aktualisieren: "Eines Tages habe ich sogar Joel Coehoorns Code repariert!" ;-D -Serge

Versuche dies:

"String goes here".PadLeft(20,' ');
"String goes here".PadRight(20,' ');

Für die Mitte erhalten Sie die Länge der Zeichenfolge und machen Padleft und Padright mit den erforderlichen Zeichen

int len = "String goes here".Length;
int whites = len /2;
"String goes here".PadRight(len + whites,' ').PadLeft(len + whites,' ');

Vielen Dank für die Diskussion, diese Methode funktioniert auch (VB):

Public Function StringCentering(ByVal s As String, ByVal desiredLength As Integer) As String
    If s.Length >= desiredLength Then Return s
    Dim firstpad As Integer = (s.Length + desiredLength) / 2
    Return s.PadLeft(firstpad).PadRight(desiredLength)
End Function

1. StringCentering () akzeptiert zwei Eingabewerte und gibt eine formatierte Zeichenfolge zurück.
2. Wenn die Länge von s größer oder gleich deisredLength ist , gibt die Funktion die ursprüngliche Zeichenfolge zurück.
3. Wenn die Länge von s kleiner als die gewünschte Länge ist , werden beide Enden aufgefüllt.
4. Da der Zeichenabstand eine Ganzzahl ist und kein halber Raum vorhanden ist, kann es zu einer ungleichmäßigen Aufteilung des Raums kommen. Bei dieser Implementierung geht die größere Aufteilung zum führenden Ende.
5. Die Funktion erfordert .NET Framework aufgrund von PadLeft () und PadRight () .
6. In der letzten Zeile der Funktion, Bindung wird von links nach rechts, so firstpad durch den aufgebracht wird , gefolgt desiredLength Pad.

Hier ist die C # -Version:

public string StringCentering(string s, int desiredLength)
{
    if (s.Length >= desiredLength) return s;
    int firstpad = (s.Length + desiredLength) / 2;
    return s.PadLeft(firstpad).PadRight(desiredLength);
}

Zum besseren Verständnis wird das Integer der Ganzzahlvariablen firstpad verwendet. s.PadLeft (firstpad) wendet die (richtige Anzahl) führender Leerzeichen an. Das PadRight ganz rechts (gewünschte Länge) hat eine niedrigere Bindung, die durch Anwenden von nachgestellten Leerzeichen abgeschlossen wird.

Hier ist eine VB.NET-Version, die ich erstellt habe, inspiriert von Joel Coehoorns Antwort, Olivers Bearbeitung und Shaunmartins Kommentar:

    <Extension()>
Public Function PadCenter(ByVal [string] As String, ByVal width As Integer, ByVal c As Char) As String

    If [string] Is Nothing Then [string] = String.Empty
    If (width <= [string].Length) Then Return [string]

    Dim padding = width - [string].Length
    Return [string].PadLeft([string].Length + (padding \ 2), c).PadRight(width, c)

End Function

<Extension()>
Public Function PadCenter(ByVal [string] As String, ByVal width As Integer) As String

    If [string] Is Nothing Then [string] = String.Empty
    If (width <= [string].Length) Then Return [string]

    Dim padding = width - [string].Length
    Return [string].PadLeft([string].Length + (padding \ 2)).PadRight(width)

End Function

Dies wird als Zeichenfolgenerweiterung in einem öffentlichen Modul eingerichtet (wie Sie Erweiterungen in VB.NET ausführen, etwas anders als in C #). Meine geringfügige Änderung besteht darin, dass eine Nullzeichenfolge als leere Zeichenfolge behandelt wird und eine leere Zeichenfolge mit dem Breitenwert aufgefüllt wird (entspricht meinen speziellen Anforderungen). Hoffentlich kann dies für jeden, der es benötigt, leicht in C # konvertiert werden. Wenn es eine bessere Möglichkeit gibt, auf die oben erwähnten Antworten, Änderungen und Kommentare zu verweisen, die meinen Beitrag inspiriert haben, lassen Sie es mich bitte wissen und ich werde es tun - ich bin relativ neu im Posten und konnte es nicht herausfinden Hinterlasse einen Kommentar (möglicherweise noch nicht genügend Wiederholungen).

Ich habe einen CodeProject-Artikel veröffentlicht, der genau Ihren Wünschen entspricht.

Siehe: AC # Weg für indirekte Breite und Stil Formatierung.

Grundsätzlich handelt es sich um eine Methode, FormatEx, die sich wie String.Format verhält, außer dass sie einen Modifikator für die zentrierte Ausrichtung zulässt.

FormatEx("{0,c10}", value);

Bedeutet, den Wert von varArgs [0] in einem 10 Zeichen breiten Feld zu zentrieren und nach rechts zu lehnen, wenn ein zusätzlicher Auffüllraum erforderlich ist.

FormatEx("{0,c-10}", value);

Bedeutet, dass der Wert von varArgs [0] in einem 10 Zeichen breiten Feld zentriert wird. Lehnen Sie sich nach links, wenn ein zusätzlicher Platz zum Auffüllen erforderlich ist.

Bearbeiten: Intern ist es eine Kombination aus Joels PadCenter mit einer Analyse, um das Format und varArgs für einen Aufruf von String.Format neu zu strukturieren, der genau das tut, was Sie wollen.

-Jesse

Es scheint, als ob Sie so etwas wollen, das Ihre Zeichenfolge an einem festen Punkt in einer Zeichenfolge konstanter Länge platziert:

Dim totallength As Integer = 100
Dim leftbuffer as Integer = 5
Dim mystring As String = "string goes here"
Dim Formatted_String as String = mystring.PadLeft(leftbuffer + mystring.Length, "-") + String.Empty.PadRight(totallength - (mystring.Length + leftbuffer), "-")

Beachten Sie, dass dies Probleme verursachen wird, wenn mystring.length + leftbuffer die Gesamtlänge überschreitet

/// <summary>
/// Returns a string With count chars Left or Right value
/// </summary>
/// <param name="val"></param>
/// <param name="count"></param>
/// <param name="space"></param>
/// <param name="right"></param>
/// <returns></returns>
 public static string Formating(object val, int count, char space = ' ', bool right = false)
{
    var value = val.ToString();
    for (int i = 0; i < count - value.Length; i++) value = right ? value + space : space + value;
    return value;
}