Wie trenne ich eine .NET-Zeichenfolge?

Oder statt des ternären operator, den Sie verwenden konnten, Math.min

public static class StringExt
{
    public static string Truncate( this string value, int maxLength )
    {
        if (string.IsNullOrEmpty(value)) { return value; }

        return value.Substring(0, Math.Min(value.Length, maxLength));
    }
}

InformationsquelleAutor der Antwort CaffGeek

Könnte man mit LINQ... es eliminiert die Notwendigkeit, überprüfen Sie die string-Länge. Zugegebenermaßen vielleicht nicht die effizienteste, aber es macht Spaß.

string result = string.Join("", value.Take(maxLength)); //.NET 4 Join

oder

string result = new string(value.Take(maxLength).ToArray());

InformationsquelleAutor der Antwort tames

Den .NET-Framework bietet eine API zum abschneiden einer Zeichenfolge wie diese:

Microsoft.VisualBasic.Strings.Left(string, int);

Aber in einer C# - app, auf die Sie wohl lieber roll your own, als sich eine Abhängigkeit Microsoft.VisualBasic.dll, deren wichtigste raison d ' etre ist die Abwärtskompatibilität.

InformationsquelleAutor der Antwort Joe

Da die Leistung testen Spaß macht: (mit linqpad-Erweiterung Methoden)

var val = string.Concat(Enumerable.Range(0, 50).Select(i => i % 10));

foreach(var limit in new[] { 10, 25, 44, 64 })
    new Perf<string> {
        { "newstring" + limit, n => new string(val.Take(limit).ToArray()) },
        { "concat" + limit, n => string.Concat(val.Take(limit)) },
        { "truncate" + limit, n => val.Substring(0, Math.Min(val.Length, limit)) },
        { "smart-trunc" + limit, n => val.Length <= limit ? val : val.Substring(0, limit) },
        { "stringbuilder" + limit, n => new StringBuilder(val, 0, Math.Min(val.Length, limit), limit).ToString() },
    }.Vs();

Den truncate Methode war "deutlich" schneller. #microoptimization

Frühen

• truncate10 5788 ticks verstrichen (0.5788 ms) [in 10K reps, 5.788 E-05 ms pro]
• smart-trunc10 8206 ticks verstrichen (0.8206 ms) [in 10K reps, 8.206 E-05 ms pro]
• stringbuilder10 10557 ticks verstrichen (1.0557 ms) [in 10K reps, 0.00010557 ms pro]
• concat10 45495 ticks verstrichen (4.5495 ms) [in 10K reps, 0.00045495 ms pro]
• newstring10 72535 ticks verstrichen (7.2535 ms) [in 10K reps, 0.00072535 ms pro]

Spät

• truncate44 8835 ticks verstrichen (0.8835 ms) [in 10K reps, 8.835 E-05 ms pro]
• stringbuilder44 13106 ticks verstrichen (1.3106 ms) [in 10K reps, 0.00013106 ms pro]
• smart-trunc44 14821 ticks verstrichen (1.4821 ms) [in 10K reps, 0.00014821 ms pro]
• newstring44 144324 ticks verstrichen (14.4324 ms) [in 10K reps, 0.00144324 ms pro]
• concat44 174610 ticks verstrichen (17.461 ms) [in 10K reps, 0.0017461 ms pro]

Zu Lange

• smart-trunc64 6944 ticks verstrichen (0.6944 ms) [in 10K reps, 6.944 E-05 ms pro]
• truncate64 7686 ticks verstrichen (0.7686 ms) [in 10K reps, 7.686 E-05 ms pro]
• stringbuilder64 13314 ticks verstrichen (1.3314 ms) [in 10K reps, 0.00013314 ms pro]
• newstring64 177481 ticks verstrichen (17.7481 ms) [in 10K reps, 0.00177481 ms pro]
• concat64 241601 ticks verstrichen (24.1601 ms) [in 10K reps, 0.00241601 ms pro]

InformationsquelleAutor der Antwort drzaus

Eine ähnliche Variante mit C# 6 ist Null propagation operator

public static string Truncate(this string value, int maxLength)
{
    return value?.Length <= maxLength ? value : value?.Substring(0, maxLength);
}

Bitte beachten Sie, wir sind im wesentlichen der überprüfung, ob value null ist zweimal hier.

InformationsquelleAutor der Antwort Jamie Rees

Kndly beachten Sie, dass das abschneiden einer Zeichenfolge nicht nur bedeutet, justing schneiden einen string auf eine angegebene Länge allein, sondern muss aufpassen, nicht zu Spalten, das Wort.

z.B. string : dies ist ein test-string.

Will ich Schnitt es am 11 . Wenn wir verwenden die Methode, die oben gegeben wird das Ergebnis

dies ist ein te

Dies ist nicht das, was wir wollen,

