Split large string into smaller chunks in c#

I have a large string separated by newline character. This string contains 100 lines. I want to split these line into small chunks say chunk of 20 also based on newline character.

Let's say the string variable is like this,

Line1
This is line2
Line3 is here
I am Line4

Now I want to split this large string variable into small chunks of 2. The result should be 2 strings as,

Line1
This is line2

---

Line3 is here
I am Line4

Using Split function, I am not getting the expected results. Please help me in achieving this.

Thanks in advance,
Vijay

---

The simple approach (Split on Environment.NewLine, then loop and append):

public static List<string> GetStringSegments(string originalString, int linesPerSegment)
{

    List<string> segments = new List<string>();
    string[] allLines = originalString.Split(new string[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries); 
    StringBuilder sb = new StringBuilder();

    int linesProcessed = 0;
    for (int i = 0; i < allLines.Length; i++)
    {
        sb.AppendLine(allLines[i]);
        linesProcessed++;

        if (linesProcessed == linesPerSegment
            || i == allLines.Length-1)
        {
            segments.Add(sb.ToString());
            sb.Clear();
            inesProcessed = 0;
        }
    }

    return segments;
}

The above approach is slightly inefficient since it requires splitting the string first into individual lines, which creates unnecessary strings. A string of 1000 lines will create an array of 1000 strings. We can improved this if we just scan the string and search for n :

public static List<string> GetStringSegments(string original, int linesPerSegment)
{
    List<string> segments = new List<string>();

    int startIndex = 0;
    int newLinesEncountered = 0;

    for (int i = 0; i < original.Length; i++)
    {
        if (original[i] == 'n')
        {
            newLinesEncountered++;
        }

        if (newLinesEncountered == linesPerSegment
            || i == original.Length - 1)
        {
            segments.Add(original.Substring(startIndex, (i - startIndex + 1)));
            startIndex = i + 1;
            newLinesEncountered = 0;
        }
    }

    return segments;
}

---

你可以使用类似http://www.make-awesome.com/2010/08/batch-or-partition-a-collection-with-linq的批处理运算符

string s = "[YOUR DATA]";
var lines = s.Split(new[]{Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);
foreach(var batch in lines.Batch(20))
{
  foreach(batchLine in batch)
  {
    Console.Writeline(batchLine);
  }
}

static class LinqEx
{
  // from http://www.make-awesome.com/2010/08/batch-or-partition-a-collection-with-linq
  public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> collection,
                int batchSize)
  {
    List<T> nextbatch = new List<T>(batchSize);
    foreach (T item in collection)
    {
      nextbatch.Add(item);
      if (nextbatch.Count == batchSize)
      {
        yield return nextbatch;
        nextbatch = new List<T>(batchSize);
      }
    }
    if (nextbatch.Count > 0)
      yield return nextbatch;
  }
}

---

As several people mentioned, using string.Split will split the whole string into memory, which might be an allocation-heavy operation. This is why we have the TextReader class and its descendants, which should provide better memory performance, and might also be clearer, logically:

using (var reader = new StringReader(myString))
{
    do
    {
        StringBuilder newString = null;
        StringWriter newStringWriter = null;
        if (lineCounter % 20 == 0)
        {
             newString = new StringBuilder();
             newStringWriter = new StringWriter(newString);
             newStringCollection.Add(newString);
        } 
        string line = reader.ReadLine();
        if (!string.isNullOrEmpty(line))
        {
             newStringWriter.WriteLine(line);
             lineCounter++;
        }
    }
    while (line != null)
}

We're using the StringReader to read our big string, one line at a time. And the corresponding StringWriter writes those lines to the new string, one line a time. After every 20 lines, we start a new StringBuilder (and the appropriate StringWriter wrapper).

链接地址: http://www.djcxy.com/p/77074.html

上一篇: 将字符串拆分成Bash中的数组

下一篇: 在c＃中将大字符串拆分为更小的块