¿Cómo podría tomar 1 artículo más de TakeWhile de Linq?

Question

(línea de código de interés es el último, el resto es sólo para una representación completa)

Usando el siguiente código, que quería tomar VOTANTES hasta que superó el máximo de votos necesarios, pero se detiene justo antes de alcanzar ese número máximo de votos, mi grupo de votantes tiene 1 votante menos de lo que yo quería.

¿Hay alguna manera limpia en LINQ en la que podría haberlo hecho tomar los votos HASTA que haya alcanzado el número máximo de votos? Sé que podría agregar un votante más o hacer esto en un ciclo, pero tengo curiosidad de saber si había una buena manera de hacerlo con LINQ.

var voters = new List<Person> 
          { 
           new Person("Alice", Vote.Yes), 
           new Person("Bob", Vote.Yes), 
           new Person("Catherine", Vote.No), 
           new Person("Denzel", Vote.Yes), 
           new Person("Einrich", Vote.Abstain), 
           new Person("Frederica", Vote.Abstain), 
           new Person("Goeffried", Vote.Abstain), 
          }; 
      voters.Single(c => c.Name == "Alice").Voices = 100; 
      voters.Single(c => c.Name == "Bob").Voices = 150; 
      voters.Single(c => c.Name == "Catherine").Voices = 99; 
      voters.Single(c => c.Name == "Denzel").Voices = 24; 
      voters.Single(c => c.Name == "Einrich").Voices = 52; 
      voters.Single(c => c.Name == "Frederica").Voices = 39; 
      voters.Single(c => c.Name == "Goeffried").Voices = 99; 

// this takes voters until we are BEFORE reaching X voices... 
int voicesSoFar = 0; 
int voicesNeeded = 300; 
var eligibleVoters = voters.TakeWhile((p => (voicesSoFar += p.Voices) < voicesNeeded)); 

Answer 1

Usted está buscando

voters.TakeWhile(p => { 
    bool exceeded = voicesSoFar > voicesNeeded ; 
    voicesSoFar += p.Voices; 
    return !exceeded; 
}); 

Si insiste en una sola línea, esto funcionará mediante la comparación del valor anterior:

voters.TakeWhile(p => (voicesSoFar += p.Voices) - p.Voices < voicesNeeded); 

Answer 2

Sólo tiene que escribir su propio método de extensión:

static class IEnumerableExtensions { 
    public static IEnumerable<T> TakeUntil<T>(
     this IEnumerable<T> elements, 
     Func<T, bool> predicate 
    ) { 
     return elements.Select((x, i) => new { Item = x, Index = i }) 
         .TakeUntil((x, i) => predicate(x.Item)) 
         .Select(x => x.Item); 
    } 

    public static IEnumerable<T> TakeUntil<T>(
     this IEnumerable<T> elements, 
     Func<T, int, bool> predicate 
    ) { 
     int i = 0; 
     foreach (T element in elements) { 
      if (predicate(element, i)) { 
       yield return element; 
       yield break; 
      } 
      yield return element; 
      i++; 
     } 
    } 
} 

Uso:

var eligibleVoters = voters.TakeUntil(
         p => (voicesSoFar += p.Voices) >= voicesNeeded 
        ); 

foreach(var voter in eligibleVoters) { 
    Console.WriteLine(voter.Name); 
} 

Salida:

Alice 
Bob 
Catherine 

Answer 3

En una situación en la que quería ejecutar una función, hasta e incluyendo golpeó una condición final lo hice :

public static IEnumerable<T> TakeUntilIncluding<T>(this IEnumerable<T> list, Func<T, bool> predicate) 
{ 
    foreach(T el in list) 
    { 
     yield return el; 
     if (predicate(el)) 
      yield break; 
    } 
} 

¡Funcionó para mí! Creo que esta es una solución independiente de la implementación como la de Jason, pero más simple.

Answer 4

Variación de la respuesta de Kobi pero demuestra el uso de (value, index). index es útil para resolver problemas similares, aunque no de OP.

voters.TakeWhile((value, index) => (voicesSoFar += value.Voices) - value.Voices < voicesNeeded); 

Answer 5

Me enfrentaba el mismo problema. he utilizado Unión y Skip métodos, por lo que tomar hasta que fue

IEnumerable<Something> newSomethings = somethings.TakeWhile(s => s != stop).Union(new List<Something>(){stop}); 

y de salto hasta

IEnumerable<Something> newSomethings = somethings.SkipWhile(s => s != stop).Skip(1); 

También es tomar método, que lleva algún int de los primeros resultados.