c# - dinamico - Dinámico donde condición en LINQ

linq expression builder c#

Question

Tengo un escenario en el que tengo que usar una condición dinámica en LINQ.

Quiero algo como esto:

public void test(bool flag)
{
   from e in employee
   where e.Field<string>("EmployeeName") == "Jhom"
   If (flag == true)
   {
       e.Field<string>("EmployeeDepartment") == "IT"
   }
   select e.Field<string>("EmployeeID")
}

Sé que no podemos usar el ''Si'' en el medio de la consulta de Linq, pero ¿cuál es la solución para esto?

Por favor ayuda...

Answer 1

Consulte la publicación completa del blog: consulta dinámica con Linq

Hay dos opciones que puede usar:

Biblioteca dinámica LINQ

string condition = string.Empty;
if (!string.IsNullOrEmpty(txtName.Text))
    condition = string.Format("Name.StartsWith(/"{0}/")", txtName.Text);

EmployeeDataContext edb = new EmployeeDataContext();
if(condition != string.empty)
{
  var emp = edb.Employees.Where(condition);
 ///do the task you wnat
}
else
{
 //do the task you want 
}

Constructor de predicados

El generador de predicados funciona de forma similar a la biblioteca Dynamic LINQ pero es seguro de tipo:

var predicate = PredicateBuilder.True<Employee>();

if(!string.IsNullOrEmpty(txtAddress.Text))
    predicate = predicate.And(e1 => e1.Address.Contains(txtAddress.Text));

EmployeeDataContext edb= new EmployeeDataContext();
var emp = edb.Employees.Where(predicate);

diferencia entre la biblioteca de arriba:

• PredicateBuilder permite construir consultas dinámicas seguras .
• La biblioteca Dynamic LINQ permite construir consultas con cláusulas Where y OrderBy dinámicas especificadas mediante cadenas .

Answer 2

Entonces, si la flag es false necesitas todos los Jhoms, y si la flag es verdadera solo necesitas Jhoms en el departamento de TI

Esta condición

!flag || (e.Field<string>("EmployeeDepartment") == "IT"

cumple ese criterio (siempre es cierto si el indicador es falso, etc.), por lo que la consulta se convertirá en:

from e in employee    
where e.Field<string>("EmployeeName") == "Jhom"
  && (!flag || (e.Field<string>("EmployeeDepartment") == "IT")
select e.Field<string>("EmployeeID") 

Además, este e.Field<string>("EmployeeID") , huele a softcoding , podría echar un vistazo a eso. supongo

from e in employee    
where e.EmployeeName == "Jhom"
  && (!flag || (e.EmployeeDepartment == "IT")
select e.EmployeeID

sería más compacto y menos propenso a errores de tipeo.

EDITAR: Esta respuesta funciona para este escenario particular. Si tiene muchas de estas consultas, investigue los patrones propuestos en las otras respuestas.

Answer 3

Puede encadenar métodos:

public void test(bool flag)
{
   var res = employee.Where( x => x.EmployeeName = "Jhom" );

   if (flag)
   {
       res = res.Where( x => x.EmployeeDepartment == "IT")
   }

   var id = res.Select(x => x.EmployeeID );
}

Answer 4

Puede llamar métodos LINQ explícitamente y encadenarlos condicionalmente.

public IEnumerable<string> FilterEmployees (IEnumerable<Employee> source, bool restrictDepartment)
{
    var query = source.Where (e => e.Field<string>("EmployeeName") == "Jhom");

    if (restrictDepartment) // btw, there''s no need for "== true"
        query = query.Where (e => e.Field<string>("EmployeeDepartment") == "IT");

    return query.Select (e => e.Field<string>("EmployeeID"));
}

Answer 5

from e in employee    
where e.Field<string>("EmployeeName") == "Jhom" &&
(!flag || e.Field<string>("EmployeeDepartment") == "IT")
select e.Field<string>("EmployeeID")