Estoy implementando una función de autocomplete donde necesito filtrar la tabla SQL según la entrada del usuario.
Por lo tanto, el requisito es filtrar los registros donde debe comenzar ( sort ) los resultados con StartsWith y luego Contains .
Data de muestra:
Desarrollador DotNet
Administrador de Azure
microsoft azure
Azure DevOps
Desarrollador de experiencia de usuario
IoT azul
Si empiezo a escribir Azu , debería mostrar los resultados en el siguiente orden.
Azure administrador
Azul sobre DevOps
Microsoft Azure re
IOT azul re
lo que significa que estamos buscando los resultados que startswith lógica y luego contains lógica.
Actualmente, he probado dos enfoques pero esos no funcionaron.
Primer enfoque:
dbContext.dbTable.Select(h => h.FieldName.ToLowerInvariant()).Where(e => e.Contains(text)).OrderBy(s => s).Distinct().Take(count).ToList();Segundo enfoque:
dbContext.dbTable.Where(e => e.FieldName.Contains(text)).OrderBy(h => h.FieldName.IndexOf(text)).ThenBy(c => c.FieldName.Length).Select(p => p.FieldName).Distinct().Take(count).ToList();¿Puede alguien por favor guiarme si esto puede ser posible?
dbContext .dbTable .Where(x => x.FieldName.Contains(text)) .Distinct() .OrderByDescending(x => x.FieldName.StartsWith(text)) .Take(count);.Where(x => x.FieldName.Contains(text)) ).OrderByDescending(x => x.FieldName.StartsWith(text)) )Su principal problema son los requisitos o la comprensión de los requisitos.
Operación de filtro:
Reducir(=filtrar) los resultados basados en una expresión booleana donde:
true ==> mostrar el resultado
false ==> no mostrar.
Se logra en linq, mediante la cláusula Where(...).
En su caso, el requisito es Filtrar por los resultados que contienen text .
.Where(e => e.Contains(text)) Ordenar operación:
Dada una lista de resultados, decide el orden de los mismos. Su requisito es ver los valores que comienzan por text primero.
En otras palabras, ordenar por esta regla.
String.StartsWith devuelve un valor booleano.
Al ejecutar OrderBy de OrderBy en booleanos, los ordena por false y luego por true . Esto se debe a que la ordenación predeterminada de OrderBy es ascendente y false cuenta como "más pequeño" que true . (decisión razonable)
Entonces, sabiendo esto, puedes lograr lo que quieras ejecutando
.OrderByDescending(s => s.StartsWith(text))Lógica completa:
dbContext.dbTable .Select(h => h.FieldName.ToLowerInvariant()) .Where(e => e.Contains(text)) // filter .Distinct() // more filtering .OrderByDescending(s => s.StartsWith(text)) // sort .Take(count) .ToList();Prueba como lo siguiente
dbContext.dbTable.Where(e => e.FieldName.Contains(text)).OrderBy(h => h.FieldName.ToLower().StartsWith(searchString.ToLower()) ? 0 : 1) .ThenBy(c => c.FieldName.ToLower().Contains("order")).Select(p => p.FieldName).Distinct().Take(count).ToList();