¿Usando el operador condicional en la expresión lambda en ForEach() en una lista genérica?

Question

¿No está permitido tener un operador condicional en una expresión lambda en ForEach?

List<string> items = new List<string>{"Item 1", "Item 2", "Item I Care About"}; 

string whatICareAbout = ""; 

// doesn't compile :(
items.ForEach(item => item.Contains("I Care About") ? 
whatICareAbout += item + "," : whatICareAbout += ""); 

Error de compilación -> "Sólo asignación, llamar, incremento, decremento, y nuevas expresiones de objetos se puede utilizar como una declaración"

Tratar de utilizar una normal si no funciona bien:

// :(
items.ForEach(item => if (item.Contains("I Care About")) {whatICareAbout += item + ", ";} 

¿No es posible?

Answer 1

Está utilizando la forma más corta de expresiones lambda, que solo permite una sola expresión.
Necesita la forma larga, que permite varias instrucciones.

Por ejemplo: paréntesis

items.ForEach(item => { 
    if (item.Contains("I Care About")) 
     whatICareAbout += item + ", "; 
}); 

Answer 2

Proveedores:

items.ForEach(item => item.Contains("I Care About") ? (whatICareAbout += item + ",") : (whatICareAbout += "")); 

+ = tiene una prioridad más alta que, que puede ser la razón de que está recibiendo el error?. Con paréntesis, el error puede desaparecer. Sin embargo, no está 100% seguro de esto ... las expresiones lambda pueden tener restricciones adicionales que impiden el uso de declaraciones de asignación.

ACTUALIZACIÓN:

En lugar de múltiples + = instrucciones, es mucho más limpio para poner el condicional en el lado derecho de la asignación, como esto:

List<string> items = new List<string> { "one", "two", "three" }; 
string whatICareAbout = ""; 
items.ForEach(item => whatICareAbout += item.Contains("I Care About") ? (item + ",") : ""); 

ACTUALIZACIÓN 2:

Pero es incluso mejor simplemente usar Agregado() ya que está diseñado exactamente para este escenario. He aquí una muestra:

string whatICareAbout = items.Aggregate("", (total, item) => item.Contains("I Care About") ? (total + item + ",") : total); 

Pero creo @Matt Breckon's respuesta anterior (que acabo de ver como estaba a punto de publicar esto) es incluso mejor que mi ejemplo ya que trata de la eliminación de la terminal "". Mira su respuesta ... :-)

Answer 3

¿Qué estás tratando de lograr? ¿Estás tratando de formar una cadena de elementos separados por comas donde contienen un valor particular? En LINQ le lograrlo utilizando la siguiente:

List<string> items = new List<string> { "Item 1", "Item 2", "Item I Care About", "Item I Care About", "Item I Care About" }; 
string whatICareAbout = items.Where(x => x.Contains("I Care About")) 
           .Aggregate((y, z) => y + ", " + z); 

El resultado de esto es el "Punto cuidado de I, artículo cuidado de I, artículo que me importa".

Nota: Agregado es una gran manera de asegurarse de que no hay arrastre ""

Answer 4

El problema fue que la expresión

item.Contains("I Care About") ? whatICareAbout += item + "," : whatICareAbout += "" 

no es una declaración. Simplemente devuelve un valor que tiene el tipo string.

Hay un truco para hacer que funcione (sólo por diversión): Llamada

items.ForEach(item => (item.Contains("I Care About") ? 
    whatICareAbout += item + "," : whatICareAbout += "").GetType()); 

simplemente he añadido a .GetType() método para crear un comunicado de la expresión inicial, y compilado.