Using C# , LINQ how to pick items between markers again and again?

Question

Say I have an array of strings:

string[] strArray = {"aa", "bb", "xx", "cc", "xx", "dd", "ee", "ff", "xx","xx","gg","xx"};

How do I use LINQ to extract the strings between the "xx" markers as groups?

Say by writing them to the console as:

cc
dd,ee,ff
gg

Answer 1

A pure-functional solution (mutation-free):

string[] strArray = { "aa", "bb", "xx", "cc", "xx", "dd", 
                      "ee", "ff", "xx", "xx", "gg", "xx" };

var result = 
 strArray.Aggregate((IEnumerable<IEnumerable<string>>)new IEnumerable<string>[0],
   (a, s) => s == "xx" ? a.Concat(new[] { new string[0] })
      : a.Any() ? a.Except(new[] { a.Last() })
                   .Concat(new[] { a.Last().Concat(new[] { s }) }) : a)
         .Where(l => l.Any());

// Test
foreach (var i in result)
  Console.WriteLine(String.Join(",", i.ToArray()));

If you want to filter out the results past the last marker:

string[] strArray = { "aa", "bb", "xx", "cc", "xx", "dd", 
                      "ee", "ff", "xx", "xx", "gg", "xx"};

var result = 
  strArray.Aggregate(
    new { C = (IEnumerable<string>)null, 
          L = (IEnumerable<IEnumerable<string>>)new IEnumerable<string>[0] },
    (a, s) => s == "xx" ? a.C == null
        ? new { C = new string[0].AsEnumerable(), a.L }
        : new { C = new string[0].AsEnumerable(), L = a.L.Concat(new[] { a.C }) } 
        : a.C == null ? a : new { C = a.C.Concat(new[] { s }), a.L }).L
          .Where(l => l.Any());

// Test
foreach (var i in result)
  Console.WriteLine(String.Join(",", i.ToArray()));

Answer 2

You can select only the ones that are not "xx" but if you need to break a line every time you find one then you whould have to use a (for/for each) not a query.

The query to extract the "xx" would be

from s from array
where s != "xx"
select s

Answer 3

Partioning lists/arrays isn't something LINQ is particularly well suited to. I recommend you write your own extension method(s) that returns an IEnumerable<IEnumerable<T>> using iterators (yield keyword) if you want to make it compatible with LINQ (i.e. fully lazy sequences). If you don't care about lazy evaluation, then the easiest thing would probably just to write a method that generates a list by iterating over the array and finally returns a jagged array (string[][]>).

Answer 4

You can assign a group number to the items by using a group counter that you increase each time that you encounter an "xx" string. Then you filter out the "xx" strings, group on the group number, and filter out the empty groups:

int group = 0;
var lines =
   strArray
   .Select(s => new { Group = (s == "xx" ? ++group : group), Value = s })
   .Where(n => n.Value != "xx")
   .GroupBy(n => n.Group)
   .Where(g => g.Count() > 0);

foreach (var line in lines) {
   Console.WriteLine(string.Join(",", line.Select(s => s.Value).ToArray()));
}

Edit:
This solution will also remove the items before the first marker and after the last marker:

int group = 0;
var lines =
   strArray
   .Select(s => new { Group = s == "xx" ? group++ : group, Value = s })
   .GroupBy(n => n.Group)
   .Skip(1)
   .Where(g => g.Last().Value == "xx" && g.Count() > 1);

foreach (var line in lines) {
   Console.WriteLine(string.Join(",", line.Take(line.Count() - 1).Select(s => s.Value).ToArray()));
}

Answer 5

A better approach may be to write a generic IEnumerable<T> split extension method and then pick and choose which parts of the results you want.

public static class IEnumerableExtensions
{
  public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
                     this IEnumerable<TSource> source, TSource splitter)
  {
    if (source == null)
      throw new ArgumentNullException("source");
    if (splitter == null)
      throw new ArgumentNullException("splitter");

    return source.SplitImpl(splitter);
  }

  private static IEnumerable<IEnumerable<TSource>> SplitImpl<TSource>(
                     this IEnumerable<TSource> source, TSource splitter)
  {
    var list = new List<TSource>();

    foreach (TSource item in source)
    {
      if (!splitter.Equals(item))
      {
        list.Add(item);
      }
      else if (list.Count > 0)
      {
        yield return list.ToList();
        list.Clear();
      }
    }
  }
}

And use it like so

static void Main(string[] args)
{
  string[] strArray = { "aa", "bb", "xx", "cc", "xx", "dd",
                        "ee", "ff", "xx", "xx", "gg", "xx" };

  var result = strArray.Split("xx");
  foreach (var group in result.Skip(1).Take(3))
  {
    Console.WriteLine(String.Join(",", group.ToArray()));
 }

  Console.ReadKey(true);
}

And you get the desired output

cc
dd,ee,ff
gg

Answer 6

Add the following extension method:

public static class SplitExtensions {
    public static IEnumerable<IEnumerable<T>> SplitBy<T>(this IEnumerable<T> src, T separator) {
        var group = new List<T>();
        foreach (var elem in src){
            if (Equals(elem, separator)){
                yield return group;
                group = new List<T>();
            } else{
                group.Add(elem);
            }
        }
        yield return group;
    }
}

Here is usage of it:

string[] strArray = { "aa", "bb", "xx", "cc", "xx", "dd", "ee", "ff", "xx", "xx", "gg", "xx" };
var groups = from g in strArray.SplitBy("xx")
             where g.Any()
             select g;