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();
}
//...