In LINQ to SQL, come si passano parti di una query LINQ in una funzione

c# expression-trees linq linq-to-sql

Domanda

È possibile passare parti di una query di linq in una funzione? Voglio creare un'interfaccia comune per il mio DAL che utilizza sempre la stessa interfaccia di query. Per esempio,

List<T> Get(Join j, Where w, Select s){    
    return currentDataContext<T>.Join(j).Where(w).Select(s).ToList();    
}

Questo tipo di cose è possibile? Sto pensando che sarebbe stato fatto con gli alberi delle espressioni, ma non sono stato in grado di trovarne degli esempi.

Risposta accettata

Bene, il "join" è complicato, perché è molto difficile esprimere un join - ma cose come where / select / orderby sono piuttosto facili ...

In realtà, è solo un caso di combinare i vari metodi LINQ su IQueryable<T> , che generalmente accettano Expression<Func<...>> per alcune combinazioni. Quindi una selezione di base con un predicato opzionale potrebbe essere:

    public IQueryable<T> Get<T>(
        Expression<Func<T,bool>> predicate
        ) where T : class
    {
        IQueryable<T> query = (IQueryable<T>)GetTable(typeof(T));
        if (predicate != null) query = query.Where(predicate);
        return query;
    }

Tenderei a restituire anche IQueryable<T> , poiché è completamente componibile. Se il chiamante desidera un elenco, può sempre utilizzare ToList() su di esso ... o (ad esempio):

    using(var ctx = new MyDataContext(CONN))
    {
        ctx.Log = Console.Out;
        int frCount = ctx.Get<Customer>(c => c.Country == "France").Count();
    }

che (usando Northwind) fa la query:

SELECT COUNT(*) AS [value]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[Country] = @p0

Il problema con l'inclusione della "selezione" (proiezione) nella query è che si finirebbe con più tipi generici. Dato che spesso si desidera che la proiezione sia di tipo anonimo, sarebbe praticamente impossibile specificare il tipo di proiezione (anonimo) e il tipo di tabella e non sarebbe possibile chiamarlo.

In realtà, mi chiedo se ci sia molto beneficio nel scrivere un tale metodo. Potrei semplicemente attenermi a un metodo di base:

    public IQueryable<T> Get<T>() where T : class
    {
        return (IQueryable<T>)GetTable(typeof(T));
    }

E lascia che il chiamante lo componga nel modo preferito, magari con la sintassi della query:

       var list = (from cust in ctx.Get<Customer>()
                   where cust.Country == "France"
                   select cust.CompanyName).Take(10).ToList();

Che utilizza:

SELECT TOP (10) [t0].[CompanyName]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[Country] = @p0

In alternativa, se vuoi davvero includere l'ordine e la proiezione, allora un metodo di estensione è l'approccio più pratico; quindi non è necessario specificare l'originale (sorgente) T (che è ciò che lo rende invalido quando si mischia con i tipi anonimi):

public static class QueryExtension
{
    public static IQueryable<TProjection>
        Get<TSource, TProjection, TOrderKey>(
            this IQueryable<TSource> source,
            Expression<Func<TSource, bool>> where, // optional
            Expression<Func<TSource, TProjection>> select,
            Expression<Func<TProjection, TOrderKey>> orderBy)
    {
        if (where != null) source = source.Where(where);
        return source.Select(select).OrderBy(orderBy);
    }
}

Quindi considera un metodo DAL come:

    public List<string> Countries()
    {
        return Customers.Get(
            x=>x.CompanyName != "",
            x=>x.Country,
            x=>x).Distinct().ToList();
    }

Che utilizza (di nuovo, con Northwind):

SELECT DISTINCT [t0].[Country]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[CompanyName] <> @p0

Risposta popolare

Controlla questa classe generica: TableView.cs .

Fondamentalmente usa un delegato Func <TEntity, bool> per applicare il predicato Where:

//...
public TableView(DataContext dataContext, Expression<Func<TEntity, bool>> predicate)
{
    this.table = dataContext.GetTable<TEntity>();
    this.baseQuery = table.Where(predicate);
    this.predicate = predicate.Compile();
}
//...


Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché