Jak obciąć ciąg .NET?

Chciałbym obciąć łańcuch tak, aby jego długość nie była dłuższa niż podana wartość. Piszę do tabeli bazy danych i chcę się upewnić, że wartości, które piszę, spełniają ograniczenie typu danych kolumny.

Na przykład byłoby miło, gdybym mógł napisać:

string NormalizeLength(string value, int maxLength)
{
    return value.Substring(0, maxLength);
}

Niestety powoduje to wyjątek, ponieważ maxLengthgeneralnie przekracza granice ciągu value. Oczywiście mógłbym napisać funkcję taką jak poniżej, ale miałem nadzieję, że coś takiego już istnieje.

string NormalizeLength(string value, int maxLength)
{
    return value.Length <= maxLength ? value : value.Substring(0, maxLength);
} 

Gdzie jest nieuchwytny interfejs API, który wykonuje to zadanie? Czy jest jeden

Truncate()Niestety nie ma metody na ciąg znaków. Musisz napisać taką logikę. Możesz jednak zawinąć to w metodę rozszerzenia, abyś nie musiał jej wszędzie kopiować:

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

Teraz możemy napisać:

var someString = "...";
someString = someString.Truncate(2);

Lub zamiast operatora trójskładnikowego możesz użyć 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));
    }
}

Pomyślałem, że wrzucę swoje wdrożenie, ponieważ uważam, że obejmuje ono wszystkie sprawy, które zostały poruszone przez innych i robi to w zwięzły sposób, który jest nadal czytelny.

public static string Truncate(this string value, int maxLength)
{
    if (!string.IsNullOrEmpty(value) && value.Length > maxLength)
    {
        return value.Substring(0, maxLength);
    }

    return value;
}

To rozwiązanie opiera się głównie na rozwiązaniu Raya i otwiera metodę do zastosowania jako metodę rozszerzenia przy użyciu tego słowa kluczowego, podobnie jak LBushkin w swoim rozwiązaniu.

Ponieważ testowanie wydajności jest zabawne: (przy użyciu metod rozszerzenia linqpad )

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();

truncateMetoda była „znacznie” szybciej. #microoptimization

Wcześnie

• truncate 10 5788 tyknięć, które upłynęły (0,5788 ms) [w powtórzeniach 10K, 5,788E-05 ms na]
• smart-trunc10 upłynęło 8206 tyknięć (0,8206 ms) [w 10 000 powtórzeń, 8,206E-05 ms na]
• stringbuilder10 upłynęło 10 1055 tyknięć (1,0557 ms) [w 10 000 powtórzeń, 0,00010557 ms na]
• concat10 upłynęło 45495 tyknięć (4,5495 ms) [w 10 000 powtórzeń, 0,00045495 ms na]
• newstring 10 72535 tyknięć, które upłynęły (7,2535 ms) [w 10 000 powtórzeń, 0,00072535 ms na]

Późno

• truncate44 8835 tyknięć, które upłynęły (0,8835 ms) [w 10 000 powtórzeń, 8,835 E-05 ms na]
• stringbuilder44 upłynęło 13106 tyknięć (1,3106 ms) [w 10 000 powtórzeń, 0,00013106 ms na]
• smart-trunc44 14821 tyknięć, które upłynęły (1,4821 ms) [w 10 000 powtórzeń, 0,00014821 ms na]
• newstring44 upłynęło 144324 tyknięć (14,4324 ms) [w 10 000 powtórzeń, 0,00144324 ms na]
• concat44 upłynęło 174610 tyknięć (17,461 ms) [w 10 000 powtórzeń, 0,0017461 ms na]

Za długo

• smart-trunc64 6944 upłynęło (0,6944 ms) [w powtórzeniach 10K, 6,944E-05 ms na]
• truncate64 7686 tyknięć, które upłynęły (0,7686 ms) [w 10 000 powtórzeń, 7,686E-05 ms na]
• stringbuilder64 upłynęło 13314 tyknięć (1,3314 ms) [w 10 000 powtórzeń, 0,00013314 ms na]
• newstring64 upłynęło 177481 tyknięć (17,7481 ms) [w 10 000 powtórzeń, 0,00177481 ms na]
• concat64 upłynęło 241601 tyknięć (24,1601 ms) [w 10 000 powtórzeń, 0,00241601 ms na]

