Welche Methode in der String-Klasse gibt nur die ersten N Zeichen zurück?

Ich möchte eine Erweiterungsmethode in die StringKlasse schreiben N, damit nur die ersten NZeichen angezeigt werden , wenn die Eingabezeichenfolge länger als die angegebene Länge ist .

So sieht es aus:

public static string TruncateLongString(this string str, int maxLength)
{
    if (str.Length <= maxLength)
        return str;
    else
        //return the first maxLength characters                
}

Mit welcher String.*()Methode kann ich nur die ersten NZeichen von erhalten str?

public static string TruncateLongString(this string str, int maxLength)
{
    if (string.IsNullOrEmpty(str))
        return str;
    return str.Substring(0, Math.Min(str.Length, maxLength));
}

string truncatedToNLength = new string(s.Take(n).ToArray());  

Diese Lösung hat den winzigen Vorteil, dass wenn n größer als s.Length ist, sie immer noch das Richtige tut.

Sie können LINQ str.Take(n)oder verwenden str.SubString(0, n), wobei letzteres eine ArgumentOutOfRangeExceptionAusnahme für auslöst n > str.Length.

Daran , dass die LINQ - Version eine gibt IEnumerable<char>, so würde man konvertieren das IEnumerable<char>zu string: new string(s.Take(n).ToArray()).

Immer wenn ich String-Manipulationen in C # durchführen muss, vermisse ich die guten alten Leftund RightFunktionen von Visual Basic, die viel einfacher zu verwenden sind als Substring.

In den meisten meiner C # -Projekte erstelle ich Erweiterungsmethoden für sie:

public static class StringExtensions
{
    public static string Left(this string str, int length)
    {
        return str.Substring(0, Math.Min(length, str.Length));
    }

    public static string Right(this string str, int length)
    {
        return str.Substring(str.Length - Math.Min(length, str.Length));
    }
}

Hinweis:
Der Math.MinTeil ist vorhanden, weil ein Substringausgelöst wird, ArgumentOutOfRangeExceptionwenn die Länge der Eingabezeichenfolge kleiner als die angeforderte Länge ist, wie bereits in einigen Kommentaren unter den vorherigen Antworten erwähnt.

Verwendung:

string longString = "Long String";

// returns "Long";
string left1 = longString.Left(4);

// returns "Long String";
string left2 = longString.Left(100);

Einfach:

public static String Truncate(String input,int maxLength)
{
   if(input.Length > maxLength)
      return input.Substring(0,maxLength);
   return input;
}

public static string TruncateLongString(this string str, int maxLength)
{
    return str.Length <= maxLength ? str : str.Remove(maxLength);
}

Wenn wir über Validierungen sprechen, warum wir nicht nach Null-String-Einträgen gesucht haben. Irgendwelche spezifischen Gründe?

Ich denke weiter unten helfen, da IsNullOrEmpty eine systemdefinierte Methode ist und ternäre Operatoren eine zyklomatische Komplexität = 1 haben, während if () {} else {} den Wert 2 hat.

    public static string Truncate(string input, int truncLength)
    {
        return (!String.IsNullOrEmpty(input) && input.Length >= truncLength)
                   ? input.Substring(0, truncLength)
                   : input;
    }

Ich habe dies in mein Projekt aufgenommen, nur weil die Wahrscheinlichkeit, dass es in Schleifen verwendet wird, in einem online gehosteten Projekt hoch ist, daher wollte ich keine Abstürze, wenn ich es verwalten könnte. Die Länge passt zu einer Spalte, die ich habe. Es ist C # 7

Nur eine Zeile:

 public static string SubStringN(this string Message, int Len = 499) => !String.IsNullOrEmpty(Message) ? (Message.Length >= Len ? Message.Substring(0, Len) : Message) : "";

Die .NET-Teilstring-Methode ist mit Gefahren behaftet. Ich habe Erweiterungsmethoden entwickelt, die eine Vielzahl von Szenarien behandeln. Das Schöne ist, dass das ursprüngliche Verhalten beibehalten wird. Wenn Sie jedoch einen zusätzlichen "true" -Parameter hinzufügen, wird zur Behandlung der Ausnahme auf die Erweiterungsmethode zurückgegriffen und die logischsten Werte basierend auf Index und Länge zurückgegeben. Zum Beispiel, wenn die Länge negativ ist und rückwärts zählt. Sie können die Testergebnisse mit einer Vielzahl von Werten auf der Geige unter folgender Adresse anzeigen: https://dotnetfiddle.net/m1mSH9 . Auf diese Weise erhalten Sie eine klare Vorstellung davon, wie Teilzeichenfolgen aufgelöst werden.

Ich füge diese Methoden immer allen meinen Projekten hinzu und muss mich nie um das Brechen von Code kümmern, da sich etwas geändert hat und der Index ungültig ist. Unten ist der Code.

    public static String Substring(this String val, int startIndex, bool handleIndexException)
    {
        if (!handleIndexException)
        { //handleIndexException is false so call the base method
            return val.Substring(startIndex);
        }
        if (string.IsNullOrEmpty(val))
        {
            return val;
        }
        return val.Substring(startIndex < 0 ? 0 : startIndex > (val.Length - 1) ? val.Length : startIndex);
    }

    public static String Substring(this String val, int startIndex, int length, bool handleIndexException)
    {
        if (!handleIndexException)
        { //handleIndexException is false so call the base method
            return val.Substring(startIndex, length);
        }
        if (string.IsNullOrEmpty(val))
        {
            return val;
        }
        int newfrom, newlth, instrlength = val.Length;
        if (length < 0) //length is negative
        {
            newfrom = startIndex + length;
            newlth = -1 * length;
        }
        else //length is positive
        {
            newfrom = startIndex;
            newlth = length;
        }
        if (newfrom + newlth < 0 || newfrom > instrlength - 1)
        {
            return string.Empty;
        }
        if (newfrom < 0)
        {
            newlth = newfrom + newlth;
            newfrom = 0;
        }
        return val.Substring(newfrom, Math.Min(newlth, instrlength - newfrom));
    }

Ich habe bereits im Mai 2010 darüber gebloggt : http://jagdale.blogspot.com/2010/05/substring-extension-method-that-does.html

Teilweise aus Gründen der Zusammenfassung (ohne LINQ-Lösung) sind hier zwei Einzeiler aufgeführt, die sich mit der int maxLengthEinschränkung befassen , negative Werte zuzulassen, sowie mit dem Fall einer Nullzeichenfolge:

1. Der SubstringWeg (aus Paul Ruanes Antwort ):

public static string Truncate(this string s, uint maxLength) =>
    s?.Substring(0, Math.Min(s.Length, (int)maxLength));

2. Der RemoveWeg (aus Kbrimingtons Antwort ):

public static string Truncate(this string s, uint maxLength) =>
    s?.Length > maxLength ? s.Remove((int)maxLength) : s;

substring(int startpos, int lenght);

string.Substring (0, n); // 0 - Startindex und n - Anzahl der Zeichen