C# 当文本超过一定长度时，将文本换行到下一行？

Wrap text to the next line when it exceeds a certain length?

提问by Ryan S.

I need to write different paragraphs of text within a certain area. For instance, I have drawn a box to the console that looks like this:

我需要在某个区域内编写不同的文本段落。例如，我在控制台上画了一个框，如下所示：

/----------------------\
|                      |
|                      |
|                      |
|                      |
\----------------------/

How would I write text within it, but wrap it to the next line if it gets too long?

我将如何在其中写入文本，但如果它太长，则将其换行到下一行？

采纳答案by Jim H

Split on last space before your row length?

在行长度之前的最后一个空格上拆分？

int myLimit = 10;
string sentence = "this is a long sentence that needs splitting to fit";
string[] words = sentence.Split(new char[] { ' ' });
IList<string> sentenceParts = new List<string>();
sentenceParts.Add(string.Empty);

int partCounter = 0;

foreach (string word in words)
{
    if ((sentenceParts[partCounter] + word).Length > myLimit)
    {
        partCounter++;
        sentenceParts.Add(string.Empty);
    }

    sentenceParts[partCounter] += word + " ";
}

foreach (string x in sentenceParts)
    Console.WriteLine(x);

UPDATE(the solution above lost the last word in some cases):

更新（上面的解决方案在某些情况下丢失了最后一句话）：

int myLimit = 10;
string sentence = "this is a long sentence that needs splitting to fit";
string[] words = sentence.Split(' ');

StringBuilder newSentence = new StringBuilder();


string line = "";
foreach (string word in words)
{
    if ((line + word).Length > myLimit)
    {
        newSentence.AppendLine(line);
        line = "";
    }

    line += string.Format("{0} ", word);
}

if (line.Length > 0)
    newSentence.AppendLine(line);

Console.WriteLine(newSentence.ToString());

回答by Manfred Ramoser

I modified the version of Jim H such that it supports some special cases. For example the case when the sentence does not contain any whitespace character; I also noted that there is a problem when a line has a space at the last position; then the space is added at the end and you end up with one character too much.

我修改了 Jim H 的版本，使其支持一些特殊情况。例如句子不包含任何空格字符的情况；我还注意到当一行在最后一个位置有空格时会出现问题；然后在末尾添加空格，最终导致一个字符过多。

Here is my version just in case someone is interested:

这是我的版本，以防万一有人感兴趣：

public static List<string> WordWrap(string input, int maxCharacters)
{
    List<string> lines = new List<string>();

    if (!input.Contains(" "))
    {
        int start = 0;
        while (start < input.Length)
        {
            lines.Add(input.Substring(start, Math.Min(maxCharacters, input.Length - start)));
            start += maxCharacters;
        }
    }
    else
    {
        string[] words = input.Split(' ');

        string line = "";
        foreach (string word in words)
        {
            if ((line + word).Length > maxCharacters)
            {
                lines.Add(line.Trim());
                line = "";
            }

            line += string.Format("{0} ", word);
        }

        if (line.Length > 0)
        {
            lines.Add(line.Trim());
        }
    }

    return lines;
}

回答by Paupa

I modified Manfred's version. If you put a string with the '\n' character in it, it will wrap the text strangely because it will count it as another character. With this minor change all will go smoothly.

我修改了曼弗雷德的版本。如果您在其中放入一个带有 '\n' 字符的字符串，它会奇怪地将文本换行，因为它会将其视为另一个字符。有了这个微小的变化，一切都会顺利进行。

public static List<string> WordWrap(string input, int maxCharacters)
    {
        List<string> lines = new List<string>();

        if (!input.Contains(" ") && !input.Contains("\n"))
        {
            int start = 0;
            while (start < input.Length)
            {
                lines.Add(input.Substring(start, Math.Min(maxCharacters, input.Length - start)));
                start += maxCharacters;
            }
        }
        else
        {
            string[] paragraphs = input.Split('\n');

            foreach (string paragraph in paragraphs)
            {
                string[] words = paragraph.Split(' ');

                string line = "";
                foreach (string word in words)
                {
                    if ((line + word).Length > maxCharacters)
                    {
                        lines.Add(line.Trim());
                        line = "";
                    }

                    line += string.Format("{0} ", word);
                }

                if (line.Length > 0)
                {
                    lines.Add(line.Trim());
                }
            }
        }
        return lines;
    }

回答by Mitat Koyuncu

I started with Jim H.'s solutionand end up with this method. Only problem is if text has any word that longer than limit. But works well.

我从Jim H. 的解决方案开始，并以这种方法结束。唯一的问题是文本是否有任何超过限制的单词。但效果很好。