W .NET 4.0 możesz użyć Takemetody:

string.Concat(myString.Take(maxLength));

Nie przetestowano pod kątem wydajności!

Możesz użyć LINQ ... eliminuje to konieczność sprawdzania długości łańcucha. Co prawda może nie jest najbardziej wydajny, ale jest fajny.

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

lub

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

Zrobiłem mój w taki sposób

value = value.Length > 1000 ? value.Substring(0, 1000) : value;

Wygląda na to, że nikt tego jeszcze nie opublikował:

public static class StringExt
{
    public static string Truncate(this string s, int maxLength)
    {
        return s != null && s.Length > maxLength ? s.Substring(0, maxLength) : s;
    }
}

Użycie operatora && sprawia, że ​​jest on nieznacznie lepszy niż zaakceptowana odpowiedź.

.NET Framework posiada interfejs API do obcinania takiego łańcucha:

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

Ale w aplikacji C # prawdopodobnie wolisz tworzyć własne niż polegać na Microsoft.VisualBasic.dll, którego główną racją bytu jest kompatybilność wsteczna.

Inne rozwiązanie:

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

Wiem, że to stare pytanie, ale oto fajne rozwiązanie:

public static string Truncate(this string text, int maxLength, string suffix = "...")
{
    string str = text;
    if (maxLength > 0)
    {
        int length = maxLength - suffix.Length;
        if (length <= 0)
        {
            return str;
        }
        if ((text != null) && (text.Length > maxLength))
        {
            return (text.Substring(0, length).TrimEnd(new char[0]) + suffix);
        }
    }
    return str;
}

var myString = "hello world"
var myTruncatedString = myString.Truncate(4);

Zwraca: cześć ...

Podobny wariant z operatorem propagacji zerowej C # 6

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

Należy pamiętać, że zasadniczo sprawdzamy, czy tutaj valuejest dwa razy zerowy.

Nadal nie ma metody obcinania w 2016 r. Dla ciągów C #. Ale - przy użyciu składni C # 6.0:

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

To działa jak urok:

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

Biorąc @CaffGeek i upraszczając go:

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

Kndly zauważa, że ​​obcięcie łańcucha nie oznacza po prostu cięcia samego łańcucha o określonej długości, ale należy uważać, aby nie rozdzielić słowa.

np. ciąg: jest to ciąg testowy.

Chcę to wyciąć o 11. Jeśli użyjemy dowolnej z metod podanych powyżej, wynik będzie

to jest te

Nie tego chcemy

Metoda, której używam, może również nie być tak idealna, ale może poradzić sobie z większością sytuacji

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

Dlaczego nie:

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

tj. w polu zdarzeń value.Length < maxLengthodstępy do końca lub obcięcie nadmiaru.

Na wypadek, gdyby nie było wystarczająco dużo odpowiedzi, oto moje :)

public static string Truncate(this string str, 
                              int totalLength, 
                              string truncationIndicator = "")
{
    if (string.IsNullOrEmpty(str) || str.Length < totalLength) 
        return str;

    return str.Substring(0, totalLength - truncationIndicator.Length) 
           + truncationIndicator;
}

używać:

"I use it like this".Truncate(5,"~")

Ze względu na (nadmierną) złożoność dodam moją przeciążoną wersję, która zastępuje ostatnie 3 znaki wielokropkiem w odniesieniu do parametru maxLength.

