Comparando dos cadenas, ignorando caso en c #

Posible duplicado:
¿Cuál es la diferencia entre los diferentes métodos de comparación de cadenas?

¿Cuál de los siguientes dos es más eficiente? (¿O tal vez hay una tercera opción que es aún mejor?)

string val = "AStringValue"; if (val.Equals("astringvalue", StringComparison.InvariantCultureIgnoreCase)) 

O

 if (val.ToLowerCase() == "astringvalue") 

?

El primero es el correcto, y en mi humilde opinión el más eficiente, ya que la segunda ‘solución’ instancia una nueva instancia de cadena.

Si buscas eficiencia, usa esto:

 string.Equals(val, "astringvalue", StringComparison.OrdinalIgnoreCase) 

Las comparaciones ordinales pueden ser significativamente más rápidas que las comparaciones basadas en cultura.

ToLowerCase puede ser la mejor opción si hace muchas comparaciones con la misma cadena, sin embargo.

Como con cualquier optimización de rendimiento: mídelo, ¡luego decida!

La versión .ToLowerCase no va a ser más rápida: implica una asignación de cadena adicional (que luego se debe recostackr), etc.

Personalmente, usaría

 string.Equals(val, "astringvalue", StringComparison.OrdinalIgnoreCase) 

esto evita todos los problemas de cadenas sensibles a la cultura, pero como consecuencia evita todos los problemas de cadenas sensibles a la cultura . Solo tú sabes si eso está bien en tu contexto.

Usar el método estático string.Equals evita cualquier problema con que val sea null .

Mi respuesta general a este tipo de pregunta sobre “eficiencia” es casi siempre, cualquiera que sea la versión del código que sea más legible, es la más eficiente.

Dicho esto, creo que (val.ToLowerCase() == "astringvalue") es bastante comprensible a simple vista por la mayoría de las personas.

La eficiencia a la que me refiero no es necesaria en la ejecución del código, sino más bien en el mantenimiento y, en general, la legibilidad del código en cuestión.

Me atrevo a aventurar que lo más seguro es usar String.Equals para mitigar la posibilidad de que val sea null .

El primero es el más rápido. Resulta que val es inmutable, por lo que se crea un nuevo objeto de cadena con String.ToLowerCase (), en lugar de solo la comparación directa con el comparador de cadenas. Crear un nuevo objeto de cadena puede ser costoso si lo hace muchas veces por segundo.

es posible que también desee ver la pregunta ya respondida Diferencias en los métodos de comparación de cadenas en C #

Primero es más eficiente (y la mejor opción posible) porque val.ToLowerCase() crea un nuevo objeto ya que las cadenas son inmutables.