public static List<string> GetWordGroups(string text, int limit)
{
    var words = text.Split(new string[] { " ", "\r\n", "\n" }, StringSplitOptions.None);

    List<string> wordList = new List<string>();

    string line = "";
    foreach (string word in words)
    {
        if (!string.IsNullOrWhiteSpace(word))
        {
            var newLine = string.Join(" ", line, word).Trim();
            if (newLine.Length >= limit)
            {
                wordList.Add(line);
                line = word;
            }
            else
            {
                line = newLine;
            }
        }
    }

    if (line.Length > 0)
        wordList.Add(line);

    return wordList;
}

回答by Vivek Patwari

This code will wrap the paragraph text. It will break the paragraph text into lines. If it encounters any word which is even larger than the line length, it will break the word into multiple lines too.

此代码将包装段落文本。它会将段落文本分成几行。如果遇到任何比行长还要大的单词，它也会将单词分成多行。

private const int max_line_length = 25;

private string wrapLinesToFormattedText(string p_actual_string) {

    string formatted_string = "";
    int available_length = max_line_length;

    string[] word_arr = p_actual_string.Trim().Split(' ');

    foreach (string w in word_arr) {

        string word = w;
        if (word == "") {
            continue;
        }


        int word_length = word.Length;

        //if the word is even longer than the length that the line can have
        //the large word will get break down into lines following by the successive words 
        if (word_length >= max_line_length)
        {
            if (available_length > 0)
            {
                formatted_string += word.Substring(0, available_length) + "\n";
                word = word.Substring(available_length);
            }
            else
            {
                formatted_string += "\n";
            }
            word = word + " ";
            available_length = max_line_length;
            for (var count = 0;count<word.Length;count++) {
                char ch = word.ElementAt(count);

                if (available_length==0) {
                    formatted_string += "\n";
                    available_length = max_line_length;
                }

                formatted_string += ch;
                available_length--;
            }                    
            continue;
        }




        if ((word_length+1) <= available_length)
        {
            formatted_string += word+" ";
            available_length -= (word_length+1);
            continue;
        }
        else {
            available_length = max_line_length;
            formatted_string += "\n"+word+" " ;
            available_length -= (word_length + 1);
            continue;                    
        }

    }//end of foreach loop

    return formatted_string;
}
//end of function wrapLinesToFormattedText

Blockquote

Blockquote

回答by Corey Alix

Here's one that is lightly tested and uses LastIndexOf to speed things along (a guess):

这是一个经过轻微测试并使用 LastIndexOf 来加快速度的方法（猜测）：

    private static string Wrap(string v, int size)
    {
        v = v.TrimStart();
        if (v.Length <= size) return v;
        var nextspace = v.LastIndexOf(' ', size);
        if (-1 == nextspace) nextspace = Math.Min(v.Length, size);
        return v.Substring(0, nextspace) + ((nextspace >= v.Length) ? 
        "" : "\n" + Wrap(v.Substring(nextspace), size));
    }

回答by bytecode77

This is a more completeand tested solution.

这是一个更完整和经过测试的解决方案。

• The bool overflowparameter specifies, whether long words are chunked in addition to splitting up by spaces.
• Consecutive whitespaces, as well as \r, \n, are ignored and collapsed into one space.
• Edge cases are throughfully tested

• 该bool overflow参数指定除了按空格分割外，是否对长词进行分块。
• 连续的空格，还有\r，\n被忽略和折叠成一个空格。
• 边缘情况经过全面测试

---

---

public static string WrapText(string text, int width, bool overflow)
{
    StringBuilder result = new StringBuilder();

    int index = 0;
    int column = 0;

    while (index < text.Length)
    {
        int spaceIndex = text.IndexOfAny(new[] { ' ', '\t', '\r', '\n' }, index);

        if (spaceIndex == -1)
        {
            break;
        }
        else if (spaceIndex == index)
        {
            index++;
        }
        else
        {
            AddWord(text.Substring(index, spaceIndex - index));
            index = spaceIndex + 1;
        }
    }

    if (index < text.Length) AddWord(text.Substring(index));

    void AddWord(string word)
    {
        if (!overflow && word.Length > width)
        {
            int wordIndex = 0;
            while (wordIndex < word.Length)
            {
                string subWord = word.Substring(wordIndex, Math.Min(width, word.Length - wordIndex));
                AddWord(subWord);
                wordIndex += subWord.Length;
            }
        }
        else
        {
            if (column + word.Length >= width)
            {
                if (column > 0)
                {
                    result.AppendLine();
                    column = 0;
                }
            }
            else if (column > 0)
            {
                result.Append(" ");
                column++;
            }

            result.Append(word);
            column += word.Length;
        }
    }

    return result.ToString();
}