c# - studio - linq to sql vs entity framework

LINQ to SQL Where Clause Criterios opcionales

Question

Estoy trabajando con una consulta de LINQ a SQL y me he encontrado con un problema en el que tengo 4 campos opcionales para filtrar el resultado de los datos. Por opción, me refiero a que tiene la opción de ingresar un valor o no. Específicamente, algunos cuadros de texto que podrían tener un valor o tener una cadena vacía y algunas listas desplegables que podrían haber tenido un valor seleccionado o tal vez no ...

Por ejemplo:

    using (TagsModelDataContext db = new TagsModelDataContext())
     {
        var query = from tags in db.TagsHeaders
                    where tags.CST.Equals(this.SelectedCust.CustCode.ToUpper()) 
                    && Utility.GetDate(DateTime.Parse(this.txtOrderDateFrom.Text)) <= tags.ORDDTE
                    && Utility.GetDate(DateTime.Parse(this.txtOrderDateTo.Text)) >= tags.ORDDTE
                    select tags;
        this.Results = query.ToADOTable(rec => new object[] { query });
    }

Ahora necesito agregar los siguientes campos / filtros, pero solo si el usuario los proporciona.

1. Número de producto: proviene de otra tabla que se puede unir a TagsHeaders.
2. Número de PO: un campo dentro de la tabla de TagsHeaders.
3. Número de pedido: similar a PO #, solo una columna diferente.
4. Estado del producto: si el usuario lo seleccionó de un menú desplegable, debe aplicar aquí el valor seleccionado.

La consulta que ya tengo funciona muy bien, pero para completar la función, necesita poder agregar estos otros 4 elementos en la cláusula where, ¡simplemente no sé cómo!

Answer 1

Puedes codificar tu consulta original:

var query = from tags in db.TagsHeaders
                where tags.CST.Equals(this.SelectedCust.CustCode.ToUpper()) 
                && Utility.GetDate(DateTime.Parse(this.txtOrderDateFrom.Text)) <= tags.ORDDTE
                && Utility.GetDate(DateTime.Parse(this.txtOrderDateTo.Text)) >= tags.ORDDTE
                select tags;

Y luego, en función de una condición, agregue restricciones adicionales donde.

if(condition)
    query = query.Where(i => i.PONumber == "ABC"); 

No estoy seguro de cómo codificar esto con la sintaxis de la consulta, pero la identificación funciona con una lambda. También funciona con sintaxis de consulta para la consulta inicial y una lambda para el filtro secundario.

También puede incluir un método de extensión (a continuación) que codifiqué hace un tiempo para incluir sentencias condicionales. (No funciona bien con la sintaxis de consulta):

        var query = db.TagsHeaders
            .Where(tags => tags.CST.Equals(this.SelectedCust.CustCode.ToUpper()))
            .Where(tags => Utility.GetDate(DateTime.Parse(this.txtOrderDateFrom.Text)) <= tags.ORDDTE)
            .Where(tags => Utility.GetDate(DateTime.Parse(this.txtOrderDateTo.Text)) >= tags.ORDDTE)
            .WhereIf(condition1, tags => tags.PONumber == "ABC")
            .WhereIf(condition2, tags => tags.XYZ > 123);

El método de extensión:

public static IQueryable<TSource> WhereIf<TSource>(
    this IQueryable<TSource> source, bool condition,
    Expression<Func<TSource, bool>> predicate)
{
    if (condition)
        return source.Where(predicate);
    else
        return source;
}

Aquí está el mismo método de extensión para IEnumerables:

public static IEnumerable<TSource> WhereIf<TSource>(
    this IEnumerable<TSource> source, bool condition,
    Func<TSource, bool> predicate)
{
    if (condition)
        return source.Where(predicate);
    else
        return source;
}

Answer 2

Solo necesita usar una verificación condicional para la existencia del parámetro. Por ejemplo:

where (string.IsNullOrEmpty(ProductNumber) || ProductNumber == tags.productNumber)

De esta forma, si no se ingresa el número de producto, esa expresión volverá a ser verdadera en todos los casos, pero si se ingresa, solo se devolverá verdadera cuando coincida.

Answer 3

Tienes la capacidad de O con ||.

Mira este hilo, ya que podría darte algunos buenos consejos: C # LINQ equivalente a una consulta SQL algo compleja