C# 如何截断.NET字符串？

我希望截断字符串，使其长度不超过给定值。我正在向数据库表写入数据，并希望确保写入的值满足列数据类型的约束

例如，如果我能写以下内容，那就太好了：

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

不幸的是，这引发了一个异常，因为

maxLength

通常超出字符串

值的边界。当然，我可以编写如下函数，但我希望这样的函数已经存在

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

string normalizeleLength（字符串值，int maxLength）
{
返回值.Length不幸的是，字符串上没有
Truncate（）
方法。您必须自己编写这种逻辑。但是，您可以做的是将其包装在扩展方法中，这样您就不必到处复制它：

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

在.net中，我没有意识到这一点-这是我的版本，其中添加了“…”：

或者可以使用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));
    }
}

您可以使用LINQ…它消除了检查字符串长度的需要。诚然，可能不是最有效的，但它很有趣

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

或

我想我会加入我的实现，因为我相信它涵盖了其他人所涉及的所有案例，并且以一种简洁的方式做到了这一点，这仍然是可读的

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

    return value;
}

此解决方案主要基于，并通过使用This关键字打开该方法作为扩展方法，就像在其解决方案中一样。
该.NET Framework有一个API来截断如下字符串：

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

但在C#应用程序中，你可能更喜欢自己开发，而不是依赖Microsoft.VisualBasic.dll，后者的主要原因是向后兼容性。
我更喜欢jpierson的答案，但我看到的示例中没有一个处理无效的maxLength参数，例如当maxLength<0时

可以选择处理try/catch中的错误，将maxLength参数min钳制为0，或者如果maxLength小于0，则返回空字符串

未优化的代码：

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

公共字符串截断（此字符串值，int maximumLength）
{
if（string.IsNullOrEmpty（value）==true）{返回值；}
if（maximumLen<0）{return String.Empty；}
if（value.Length>maximumLength）{返回value.Substring（0，maximumLength）；}
返回值；
}
采用@CaffGeek并简化它：

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

Kndly注意到，截断字符串不仅仅意味着仅在指定长度处剪切字符串，还必须注意不要拆分单词

这是一个测试字符串

我想把它削减到11。如果我们使用上面给出的任何一种方法，结果将是

这是一个te

这不是我们想要的

我使用的方法可能也不太完美，但它可以处理大多数情况

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

publicstringcutstring（字符串源，int-length）
{
if（source==null | | source.Length0）？nextSpace:length.Trim（））；
} 
为什么不：

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

i、 e.在事件
value.Length
将空格填充到末尾或截断多余的空格。
在.NET 4.0中，您可以使用
Take
方法：

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

未进行效率测试！
为了（过度）复杂，我将添加重载版本，该版本使用省略号替换maxLength参数的最后3个字符

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

public static string Truncate（此字符串值，int maxLength，bool replacetTruncatedCharWithEllipsis=false）
{
if（替换截断字符，带省略号（&maxLength）
{
返回值。子字符串（0，maxLength-3）+“…”；
}
返回value.Substring（0，Math.Min（value.Length，maxLength））；
}
我知道这是一个老问题，但这里有一个很好的解决方案：

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

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

公共静态字符串截断（此字符串文本，int-maxLength，字符串后缀=“…”）
{
字符串str=文本；
如果（最大长度>0）
{
int length=maxLength-后缀.length；
如果（长度最大长度））
{
return（text.Substring（0，长度）.TrimEnd（新字符[0]）+后缀）；
}
}
返回str；
}
var myString=“你好，世界”
var myTruncatedString=myString.Truncate（4）；

返回：您好…
似乎还没有人发布此消息：

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

使用&&运算符使其略优于公认的答案。
为了防止这里没有足够的答案，这是我的：）

这是一个vb.net解决方案，注意if（尽管很难看）语句提高了性能，因为当string已经小于maxlength时，我们不需要substring语句。。。
通过使其成为字符串的扩展，它很容易使用

 <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

_
公共函数Truncate（字符串为字符串，最大长度为整数）为字符串
如果不是String.IsNullOrEmpty（String__1）并且也是String__1.Length>maxlength，则
返回字符串\ 1.子字符串（0，maxlength）
其他的
返回字符串1
如果结束
端函数
TruncateString

C#6的空传播算子的类似变体

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

公共静态字符串截断（此字符串值，int maxLength）
{
返回值？.Length对于C#字符串，2016年仍然没有截断方法。
但是-使用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); 
  }
}

它就像一个符咒：

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

我知道已经有很多答案了，但我需要的是保持字符串的开头和结尾完好无损，但将其缩短到最大长度以下

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

publicstaticstringtrunchemiddle（字符串源）
{
if（String.IsNullOrWhiteSpace（source）| | source.Length<260）
返回源；
返回string.Format（“{0}…{1}”，
源。子字符串（0235），
source.Substring（source.Lengt
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;
}

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

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

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

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

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

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

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

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

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

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

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

Install-Package Humanizer

string Trunc(string s, int len) => s?.Length > len ? s.Substring(0, len) : s;