dividir una lista utilizando LINQ

Question

He el siguiente código:

var e = someList.GetEnumerator(); 
    var a = new List<Foo>(); 
    var b = new List<Foo>(); 
    while(e.MoveNext()) { 
    if(CheckCondition(e.Current)) { 
     b.Add(e.Current); 
     break; 
    } 
    a.Add(e.Current); 
} 

while(e.MoveNext()) 
    b.Add(e.Current) 

Esto se ve feo. Básicamente, itere a través de una lista y agregue elementos a una lista hasta que se active una condición, y agregue el resto a otra lista.

¿Hay alguna otra manera, por ejemplo,? usando linq? CheckCondition() es costoso, y las listas pueden ser enormes, por lo que preferiría no hacer nada que itere las listas dos veces.

Answer 1

he aquí una solución que va a enumerar la lista dos veces, pero no va a comprobar el estado de la segunda vez, por lo que debería ser más rápido:

var a = someList.TakeWhile(x => !CheckCondition(x)).ToList(); 
var b = someList.Skip(a.Count).ToList(); 

Si someList implementa IList<T>, cada elemento se enumerará realmente una sola vez, por lo que no habrá ninguna penalización.
pensé Skip se ha optimizado para el caso de IList<T>, pero al parecer no es ... Sin embargo fácilmente se podría implementar su propio método Skip que utiliza esta optimización (ver Jon Skeet's article sobre esto)

En realidad, sería más elegante si había un método TakeUntil ... podemos crear fácilmente:

public static IEnumerable<TSource> TakeUntil<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) 
{ 
    foreach(var item in source) 
    { 
     if (predicate(item)) 
      break; 
     yield return item; 
    } 
} 

Con este método, el código se convierte en:

var a = someList.TakeUntil(CheckCondition).ToList(); 
var b = someList.Skip(a.Count).ToList(); 

Answer 2

Personalmente, no creo que haya necesidad de LINQ aquí.

Me gustaría hacer algo como:

bool conditionHit = false; 

foreach (var item in someList) 
{ 
    if (!conditionHit) 
     conditionHit = CheckCondition(item); 

    var listToBeAdded = conditionHit ? b : a; 
    listToBeAdded.Add(item); 
} 

Answer 3

Esto va a terminar pasando a través de los elementos de la primera lista más de una vez, pero sólo llamadas a través de CheckCondition primera vez:

var a = someList.TakeWhile(e => !CheckCondition(e)); 
var b = someList.Skip(a.Count()); 

Answer 4

Si someList es un hormigón List<T> entonces esto sólo se necesita un único pasar a través de cada elemento:

var a = someList.TakeWhile(x => !CheckCondition(x)).ToList(); 
var b = someList.GetRange(a.Count, someList.Count - a.Count); 

Answer 5

no quería cambiar Ani's answer, pero aquí hay una ligera simplificación.

var listToBeAdded = a; 
foreach (var item in someList) 
{ 
    if (listToBeAdded == a && CheckCondition(item)) 
     listToBeAdded = b; 

    listToBeAdded.Add(item); 
} 

Answer 6

Prueba esto (no reutilizar métodos incorporados de Linq (conocidas para rebobinar los iteradores)), acaba de reutilización de la lógica de la OP (que creo que es performant, no volver a evaluar la condición en la próxima la mitad de la lista) y el embalaje en un método de extensión ordenada y tupla:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 



namespace Craft 
{ 
    class Act 
    { 
     static void Main(string[] args) 
     { 

      var a = new List<string> 
       { "I", "Love", "You", "More", "Today", "Than", "Yesterday" }; 

      var tx = a.SplitByCondition(s => s == "More"); 

      foreach (var s in tx.Item1) 
       Console.WriteLine("First Half : {0}", s); 

      foreach (var s in tx.Item2) 
       Console.WriteLine("Second Half : {0}", s); 

      Console.ReadLine();      
     } 

    }//Act 

    public static class Helper 
    { 

     public static Tuple<List<T>, List<T>> SplitByCondition<T> 
      (this IEnumerable<T> t, Func<T, bool> terminator) 
     { 


      var tx = new Tuple<List<T>, List<T>> 
          (new List<T>(), new List<T>()); 

      var iter = t.GetEnumerator(); 

      while (iter.MoveNext()) 
      { 
       if (terminator(iter.Current)) 
       { 
        tx.Item2.Add(iter.Current); 
        break; 
       } 

       tx.Item1.Add(iter.Current); 
      } 

      while (iter.MoveNext()) 
       tx.Item2.Add(iter.Current); 

      return tx; 
     }  

    }//Helper 

}//Craft 

salida:

First Half : I 
First Half : Love 
First Half : You 
Second Half : More 
Second Half : Today 
Second Half : Than 
Second Half : Yesterday