您可以创建一个Truncate扩展方法，它将最大长度与字符串长度进行比较，并在需要时调用Substring。

如果您想要与Substring类似的空处理行为，则不要包含空检查。这样，就像str. substring(0,10)在str为空时抛出NullReferenceException一样，str. truncate(10)也会抛出NullReferenceException。

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

这是一个vb.net解决方案，标记if(虽然丑陋)语句提高性能，因为当字符串已经小于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

你可以用LINQ…它消除了检查字符串长度的需要。不可否认，这可能不是最有效的，但很有趣。

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

or

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

因为性能测试很有趣:(使用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();

截断法“明显”更快。# microoptimization

早期

truncate10 5788滴答流逝(0.5788 ms) [10K次，5.788E-05 ms /次] smart-trunc10 8206滴答流逝(0.8206 ms) [10K次，8.206E-05 ms /次] stringbuilder10 10557滴答流逝(1.0557 ms) [10K次，0.00010557 ms /次] concat10 45495滴答流逝(4.5495 ms) [10K次，0.00045495 ms /次] 时间流逝(7.2535 ms) [10K次，0.00072535 ms /次]

Late

truncate44 8835滴答流逝(0.8835 ms) [10K次，8.835E-05 ms /次] 13106滴答流逝(1.3106 ms) [10K次，0.00013106 ms /次] smart-trunc44 14821滴答流逝(1.4821毫秒)[10K次，0.00014821毫秒/次] 时间流逝(14.4324 ms) [10K次，0.00144324 ms /次] concat44 174610滴答流逝(17.461毫秒)[每10K次，0.0017461毫秒]

太长时间

smart-trunc64 6944滴答流逝(0.6944毫秒)[在10K次中，6.944E-05毫秒每] truncate64 7686滴答流逝(0.7686 ms) [10K次，7.686E-05 ms /次] stringbuilder64 13314滴答流逝(1.3314 ms) [10K次，0.00013314 ms /次] 时间流逝(17.7481 ms) [10K次，0.00177481 ms /次] concat64 241601滴答流逝(24.1601毫秒)[每10K次，0.00241601毫秒]

我知道这里已经有大量的答案，但这是一个我已经去了，它处理空字符串和传递的长度为负的情况:

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