Como truncar uma string .NET?

Gostaria de truncar uma string de forma que seu comprimento não exceda um determinado valor. Estou escrevendo em uma tabela de banco de dados e quero garantir que os valores que eu escrevo atendam às restrições do tipo de dados da coluna.

Por exemplo, seria bom se eu pudesse escrever o seguinte:

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

Infelizmente, isso gera uma exceção, porque maxLengthgeralmente excede os limites da string value. Claro, eu poderia escrever uma função como a seguinte, mas esperava que algo assim já existisse.

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

Onde está a API indescritível que executa essa tarefa? Existe um?

Truncate()Infelizmente, não há um método na string. Você precisa escrever esse tipo de lógica. O que você pode fazer, no entanto, é agrupar isso em um método de extensão para que você não precise duplicá-lo em qualquer lugar:

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

Agora podemos escrever:

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

Ou, em vez do operador ternário, você pode usar 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));
    }
}

Imaginei que lançaria minha implementação, pois acredito que ela cobre todos os casos que foram abordados pelos outros e o faz de uma maneira concisa que ainda é legível.

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

    return value;
}

Essa solução baseia-se principalmente na solução de Ray e abre o método para uso como método de extensão, usando a palavra - chave this, assim como LBushkin em sua solução.

Como o teste de desempenho é divertido: (usando métodos de extensão 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();

O truncatemétodo foi "significativamente" mais rápido. #microoptimization

Cedo

• truncate10 5788 carrapatos decorridos (0,5788 ms) [em 10K repetições, 5.788E-05 ms por]
• ticks de 8206 smart-trunc10 decorridos (0,8206 ms) [em 10K repetições, 8,206E-05 ms por]
• stringbuilder10 10557 pontos decorridos (1.0557 ms) [em 10K repetições, 0,00010557 ms por]
• concat10 45495 tiques decorridos (4.5495 ms) [em 10K repetições, 0,00045495 ms por]
• newstring10 72535 tiques decorridos (7,2535 ms) [em 10K repetições, 0,00072535 ms por]

Atrasado

• truncate44 8835 tiques decorridos (0,8835 ms) [em 10K repetições, 8,835E-05 ms por]
• stringbuilder44 13106 pontos decorridos (1.3106 ms) [em 10K repetições, 0,00013106 ms por]
• ticks 14821 smart-trunc44 decorridos (1,4821 ms) [em 10K repetições, 0,00014821 ms por]
• newstring44 144324 pontos decorridos (14,4324 ms) [em 10K repetições, 0,00144324 ms por]
• concat44 174610 tiques decorridos (17,461 ms) [em 10K repetições, 0,0017461 ms por]

Demasiado longo

• tiquetaques smart-trunc64 6944 decorridos (0,6944 ms) [em 10K repetições, 6,944E-05 ms por]
• truncate64 7686 tiques decorridos (0,7686 ms) [em 10K repetições, 7,686E-05 ms por]
• stringbuilder64 13314 carrapatos decorridos (1,3314 ms) [em 10K repetições, 0,00013314 ms por]
• newstring64 177481 tiques decorridos (17.7481 ms) [em 10K repetições, 0,00177481 ms por]
• concat64 241601 ticks decorridos (24.1601 ms) [em 10K repetições, 0,00241601 ms por]

No .NET 4.0, você pode usar o Takemétodo:

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

Não testado quanto à eficiência!

Você pode usar o LINQ ... elimina a necessidade de verificar o comprimento da string. É certo que talvez não seja o mais eficiente, mas é divertido.

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

ou

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

Eu fiz o meu em uma linha como esta

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

Parece que ninguém postou isso ainda:

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

O uso do operador && o torna marginalmente melhor que a resposta aceita.

O .NET Framework possui uma API para truncar uma string como esta:

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

Mas, em um aplicativo C #, você provavelmente prefere usar o Microsoft.VisualBasic.dll, cuja principal razão de ser é a compatibilidade com versões anteriores.

Outra solução:

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

Sei que essa é uma pergunta antiga, mas aqui está uma boa solução:

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

Retorna: olá ...

Uma variante semelhante ao operador de propagação nula do C # 6

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

Observe que estamos essencialmente verificando se valueé nulo duas vezes aqui.

Ainda não há método Truncar em 2016 para seqüências de caracteres C #. Mas - usando a sintaxe do 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); 
  }
}

Ele funciona como um encanto:

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

Tomando o @CaffGeek e simplificando-o:

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

Observe que truncar uma string não significa apenas cortar uma string apenas com um comprimento especificado, mas deve-se tomar cuidado para não dividir a palavra.

eg string: esta é uma string de teste.

Eu quero cortar às 11. Se usarmos algum dos métodos acima, o resultado será

isso é um te

Não é isso que queremos

O método que estou usando também pode não ser tão perfeito, mas pode lidar com a maior parte da situação

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

Por que não:

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

ou seja, nos value.Length < maxLengthespaços do bloco de eventos até o fim ou truncar o excesso.

Apenas no caso de não haver respostas suficientes aqui, aqui está a minha :)

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

usar:

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

Por uma questão de (excesso) complexidade, adicionarei minha versão sobrecarregada que substitui os últimos 3 caracteres por uma elipse em relação ao parâmetro 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)); 
}

Meus dois centavos com exemplo de comprimento de 30:

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

Prefiro a resposta de jpierson, mas nenhum dos exemplos aqui que posso ver está lidando com um parâmetro maxLength inválido, como quando maxLength <0.

As opções seriam manipular o erro em uma tentativa / captura, fixe o parâmetro maxLength min a 0 ou, se maxLength for menor que 0, retorne uma sequência vazia.

Código não otimizado:

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

Aqui está uma solução vb.net, marque que a instrução if (embora feia) melhora o desempenho, porque não precisamos da instrução substring quando a string já é menor que o comprimento máximo ... Ao torná-la uma extensão da string, é fácil de usar. ..

 <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

Eu sei que já existem muitas respostas, mas minha necessidade era manter intacto o início e o fim da string, mas encurtá-la para o comprimento máximo.

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

Isso é para criar URLs do SharePoint com um comprimento máximo de 260 caracteres.

Eu não tornei o comprimento um parâmetro, pois é uma constante 260. Também não fiz o primeiro comprimento da substring um parâmetro porque quero que ele quebre em um ponto específico. Finalmente, a segunda substring é o comprimento da fonte - 20 desde que conheço a estrutura da pasta.

Isso pode ser facilmente adaptado às suas necessidades específicas.

Eu sei que já existem muitas respostas aqui, mas essa é a que eu tenho, que lida com cadeias nulas e a situação em que o comprimento passado é negativo:

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

No C # 8, o novo recurso Ranges pode ser usado ...

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

Não há nada no .net para isso que eu saiba - aqui está a minha versão que adiciona "...":

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

Como complemento às possibilidades discutidas acima, eu gostaria de compartilhar minha solução. É um método de extensão que permite null (retorna string.Empty) e também existe um segundo .Truncate () para usá-lo com reticências. Cuidado, não é um desempenho otimizado.

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
    }

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

Este é o código que eu costumo usar:

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