Können die maximale Anzahl von Zeichen definiert werden, die in C# format-strings wie in C printf?

Nicht finden, wie zu tun. Was ich fand, war mehr oder weniger auf die Linien (http://blog.stevex.net/string-formatting-in-csharp/):

Es ist wirklich nicht jede Formatierung in einen string zu, neben der Ausrichtung. Ausrichtung funktioniert für jedes argument, das gedruckt wird, in eine Zeichenfolge.Format aufrufen.
Probe Erzeugt

String.Format(“->{1,10}<-”, “Hello”);  //gives "->     Hello<-" (left padded to 10)
String.Format(“->{1,-10}<-”, “Hello”); //gives "->Hello     <-" (right padded to 10)

Was genau wollen Sie erreichen? Können Sie Beispiele von dem, was Sie sehen möchten?
ich bin versucht zu konvertieren von C-format-Zeichenfolgen zu C# format-strings. in C können Sie angeben, %-4.4 s und ähnliche.
warum nach unten Stimmen? dies ist die essentielle Frage!
und noch wichtiger ist, wenn nicht ein Fehler im C# - format-string-design.
Ich würde nicht nennen es ein - Fehler. Es ist eher so, dass die spezifische Funktion, die Sie suchen ist nicht verfügbar. String.Format unterstützt auch mehrere Funktionen nicht im C format-strings. Bedeutet das, dass die C ' format-strings sind zwangsläufig fehlerhaft?

InformationsquelleAutor char m | 2010-11-05

c#string string-formatting

7

Was Sie wollen, ist nicht "nativ" unterstützt C# string-Formatierung wie die String.ToString Methoden des string-Objekts nur den string selbst.

Beim Aufruf
```
string.Format("{0:xxx}",someobject);
```
wenn someobject implementiert die IFormattable-Schnittstelle, die überlastung ToString(string format,IFormatProvider formatProvider) Methode wird aufgerufen, mit "xxx" als format parameter.

So, bei den meisten ist dies nicht ein Fehler im design .NET-string-Formatierung, sondern einfach nur fehlende Funktionalität in der string-Klasse.

Wenn Sie wirklich brauchen, können Sie mit einem der vorgeschlagenen workarounds, oder erstellen Sie Ihre eigenen Klasse die IFormattable-Schnittstelle.

danke! u hast auf jeden Fall Recht. es ist die string-Klasse, die fehlt etwas. aber u verwenden Sie xxx als ein Beispiel für einige format oder ist es wirklich etwas bedeuten (z.B. 3 Zeichen)?
kein xxx war nur ein Beispiel. Tatsächlich, was es bedeutet, entscheidet sich durch die Umsetzung die IFormattable-Schnittstelle. Jedenfalls (sprechen wie ein c++ - Liebhaber), string Formatierung in c++ ist im Vergleich zu dem in c# Scheiße, sprechen von einem Fehler für die Tatsache, dass diese Besonderheit ist fehlen scheint ziemlich seltsam zu mir 😉

InformationsquelleAutor Paolo Tedesco

Ich geschrieben habe, eine benutzerdefinierte formatter implementiert, dass ein "L" - Formatbezeichner verwendet, um die maximale Breite. Dies ist nützlich, wenn wir brauchen, um die Kontrolle der Größe der formatierten Ausgabe sagen, wenn bestimmt für eine Spalte in der Datenbank-oder CRM-Bereich.

public class StringFormatEx : IFormatProvider, ICustomFormatter
{
    ///<summary>
    ///ICustomFormatter member
    ///</summary>
    public string Format(string format, object argument, IFormatProvider formatProvider)
    {
        #region func-y town
        Func<string, object, string> handleOtherFormats = (f, a) => 
        {
            var result = String.Empty;
            if (a is IFormattable) { result = ((IFormattable)a).ToString(f, CultureInfo.CurrentCulture); }
            else if (a != null) { result = a.ToString(); }
            return result;
        };
        #endregion

        //reality check.
        if (format == null || argument == null) { return argument as string; }

        //perform default formatting if arg is not a string.
        if (argument.GetType() != typeof(string)) { return handleOtherFormats(format, argument); }

        //get the format specifier.
        var specifier = format.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture);

        //perform extended formatting based on format specifier.
        switch(specifier)
        {
            case "L": 
                return LengthFormatter(format, argument);
            default:
                return handleOtherFormats(format, argument);
        }
    }

    ///<summary>
    ///IFormatProvider member
    ///</summary>
    public object GetFormat(Type formatType)
    {
        if (formatType == typeof(ICustomFormatter))
            return this;
        else
            return null;
    }

    ///<summary>
    ///Custom length formatter.
    ///</summary>
    private string LengthFormatter(string format, object argument)
    {
        //specifier requires length number.
        if (format.Length == 1)
        {
            throw new FormatException(String.Format("The format of '{0}' is invalid; length is in the form of Ln where n is the maximum length of the resultant string.", format));
        }

        //get the length from the format string.
        int length = int.MaxValue;
        int.TryParse(format.Substring(1, format.Length - 1), out length);

        //returned the argument with length applied.
        return argument.ToString().Substring(0, length);
    }
}

Nutzung ist

var result = String.Format(
    new StringFormatEx(),
    "{0:L4} {1:L7}",
    "Stack",
    "Overflow");

Assert.AreEqual("Stac Overflo", result);

InformationsquelleAutor Doug Wiley

Dies ist nicht eine Antwort, wie die Verwendung von string.format, sondern ein anderer Weg, die Verkürzung ein string mit extension-Methoden. Auf diese Weise können Sie die maximale Länge der string direkt, auch ohne string.format.

public static class ExtensionMethods
{
    ///<summary>
    /// Shortens string to Max length
    ///</summary>
    ///<param name="input">String to shortent</param>
    ///<returns>shortened string</returns>
    public static string MaxLength(this string input, int length)
    {
        if (input == null) return null;
        return input.Substring(0, Math.Min(length, input.Length));
    }
}

Beispiel für die Nutzung:

string Test = "1234567890";
string.Format("Shortened String = {0}", Test.MaxLength(5));
string.Format("Shortened String = {0}", Test.MaxLength(50));

Output: 
Shortened String = 12345
Shortened String = 1234567890

InformationsquelleAutor Andy

0

Kannst du nicht einfach die Länge Argumente, die den parameter verwenden, anstatt das format?

String.Format("->{0}<-", toFormat.PadRight(10)); //->Hallo <-

Oder schreiben Sie Ihre eigenen formatter, um Ihnen zu erlauben, dies zu tun?

c Kommentare zu Frage

InformationsquelleAutor Ian Johnson
0

Warum nicht einfach Substr, beschränken Sie die Länge der Zeichenfolge?
```
String s = "abcdefghijklmnopqrstuvwxyz";
String.Format("Character limited: {0}", s.Substr(0, 10));
```
c Kommentare zu Frage
Ich vermisste die Tatsache, dass selbst Substr hat ein paar unangenehme Umsetzung unterscheidet sich von jeder anderen Sprache. Ich habe diesen workaround, wie es ist und es schlägt fehl, wenn der string kürzer ist als 10 Zeichen...

InformationsquelleAutor Moo-Juice

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.