String line limiter

Question

My experience is more general architecture and software design not code snippets like this. See any improvement to my code?

var message = @"This is a test message 
012345678901234567890123";

var output = Split(message, 20);

output

"This is a test",
"message",
"01234567890123456789",
"0123"

Max length of a line is 20 chars and it does not split words if not needed

code:

private IEnumerable<string> Split(string text, int maxLength)
{
    var n = '\n';
    var whiteSpaces = new HashSet<char> { ' ', '\t', n };
    text = text.Replace(Environment.NewLine, n.ToString());
    if (!text.EndsWith(n)) text += n;

    var whiteSpaceIndices = text
        .Select((c, i) => (i, c))
        .Where(t => whiteSpaces.Contains(t.c))
        .ToList();

    var index = 0;
    var line = string.Empty;

    char? last = null;

    foreach (var white in whiteSpaceIndices)
    {

        do
        {
            var wordLength = white.i - index;
            var wordTrimmed = text.Substring(index, Math.Min(maxLength, wordLength));
            var wordWasTrimmed = wordLength > maxLength;
            var trimmedTotalLength = wordTrimmed.Length + (wordWasTrimmed ? 0 : 1);

            if (line.Length + trimmedTotalLength > maxLength || last == n)
            {
                if (line != string.Empty)
                    yield return line;

                last = null;
                line = string.Empty;
            }

            line += last;
            line += wordTrimmed;
            index += trimmedTotalLength;

        } while (index < white.i);

        last = white.c;
    }

    if (line != string.Empty)
        yield return line;
}

https://dotnetfiddle.net/gpT5UY

Target framework is Core 3.1

Answer 1

I'm not sure if i can review this in details. But I suggest to consider my own implementation of the same.

private static IEnumerable<string> Split(string text, int maxLength)
{
    char[] whiteSpaces = new[] { ' ', '\t' };
    string[] lines = text.Replace(Environment.NewLine, "\n").Split('\n');

    foreach (string line in lines)
    {
        int i = 0;
        string s = line;
        while (true)
        {
            s = s.Substring(i);
            string t = s.Trim();
            if (t.Length > maxLength)
            {
                int diff = s.Length - t.Length;
                i = t.LastIndexOfAny(whiteSpaces, maxLength);
                if (i < 0)
                    i = maxLength;
                yield return t.Remove(i);
                i += diff;
            }
            else
            {
                yield return t;
                break;
            }
        }
    }
}

Probably this code isn't absolutely accurate but it's ~5 times faster than original one.
I suggest you to test behavior and compare the performance.

The main slow points in your code are string concatenation operations.

---

Edit: Ok, the encrypted version for var lovers.

private static IEnumerable<string> Split(string text, int maxLength)
{
    var whiteSpaces = new[] { ' ', '\t' };
    var lines = text.Replace(Environment.NewLine, "\n").Split('\n');

    foreach (var line in lines)
    {
        var i = 0;
        var s = line;
        while (true)
        {
            s = s.Substring(i);
            var t = s.Trim();
            if (t.Length > maxLength)
            {
                var diff = s.Length - t.Length;
                i = t.LastIndexOfAny(whiteSpaces, maxLength);
                if (i < 0)
                    i = maxLength;
                yield return t.Remove(i);
                i += diff;
            }
            else
            {
                yield return t;
                break;
            }
        }
    }
}

Answer 2

Overall this is not a bad technique, there is a code smell though in the number of string concatenations, I'm not going to profile it, but I prefer solutions in string processing that write to string variables as little as possible.

What are you missing:

1. There is no support or checking for null values
2. There is no support or checking for a maxLength that is zero or less.

This achieves the same outcome, but assigns less string variables along the way.

private IEnumerable<string> Split(string text, int maxLength)
{
    if (String.IsNullOrWhiteSpace(text) || maxLength <= 0)
        yield return text;
    else
    {
        var whiteSpaces = new char[] { ' ', '\t', '\n' };
        text = text.Replace(Environment.NewLine, "\n");

        int index = 0;
        int totalLength = text.Length;
        string max = "";
        do
        {
            // skip any whitespaces, handles case or multiple consecutive whitespaces
            for (; index < totalLength; index++)
            {
                if (!whiteSpaces.Contains(text[index]))
                    break;
            }

            if (index + maxLength < totalLength)
                max = text.Substring(index, maxLength);
            else
                max = text.Substring(index);

            int maxBreak = max.LastIndexOfAny(whiteSpaces);
            if (maxBreak > 0)
            {
                yield return text.Substring(index, maxBreak);
                index += maxBreak;
            }
            else
            {
                yield return max;
                index += maxLength;
            }

        } while (index < totalLength);
    }
}