maggio 2006 Blog Posts
Facendo seguito ai miei post precedenti, il metodo QueryExpression::Parse effettua chiaramente un controllo sui tipi coinvolti nell'espressione; ad es. Parse solleverebbe un'eccezione per un'espressione del tipo
x * 2
se x è un parametro dichiarato come stringa.Un'altra interessante caratteristica del metodo Parse è che questo è in grado di inferire il tipo del risultato dell'espressione. Es:
string expr = "x + 2";Dictionary<string, Expression> scope = new Dictionary<string, Expression>();scope.Add("x", Expression.Parameter(typeof(int), "x"));Expression expression = QueryExpression.Parse(expr, scope);
// Expression::Type è il tipo del valore calcolato dall'espressione.Console.WriteLine(expression.Type); // System.Int32
Se expr fosse invece
string expr = "x + 2.0";// ...Console.WriteLine(expression.Type); // System.Double
Infine, se expr fosse ad es.
string expr = "x...
Un'altro interessante metodo della classe System.Query.QueryExpression (presente nell'assembly System.Query.dll della preview di LINQ) è Parse: riceve in input una espressione (e gli eventuali argomenti) sotto forma di stringa e restituisce in output un oggetto Expression, ovvero una rappresentazione ad oggetti della stessa. Si consideri il seguente codice:
using System;using System.Collections.Generic;using System.Text;using System.Query;using System.Expressions;
class ExpressionBuilder{ private Expression expression; private ParameterExpression[] parameters;
public ExpressionBuilder(string expression, params ParameterExpression[] parameters) { this.parameters = parameters; if (parameters == null || parameters.Length == 0) { this.expression = QueryExpression.Parse(expression); return; }
Dictionary<string, Expression> scope = new Dictionary<string, Expression>(); foreach (ParameterExpression parameter in parameters) { ParameterExpression tmp = Expression.Parameter(parameter.Type, parameter.Name); ...
Uno degli assembly fornito con l'installazione della Preview di LINQ è System.Query.dll. E' codice che gira sul .Net Framework 2.0 e pertanto può essere utilizzato e compilato anche con il compilatore C# 2.0 (lo stesso discorso vale per altri compilatori). C# 3.0 aggiunge diverse feature al compilatore che permettono ad es. di scrivere delegate con una sintassi compatta (lambda expression). L'esecutore del codice rimane comunque in ultima analisi il .Net Framework 2.0.Curiosando nell'assembly si trovano diverse interessanti classi. Supponiamo ad es. di voler comporre programmaticamente una expressione che effettua la somma di due numeri interi. Possiamo scrivere una cosa del...
Chi ha avuto modo di utilizzare anche minimamente le TAPI (Telephone API) penso si sia reso conto delle potenzialità e allo stesso tempo della complessità nel loro utilizzo. Esistono due "librerie" TAPI: le TAPI 2 (DLL normale) e le TAPI 3 (DLL COM). Sul sito http://www.julmar.com/samples.htm è possibile trovare due managed wrapper (scritti in managed C++) per ciascuna delle due "versioni" di TAPI.
Enumerare i nodi di un albero binario (è per semplicità di esposizione anche se l'algoritmo si adatta anche nel caso di alberi non binari) per livelli è relativamente semplice: basta utilizzare una coda.Visitare un albero per livelli significa per un albero del tipo
A B D E C F
la sequenza A B C D E F (prendo, da sinistra a destra, tutti i nodi di livello 0, poi di livello 1, ...).
public class Tree<T>{ public T Item; public Tree<T> Left; public Tree<T> Right;
public Tree() { }
public Tree(T item, Tree<T> left, Tree<T> right) { this.Item = item; this.Left = left; ...
Il porting per il .Net Framework di un "celebre" Application Framework Java che concentra diverse aree funzionali: http://www.springframework.net/
E' veramente interessante la compattezza e l'eleganza del codice che è possibile scrivere combinando generics e iterators.Ad esempio per enumerare al contrario gli elementi di una sequenza (per sequenza si intende un qualsiasi oggetto che implementa l'interfaccia IEnumerable<T>):
IEnumerable<T> Reverse<T>(IEnumerable<T> sequence){ // Un overload del costruttore di Stack<T> accetta in input // un oggetto che implementa IEnumerable<T>. Stack<T> stack = new Stack<T>(sequence);
foreach (T item in stack) yield return item;}
Microsoft Phoenix (http://research.microsoft.com/phoenix/) è il nome in codice del framework che in futuro sarà una componente essenziale e standard per i compilatori di Redmond.
In una intervista, Jim Hogg ne illustra finalità e fondamenti: http://channel9.msdn.com/Showpost.aspx?postid=188589
Alcuni giorni fa, cercando sulla rete una libreria .Net che mi permettesse di rappresentare graficamente un grafo orientato, ho trovato questo http://netron.sourceforge.net/wp/.
Nonostante non ne sia ancora stato fatto il porting sul .Net Framework 2.0, è una libreria di codice veramente scritta bene.
La promessa di LINQ è quella di poter scrivere interrogazioni SQL-like per qualunque oggetto che implementi l'interfaccia IEnumerable<T>, dove T è il tipo degli elementi della "sequenza" da interrogare. Le query possono essere, tra l'altro, eseguite in parte da un DBMS (DLINQ) e in parte in memoria.Gran parte delle feature di LINQ si basano su alcune estensioni a C# (idem per VB.Net) supportate dalla prossima versione del compilatore (3.0). Di queste feature, due sono già presenti nell'attuale compilatore C# 2: generics e iterators. Generics e iterators sono un'accoppiata formidabile per generare astrazioni.Grazie a tutto questo è possibile scrivere una classe...