¿Es StringBuilder realmente más rápido que Aggreggate?

string c = tmpArr[0].Aggregate(string.Empty, (current, m) => current + (m.Name + " ")); StringBuilder sb = new StringBuilder(); foreach (Mobile m in tmpArr[0]) sb.Append(m.Name + " "); sb.ToString(); 

¿Cuál de esos dos es más rápido? el agregado ciertamente es más limpio, pero es rápido o es lo mismo que hacer

 foreach(Mobile m in tmpArr[0]) c += m.Name + " "; 

lo que realmente me gustaría hacer es algo así como string.Join(",",tmpArr[0]) , pero no quiero que consiga sus valores de ToString, solo sus nombres, ¿cómo podría hacerlo mejor?

mi problema con no usar string.Join es que en realidad tendría que hacer algo como esto:

  string separator = ""; StringBuilder sb = new StringBuilder(); foreach (Mobile m in tmpArr[0]) { separator = ", "; sb.Append(separator + m.Name); } 

No quiero que consiga sus valores de ToString, solo sus nombres, ¿cómo podría hacerlo mejor?

 string.Join(",",tmpArr[0].Select(t => t.Name).ToArray()) 

Pero la mayor parte del tiempo . Sólo. No lo hace ¡Importar!

Si agrega cadenas en un bucle ( c += m.Name + " "; ) está causando que se creen muchas cadenas intermedias; esto causa el uso de la memoria “telescópica”, y agrega una carga extra al GC. El agregado, mezclado con la API fluida de StringBuilder puede ayudar aquí, pero como lo haría con StringBuilder. Lo importante no es el Agregado: no está creando muchas cadenas intermedias .

Por ejemplo, yo usaría:

 foreach (Mobile m in tmpArr[0]) sb.Append(m.Name).Append(" "); 

aún menos; p

Y para un ejemplo similar usando StringBuilder en Agregado:

 string c = tmpArr[0].Aggregate(new StringBuilder(), (current, m) => current.Append(m.Name).Append(" ")).ToString(); 

Como la cadena es inmutable, la operación de adición tiene un costo de rendimiento. Esto es para lo que se diseñó principalmente el StringBuilder, actúa como “Mutable” String. No he hecho muchas evaluaciones comparativas de la velocidad, pero para las optimizaciones de memoria, StringBuilder es definitivamente mejor.

Aggregate ejecuta un método anónimo contra cada elemento en el IEnumerable . Este método se pasa al delegado Func<> definido por el sistema que devuelve un parámetro de salida.

Básicamente es como ejecutar una función que realiza el agregado tantas veces como sea posible.

Por lo tanto, la asignación / desasignación en la stack para las llamadas de método, etc. ciertamente tiene más sobrecarga que la ejecución de un bucle simple for / foreach

Entonces, en mi opinión, el segundo método sería más rápido.

Aggregate sí mismo no es el problema. El problema es que estás concatenando cadenas en un bucle. Cuando concatena dos cadenas con el operador + , se debe asignar un nuevo lugar en la memoria y las dos cadenas se copian en ella. Entonces, si usas el + cinco veces, en realidad creas cinco nuevas cadenas. Es por eso que debes usar StringBuilder o Join evitar esto.

Si desea usar Join junto con linq para una mejor lectura, aún puede, simplemente no use Aggregate sino algo como Select y ToArray .

¿Algo como esto?

 string joined = string.Join(",", myItems.Select(x => x.Name).ToArray());