public static string Truncate(this string value, int maxLength, bool replaceTruncatedCharWithEllipsis = false)
{
    if (replaceTruncatedCharWithEllipsis && maxLength <= 3)
        throw new ArgumentOutOfRangeException("maxLength",
            "maxLength should be greater than three when replacing with an ellipsis.");

    if (String.IsNullOrWhiteSpace(value)) 
        return String.Empty;

    if (replaceTruncatedCharWithEllipsis &&
        value.Length > maxLength)
    {
        return value.Substring(0, maxLength - 3) + "...";
    }

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

Moje dwa centy o przykładowej długości 30:

  var truncatedInput = string.IsNullOrEmpty(input) ? 
      string.Empty : 
      input.Substring(0, Math.Min(input.Length, 30));

Wolę odpowiedź jpiersona, ale żaden z przykładów, które widzę, nie obsługuje nieprawidłowego parametru maxLength, na przykład gdy maxLength <0.

Wybierane byłyby albo obsłużyć błąd w try / catch, ustawić parametr maxLength min na 0, lub jeśli maxLength jest mniejszy niż 0, zwrócić pusty ciąg

Niezoptymalizowany kod:

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

Oto rozwiązanie vb.net, zaznacz, że instrukcja if (choć brzydka) poprawia wydajność, ponieważ nie potrzebujemy instrukcji substring, gdy łańcuch jest już mniejszy niż maxlength ... Dzięki temu, że jest rozszerzeniem łańcucha, jest łatwy w użyciu. ..

 <System.Runtime.CompilerServices.Extension()> _
    Public Function Truncate(String__1 As String, maxlength As Integer) As String
        If Not String.IsNullOrEmpty(String__1) AndAlso String__1.Length > maxlength Then
            Return String__1.Substring(0, maxlength)
        Else
            Return String__1
        End If
    End Function

Wiem, że jest już mnóstwo odpowiedzi, ale potrzebowałem utrzymać nienaruszony początek i koniec łańcucha, ale skrócić go poniżej maksymalnej długości.

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

Służy to do tworzenia adresów URL programu SharePoint o maksymalnej długości 260 znaków.

Nie ustawiłem długości jako parametru, ponieważ jest to stała 260. Nie uczyniłem też pierwszej długości podłańcucha parametrem, ponieważ chcę, aby pękała w określonym punkcie. Wreszcie drugi podciąg to długość źródła - 20, ponieważ znam strukturę folderów.

Można to łatwo dostosować do konkretnych potrzeb.

Wiem, że jest tu już mnóstwo odpowiedzi, ale jest to ta, z którą poszedłem, która obsługuje zarówno ciągi zerowe, a sytuacja, w której przekazywana długość jest ujemna:

public static string Truncate(this string s, int length)
{
    return string.IsNullOrEmpty(s) || s.Length <= length ? s 
        : length <= 0 ? string.Empty 
        : s.Substring(0, length);
}

W C # 8 można użyć nowej funkcji Ranges ...

value = value[..Math.Min(30, value.Length)];

Nic nie wiem o tym w .net - oto moja wersja, która dodaje „...”:

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

TruncateString

public static string _TruncateString(string input, int charaterlimit)
{
    int characterLimit = charaterlimit;
    string output = input;

    // Check if the string is longer than the allowed amount
    // otherwise do nothing
    if (output.Length > characterLimit && characterLimit > 0)
    {
        // cut the string down to the maximum number of characters
        output = output.Substring(0, characterLimit);
        // Check if the character right after the truncate point was a space
        // if not, we are in the middle of a word and need to remove the rest of it
        if (input.Substring(output.Length, 1) != " ")
        {
            int LastSpace = output.LastIndexOf(" ");

            // if we found a space then, cut back to that space
            if (LastSpace != -1)
            {
                output = output.Substring(0, LastSpace);
            }
        }
        // Finally, add the "..."
        output += "...";
    }
    return output;
}

Jako dodatek do omówionych powyżej możliwości chciałbym podzielić się moim rozwiązaniem. Jest to metoda rozszerzenia, która pozwala null (zwraca string.Empty), istnieje również druga metoda .Truncate () do używania jej z wielokropkiem. Uwaga, nie jest zoptymalizowana pod kątem wydajności.

public static string Truncate(this string value, int maxLength) =>
    (value ?? string.Empty).Substring(0, (value?.Length ?? 0) <= (maxLength < 0 ? 0 : maxLength) ? (value?.Length ?? 0) : (maxLength < 0 ? 0 : maxLength));
public static string Truncate(this string value, int maxLength, string ellipsis) =>
    string.Concat(value.Truncate(maxLength - (((value?.Length ?? 0) > maxLength ? ellipsis : null)?.Length ?? 0)), ((value?.Length ?? 0) > maxLength ? ellipsis : null)).Truncate(maxLength);

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

        return new string(value.Take(maxLength).ToArray());// use LINQ and be happy
    }

Obciąć ciąg

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

Oto kod, którego zwykle używam:

string getSubString(string value, int index, int length)
        {
            if (string.IsNullOrEmpty(value) || value.Length <= length)
            {
                return value;
            }
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            for (int i = index; i < length; i++)
            {
                sb.AppendLine(value[i].ToString());
            }
            return sb.ToString();
        }