.NET 문자열을 자르려면 어떻게합니까?

길이가 주어진 값보다 길지 않도록 문자열을 자르고 싶습니다. 데이터베이스 테이블에 쓰고 있는데 작성하는 값이 열 데이터 유형의 제약 조건을 충족하는지 확인하고 싶습니다.

예를 들어, 다음을 쓸 수 있다면 좋을 것입니다.

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

불행히도 maxLength일반적으로 문자열의 경계를 초과 하기 때문에 예외가 발생 합니다 value. 물론 다음과 같은 함수를 작성할 수는 있지만 이와 같은 것이 이미 존재하기를 희망했습니다.

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

이 작업을 수행하는 어려운 API는 어디에 있습니까? 하나 있습니까?

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

이제 다음과 같이 쓸 수 있습니다 :

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

또는 삼항 연산자 대신 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));
    }
}

나는 그것이 다른 사람들에 의해 접촉 된 모든 사례를 다루고 여전히 읽을 수있는 간결한 방식으로 그렇게한다고 믿기 때문에 구현을 포기할 것이라고 생각했다.

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

    return value;
}

이 솔루션은 주로 Ray의 솔루션을 하며 LBushkin이 솔루션에서 수행하는 것처럼 this 키워드 를 사용하여 확장 방법으로 사용할 방법을 엽니 다 .

성능 테스트가 재미 있기 때문에 : ( 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();

이 truncate방법은 "상당히"빨랐습니다. # 미세 최적화

이른

• truncate10 5788 틱 경과 (0.5788ms) [10K 반복, 5.788E-05ms 당]
• smart-trunc10 8206 틱 경과 (0.8206ms) [10K 반복, 8.206E-05ms / 초]
• stringbuilder10 10557 틱 경과 (1.0557ms) [10K 반복, 0.00010557ms 당]
• concat10 45495 틱 경과 (4.5495ms) [10K 반복, 0.00045495ms 당]
• newstring10 72535 틱 경과 (7.2535ms) [10K 반복, 0.00072535ms]

늦은

• truncate44 8835 틱 경과 (0.8835ms) [10K 반복, 8.835E-05ms 당]
• stringbuilder44 13106 틱 경과 (1.3106ms) [10K 반복, 0.00013106ms 당]
• smart-trunc44 14821 틱 경과 (1.4821ms) [10K 반복, 0.00014821ms 당]
• newstring44 144324 틱 경과 (14.4324ms) [10K 반복, 0.00144324ms 당]
• concat44 174610 틱 경과 (17.461ms) [10K 반복, 0.0017461ms / 초]

너무 오래

• smart-trunc64 6944 틱 경과 (0.6944ms) [10K 반복, 6.944E-05ms 당]
• truncate64 7686 틱 경과 (0.7686ms) [10K 반복, 7.686E-05ms 당]
• stringbuilder64 13314 틱 경과 (1.3314ms) [10K 반복, 0.00013314ms 당]
• newstring64 177481 틱 경과 (17.7481ms) [10K 반복, 0.00177481ms 당]
• concat64 241601 틱 경과 (24.1601ms) [10K 반복, 0.00241601ms 당]

.NET 4.0에서는 다음 Take방법을 사용할 수 있습니다 .

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

효율성을 테스트하지 않았습니다!

LINQ를 사용할 수 있습니다 ... 문자열 길이를 확인할 필요가 없습니다. 아마도 가장 효율적이지는 않지만 재미 있습니다.

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

또는

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

나는 이런 식으로 한 줄로 내 것을 했어

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

아직 아무도 이것을 게시하지 않았습니다 :

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

&& 연산자를 사용하면 허용되는 답변보다 약간 더 좋습니다.

.NET Framework에는 다음과 같은 문자열을 자르는 API가 있습니다.

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

그러나 C # 앱에서는 주요 raison d' etre가 이전 버전과의 호환성 인 Microsoft.VisualBasic.dll에 대한 종속성을 얻는 것보다 자신의 롤을 선호 할 것입니다.

다른 해결책 :

return input.Substring(0, Math.Min(input.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);

반품 : 안녕하세요 ...

C # 6의 널 전파 연산자와 유사한 변형

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

기본적으로 valuenull이 두 번 있는지 확인하고 있습니다.

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"

@CaffGeek를 가져 와서 단순화하십시오.

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

끈을 자르는 것은 단지 지정된 길이로만 끈을 자르는 것만을 의미하는 것이 아니라 단어를 나누지 않도록주의해야한다는 점에 유의하십시오.

예를 들어 문자열 : 이것은 테스트 문자열입니다.

11시에 자르고 싶습니다. 위에 주어진 방법 중 하나를 사용하면 결과는

이것은 테입니다

이것은 우리가 원하는 것이 아닙니다

내가 사용하는 방법도 완벽하지는 않지만 대부분의 상황을 처리 할 수 ​​있습니다.

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

왜 안되 겠어요 :

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

즉, 이벤트 value.Length < maxLength패드 공간에서 끝까지 또는 초과를 자릅니다.

여기에 충분한 답변이없는 경우 여기에 내 것이 있습니다 :)

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

쓰다:

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

복잡성을 줄이기 위해 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)); 
}

예제 길이가 30 인 내 2 센트 :

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

jpierson의 답변을 선호하지만 여기서 볼 수있는 예제 중 maxLength <0과 같은 잘못된 maxLength 매개 변수를 처리하는 예제는 없습니다.

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

다음은 vb.net 솔루션입니다. 문자열이 이미 maxlength보다 작을 때 하위 문자열 문이 필요하지 않기 때문에 if (추악한) 문이 성능을 향상 시킨다는 점을 표시하십시오 ... 문자열의 확장으로 사용하기 쉽습니다. ..

 <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

나는 이미 많은 대답이 있다는 것을 알고 있지만 문자열의 시작과 끝을 그대로 유지하면서 최대 길이 이하로 줄이려고했습니다.

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

최대 길이가 260자인 SharePoint URL을 만들기위한 것입니다.

상수 260이므로 길이를 매개 변수로 만들지 않았습니다. 또한 특정 지점에서 끊기를 원하기 때문에 첫 번째 하위 문자열 길이를 매개 변수로 만들지 않았습니다. 마지막으로 두 번째 하위 문자열은 폴더 구조를 알고 있기 때문에 소스의 길이입니다.

이는 특정 요구에 쉽게 적용 할 수 있습니다.

나는 이미 여기에 많은 대답이 있다는 것을 알고 있지만 이것은 내가 가지고있는 것입니다. 널 문자열과 길이가 음수 인 상황을 모두 처리합니다.

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

C # 8에서는 새로운 범위 기능을 사용할 수 있습니다 ...

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

내가 알고있는 이것에 대한 .net에는 아무것도 없습니다-여기에 "..."를 추가하는 내 버전이 있습니다 :

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

자르기 문자열

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

위에서 논의한 가능성에 더하여 솔루션을 공유하고 싶습니다. 그것은 null을 허용하는 확장 메소드입니다 (string.Empty를 반환) 또한 줄임표와 함께 사용하기위한 두 번째 .Truncate ()가 있습니다. 성능이 최적화되지 않았습니다.

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
    }

문자열 자르기

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

이것은 내가 일반적으로 사용하는 코드입니다.

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