Comparación de cadenas sin distinción entre mayúsculas y minúsculas en LINQ-to-SQL

He leído que no es aconsejable usar ToUpper y ToLower para realizar comparaciones de cadenas que no distinguen entre mayúsculas y minúsculas, pero no veo otra alternativa cuando se trata de LINQ-to-SQL. LINQ-to-SQL ignora los argumentos ignoreCase y CompareOptions de String.Compare (si está utilizando una base de datos que distingue entre mayúsculas y minúsculas, obtendrá una comparación entre mayúsculas y minúsculas, incluso si solicita una comparación que no distinga entre mayúsculas y minúsculas). ¿Es ToLower o ToUpper la mejor opción aquí? ¿Es uno mejor que el otro? Pensé que leí en alguna parte que ToUpper era mejor, pero no sé si eso se aplica aquí. (Estoy haciendo muchas revisiones de código y todos están usando ToLower).

Dim s = From row In context.Table Where String.Compare(row.Name, "test", StringComparison.InvariantCultureIgnoreCase) = 0

Esto se traduce en una consulta SQL que simplemente compara row.Name con "test" y no devolverá "Test" y "TEST" en una base de datos sensible a mayúsculas y minúsculas.

Como usted dice, hay algunas diferencias importantes entre ToUpper y ToLower, y solo una es confiable y confiable cuando intenta hacer verificaciones de igualdad que no distinguen entre mayúsculas y minúsculas.

Idealmente, la mejor manera de hacer una verificación de igualdad sin distinción entre mayúsculas y minúsculas sería :

String.Equals(row.Name, "test", StringComparison.OrdinalIgnoreCase)

¡NOTA, SIN EMBARGO, que esto no funciona en este caso! Por lo tanto estamos atrapados con ToUppero ToLower.

Tenga en cuenta el ordinal IgnoreCase para que sea la seguridad de fallos. Pero exactamente el tipo de verificación sensible a mayúsculas y minúsculas que use depende de sus propósitos. Pero, en general, use Iguales para verificaciones de igualdad y Comparar cuando esté ordenando, y luego elija la Comparación de cadenas correcta para el trabajo.

Michael Kaplan (una autoridad reconocida en cultura y manejo de personajes como este) tiene publicaciones relevantes en ToUpper vs. ToLower:

• http://www.siao2.com/2007/10/01/5218976.aspx
• http://www.siao2.com/2005/03/10/391564.aspx

Él dice "String.ToUpper - Use ToUpper en lugar de ToLower, y especifique InvariantCulture para recoger las reglas de la carcasa del sistema operativo "

Utilicé System.Data.Linq.SqlClient.SqlMethods.Like(row.Name, "test") en mi consulta.

Esto realiza una comparación entre mayúsculas y minúsculas.

Intenté esto usando la expresión Lambda, y funcionó.

List<MyList>.Any (x => (String.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase)) && (x.Type == qbType) );

Si pasa una cadena que no distingue entre mayúsculas y minúsculas en LINQ-to-SQL, se pasará al SQL sin cambios y la comparación se realizará en la base de datos. Si desea hacer comparaciones de cadenas que no distinguen entre mayúsculas y minúsculas en la base de datos, todo lo que necesita hacer es crear una expresión lambda que haga la comparación y el proveedor LINQ-to-SQL traducirá esa expresión en una consulta SQL con su cadena intacta.

Por ejemplo, esta consulta LINQ:

from user in Users
where user.Email == "[email protected]"
select user

se traduce al siguiente SQL por el proveedor LINQ-to-SQL:

SELECT [t0].[Email]
FROM [User] AS [t0]
WHERE [t0].[Email] = @p0
-- note that "@p0" is defined as nvarchar(11)
-- and is passed my value of "[email protected]"

Como puede ver, el parámetro de cadena se comparará en SQL, lo que significa que las cosas deberían funcionar de la manera que esperaría.

Para realizar consultas de Linq a Sql sensibles a mayúsculas y minúsculas, declare que los campos 'string' distinguen entre mayúsculas y minúsculas especificando el tipo de datos del servidor utilizando uno de los siguientes;

varchar(4000) COLLATE SQL_Latin1_General_CP1_CS_AS 

o

nvarchar(Max) COLLATE SQL_Latin1_General_CP1_CS_AS

Nota: La 'CS' en los tipos de clasificación anteriores significa 'mayúsculas y minúsculas'.

Esto se puede ingresar en el campo "Tipo de datos del servidor" cuando se visualiza una propiedad con Visual Studio DBML Designer.

Para más detalles ver http://yourdotnetdesignteam.blogspot.com/2010/06/case-sensitive-linq-to-sql-queries.html

where row.name.StartsWith(q, true, System.Globalization.CultureInfo.CurrentCulture)

El siguiente enfoque de 2 etapas funciona para mí (VS2010, ASP.NET MVC3, SQL Server 2008, Linq to SQL):

result = entRepos.FindAllEntities()
    .Where(e => e.EntitySearchText.Contains(item));

if (caseSensitive)
{
    result = result
        .Where(e => e.EntitySearchText.IndexOf(item, System.StringComparison.CurrentCulture) >= 0);
}

A veces, el valor almacenado en la base de datos puede contener espacios, por lo que ejecutar esto podría fallar

String.Equals(row.Name, "test", StringComparison.OrdinalIgnoreCase)

La solución a este problema es eliminar el espacio, luego convertir su caja y luego seleccionar así

 return db.UsersTBs.Where(x => x.title.ToString().ToLower().Replace(" ",string.Empty).Equals(customname.ToLower())).FirstOrDefault();

Nota en este caso

nombre personalizado es el valor que coincide con el valor de la base de datos

UsersTBs es clase

título es la columna de la base de datos

¡Recuerde que hay una diferencia entre si la consulta funciona y si funciona de manera eficiente ! Una declaración LINQ se convierte a T-SQL cuando el objetivo de la declaración es SQL Server, por lo que debe pensar en el T-SQL que se produciría.

El uso de String.

En otras palabras, el uso de una expresión aumentará su acceso a los datos y eliminará su capacidad de hacer uso de índices. Funcionará en mesas pequeñas y no notará la diferencia. En una mesa grande podría funcionar muy mal.

Ese es uno de los problemas que existe con LINQ; la gente ya no piensa en cómo se cumplirán las declaraciones que escriben.

En este caso, no hay una manera de hacer lo que quiere sin usar una expresión, ni siquiera en T-SQL. Por lo tanto, es posible que no pueda hacer esto de manera más eficiente. Incluso la respuesta T-SQL dada anteriormente (usando variables con intercalación) probablemente dará como resultado que se ignoren los índices, pero si es una tabla grande entonces vale la pena ejecutar la declaración y mirar el plan de ejecución para ver si se utilizó un índice .