Continuiamo a vedere come implementare un provider custom che supporta la sintassi Linq.
Per prima cosa creiamo un oggetto che implementa le interfacce IQueryable e IQueryProvider. Ecco una prima implementazione :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CustomLinqProvider
{
public class myQueryableObject<T> : IQueryable, IQueryable<T>, IQueryProvider
{
private System.Linq.Expressions.Expression _expression = null;
#region IQueryable Members
public Type ElementType
{
get { return typeof(T); }
}
public System.Linq.Expressions.Expression Expression
{
get { return _expression; }
internal set { _expression = value; }
}
public IQueryProvider Provider
{
get { return this; }
}
#endregion
#region IEnumerable Members
public System.Collections.IEnumerator GetEnumerator()
{
throw new NotImplementedException();
}
#endregion
#region IEnumerable<T> Members
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
throw new NotImplementedException();
}
#endregion
#region IQueryProvider Members
public IQueryable<TElement> CreateQuery<TElement>(System.Linq.Expressions.Expression expression)
{
myQueryableObject<TElement> mq = new myQueryableObject<TElement>();
mq.Expression = expression;
return mq;
}
public IQueryable CreateQuery(System.Linq.Expressions.Expression expression)
{
return CreateQuery<T>(expression);
}
public TResult Execute<TResult>(System.Linq.Expressions.Expression expression)
{
throw new NotImplementedException();
}
public object Execute(System.Linq.Expressions.Expression expression)
{
throw new NotImplementedException();
}
#endregion
}
}
I metodi che per adesso ci interessano sono i due metodi CreateQuery. questi metodi vengono chiamati al termine della creazione della Expression Tree da parte del compilatore. La Expression Tree viene preparata e viene passata come oggetto Expression che può essere interpretato ed utilizzato per eseguire le nostre query.
Come è possibile vedere non viene fatta alcun tipo di elaborazione, semplicemente la expression viene memorizzata all'interno del membro _expression e vine e restituito un oggetto dello stesso tipo che stiamo creando. Questo perchè è molto spesso conveniente implementare IQueryProvider e IQueryable all'interno della stessa classe. Capiremo tra poco il perchè.
Abbiamo detto che i metodi CreateQuery vengono invocati appena la creazione della expression tree è completata, tuttavia non viene eseguita nessuna elaborazione. Il motivo di questa tardata esecuzione è che ancora non sappiamo come applicare l'Expression Tree; in modo particolare non sappiamo se dobbiamo attenderci un risultato singolo oppure una lista di elementi e il metodo che viene invocato per l'esecuzione della query potrebbe essere differente.
Facciamo un esempio. Nella query
var result = from rr in myQueryObject<tabella1>()
select rr;
abbiamo definito che intendiamo ottenere tutti i campi della tabella 1 senza nessun filtro. Tuttavia l'esecuzione potrebbe essere eseguita in uno dei seguenti metodi:
rr.ToArray();
rr.Count();
rr.FirstOrDefault();
Ognuno di questi metodi applica la query eseguendo operazioni differenti:
La prima restituisce un risultato multiplo, la seconda esegue un raggruppamento su tutti i record per restituirci il numero di elementi all'interno della tabella, il terzo restituisce il primo elemento completo.
Vediamo quindi come viene invocata l'esecuzione della query.
La prima grande differenza tra i metodi che invocano la query è il tipo di risultato che andiamo ad ottenere.
Se il risultato è un elenco di elementi, allora verranno invocati i metodi GetEnumerator() della nostra classe.
Se invece il risultato è un elemento singolo, allora la query verrà arricchita con l'informazione della chiamata all'ultimo metodo e verrà invocato il metodo Execute().
Tornando al nostro esempio, nel caso di ToArray() verà invocato il GetEnumerator, nel caso di Count() o di FirstOrDefault(), verrà aggiunto all'Expression Tree l'informazione della chiamata all'ultimo metodo e verrà effettivamente invocato il metodo Execute.
Quindi per implementare il nostro parser, dovremo implementare sia i metodi Execute che i metodi GetEnumerator di cui abbiamo già gli stub pronti perchè abbiamo implementato le interfaccie.
E comodo avere implementate entrambe le interfaccie all'interno della stessa classe, poichè il metodo GetEnumerator viene fornito dalla interfaccia IQueryable, mentre il metodo Execute viene fornito dalla interfaccia IQueryProvider.
E' venuto il momento di capire l'Expression Tree e piegarla alla nostra volontà. L'Expression Tree è la rappresentazione a livello linguaggio delle operazioni che devono essere eseguite per ottenere un certo set di dati.
Quello che vogliamo fare per prima cosa è capire come "leggere" l'expression tree, per poi interpretarla ed eseguire operazioni Custom.
Scriviamo questa Query:
myQueryableObject<int> test = new myQueryableObject<int>();
var result = from i in test
select i;
e vediamo come viene interpretata eseguendo result.Expression.ToString();
value( CustomLinqProvider.myQueryableObject`1[System.Int32] ).Select( i => i )
quello che vediamo è la visualizzazione testuale dell'expression tree. come possiamo vedere ogni operazione viene esplicitata in modo del tutto simile alla chiamata a metodi.
Quello che accade in realtà, è che ogni sezione della nostra espressione viene rappresentata attraverso un nodo della expression tree.
Ogni nodo è composto da un oggetto che eredita dalla classe expression. L'oggetto specializza la classe base in modo da rappresentare in modo più fedele possibile il significato del nodo stesso.
Vediamo quali sono gli oggetti che ereditano da Expression.
- BinaryExpression
- ConditionalExpression
- ConstantExpression
- InvocationExpression
- LambdaExpression
- ListInitExpression
- MemberExpression
- MemberInitExpression
- MethodCallExpression
- NewArrayExpression
- NewExpression
- ParameterExpression
- TypeBinaryExpression
- UnaryExpression
Ognuno di questi oggetti rappresenta un particolare tipo di nodo all'interno della nostra espressione. Ogni classe può tuttavia rappresentare più di un tipo di nodo.
I tipi possibili di nodo sono rappresentati da un Enum.
public enum ExpressionType
{
Add,
AddChecked,
And,
AndAlso,
ArrayLength,
ArrayIndex,
Call,
Coalesce,
Conditional,
Constant,
Convert,
ConvertChecked,
Divide,
Equal,
ExclusiveOr,
GreaterThan,
GreaterThanOrEqual,
Invoke,
Lambda,
LeftShift,
LessThan,
LessThanOrEqual,
ListInit,
MemberAccess,
MemberInit,
Modulo,
Multiply,
MultiplyChecked,
Negate,
UnaryPlus,
NegateChecked,
New,
NewArrayInit,
NewArrayBounds,
Not,
NotEqual,
Or,
OrElse,
Parameter,
Power,
Quote,
RightShift,
Subtract,
SubtractChecked,
TypeAs,
TypeIs
}
Per interpretare in modo corretto quindi un Expression Tree è sufficiente navigare l'albero e interpretare ogni tipo di nodo. Nel prossimo post vedremo con scrivere in modo corretto un parser per interpretare l'expression tree.
Vi consiglio di dare un'occhiata ai link che vi riporto.
Link utili :
http://msdn.microsoft.com/en-us/library/bb882521.aspx
http://msdn.microsoft.com/en-us/library/bb882536.aspx
http://msdn.microsoft.com/en-us/library/bb397951.aspx