Die Methode, die ich benutze, kann auch nicht so perfekt, aber es kann mit den meisten die situation

public string CutString(string source, int length)
{
        if (source== null || source.Length < length)
        {
            return source;
        }
        int nextSpace = source.LastIndexOf(" ", length);
        return string.Format("{0}...", input.Substring(0, (nextSpace > 0) ? nextSpace : length).Trim());
} 

InformationsquelleAutor der Antwort Sen K. Mathew

Immer noch keine Truncate-Methode im Jahr 2016 für C# - strings.
Aber - Mit C# 6.0 Syntax:

public static class StringExtension
{
  public static string Truncate(this string s, int max) 
  { 
    return s?.Length > max ? s.Substring(0, max) : s ?? throw new ArgumentNullException(s); 
  }
}

Es funktioniert wie ein Charme:

"Truncate me".Truncate(8);
Result: "Truncate"

InformationsquelleAutor der Antwort Tobias Schiele

Warum nicht:

string NormalizeLength(string value, int maxLength)
{
    //check String.IsNullOrEmpty(value) and act on it. 
    return value.PadRight(maxLength).Substring(0, maxLength);
}

D. H. im Falle value.Length < maxLength pad Leerzeichen am Ende oder kürzen Sie die überschüssige.

InformationsquelleAutor der Antwort Sri

Ich lieber jpierson Antwort, aber keines der Beispiele hier, die ich sehen kann sind im Umgang mit einem ungültigen maxLength-parameter, wie wenn maxLength < 0.

Wahl wäre entweder behandeln Sie die Fehler in einem try/catch, clamp den maxLength-parameter min 0, oder, wenn maxLength ist weniger als 0, wird ein leerer string zurückgegeben.

Nicht optimiertem code:

public string Truncate(this string value, int maximumLength)
{
    if (string.IsNullOrEmpty(value) == true) { return value; }
    if (maximumLen < 0) { return String.Empty; }
    if (value.Length > maximumLength) { return value.Substring(0, maximumLength); }
    return value;
}

InformationsquelleAutor der Antwort deegee

Ich weiß es gibt eine Tonne von Antworten schon, aber mein Bedürfnis zu halten war der Anfang und das Ende des Strings intakt, sondern es verkürzen, um unter die max Länge.

    public static string TruncateMiddle(string source)
    {
        if (String.IsNullOrWhiteSpace(source) || source.Length < 260) 
            return source;

        return string.Format("{0}...{1}", 
            source.Substring(0, 235),
            source.Substring(source.Length - 20));
    }

Dies ist für die Erstellung von SharePoint-URLs haben eine maximale Länge von 260 Zeichen.

Ich nicht die Länge eines Parameters, da es eine Konstante 260. Ich habe auch nicht die erste, die substring-Länge parameter, weil ich will, es zu brechen an einem bestimmten Punkt. Schließlich, der zweiten Teilzeichenfolge ist die Länge der Quell - 20 da ich weiß, dass die Ordner-Struktur.

Diese könnten sich leicht an Ihre spezifischen Bedürfnisse.

InformationsquelleAutor der Antwort Paul Haan

Ich würde Empfehlen, mit der substring-Methode für die gleiche effektive Funktionalität.

    //Gets first n characters.
    string subString = inputString.Substring(0, n);

Dies hat den Vorteil, dass Sie splice Ihren string aus entweder seitlich oder sogar irgendwo in der Mitte ohne das schreiben von zusätzlichen Methoden. Hoffe, das hilft 🙂

Weitere Referenz: https://www.dotnetperls.com/substring

InformationsquelleAutor der Antwort SethMartn

Gibt es nichts .net für das, dass ich mir bewusst bin - hier ist meine version, die hinzufügt:"...":

public static string truncateString(string originalString, int length) {
  if (string.IsNullOrEmpty(originalString)) {
   return originalString;
  }
  if (originalString.Length > length) {
   return originalString.Substring(0, length) + "...";
  }
  else {
   return originalString;
  }
}

InformationsquelleAutor der Antwort Ray

Abschneiden, String

public static string TruncateText(string strText, int intLength)
{
    if (!(string.IsNullOrEmpty(strText)))
    {                                
        //split the text.
        var words = strText.Split(' ');

        //calculate the number of words
        //based on the provided characters length 
        //use an average of 7.6 chars per word.
        int wordLength = Convert.ToInt32(Math.Ceiling(intLength / 7.6));

        //if the text is shorter than the length,
        //display the text without changing it.
        if (words.Length <= wordLength)
            return strText.Trim();                

        //put together a shorter text
        //based on the number of words
        return string.Join(" ", words.Take(wordLength)) + " ...".Trim();
    }
        else
        {
            return "";
        }            
    }

InformationsquelleAutor der Antwort V.T.