|
Nous nous appuierons sur cette précédente astuce (Requêtes dynamiques sur les IEnumerable<T>) concernant le requêteur dynamique fourni en exemple dans Visual Studio 2008. Nous avions ajouté très peu de code afin de pouvoir requêter non pas uniquement sur des « IQueryable » mais aussi sur des « IEnumerable<T> ». Essayons d'exploiter cet exemple pour qu'un utilisateur puisse dynamiquement choisir les colonnes du fichier CSV qu'il souhaite exploiter. Tout d'abord, il nous faut extraire toutes les lignes du fichier : var s = File.ReadAllLines(@"E:\test.csv"); Généralement, la première ligne est constituée par le nom des colonnes dont le séparateur peut être le point virgule. Récupérer la liste des colonnes est très simple grâce à la méthode d'extension « First » : var nomsChamp = s.First().Split(';'); Les noms de colonnes récupérés peuvent servir à rendre plus convivial pour l'utilisateur le choix de celles-ci. Toutes les données du fichier CSV hormis la première ligne peuvent être extraites via une requête Linq des plus classiques : var l = from ligne in s.Skip(1) select ligne.Split(';'); Nous obtenons un « IEnumerable<string[]> », c'est-à-dire une énumération de rangées constituées par des champs. Comment exploiter ceci avec le requêteur dynamique ? J'avoue avoir foncé tête baissée pour modifier le parseur car je pensais qu'il ne prenait pas en compte les tableaux. Voici quelques lignes qui vous convaincrons qu'il est possible d'enrichir le parseur et d'y ajouter des expressions dans l'arbre qu'il génère : //ajouté dans la méthode FindPropertyOrField de la classe ExpressionParser if (type.IsArray) { foreach (MethodInfo m in type.GetMethods()) { if (m.Name == "Get") return m; } return null; } //ajouté dans la méthode ParseMemberAccess de la classe ExpressionParser if (member is MethodInfo && type.IsArray) { int valeur = int.Parse(id.Split(new string[] { "[", "]" }, StringSplitOptions.None)[1]); //Ajout à l'arbre d'expression return Expression.Call(instance, (MethodInfo)member, Expression.Constant(valeur)); } Ce code est évidemment complètement inutile puisque le requêteur dynamique fourni par Microsoft en exemple de Visual Studio 2008 gère les tableaux. Il suffisait tout simplement de lire la documentation fournie avec l'exemple. Je vous invite donc vivement à le faire. Si nous revenons à l'exploitation de notre fichier CSV, il suffit d'écrire : var t = l.Select("new( it[0] as Versement, it[2] as Periodicite, it[15] as Taux, it[5] as Police)"); pour extraire les champs souhaités par l'utilisateur. « it[0] » représente le premier champ de la rangée qui sera placé dans la propriété « Versement » de la « DynamicClassN » générée par le parseur. A ce stade d'écriture, nous n'obtenons en sortie qu'un ensemble d'objets possédant des propriétés de type « string ». On comprend aisément que l'on souhaite avoir un type par exemple « Decimal » pour la propriété « Versement ». Le parseur permet de réaliser des conversions de type, ceci est décrit dans la documentation. Nous pouvons donc écrire : var t = l.Select("new( Convert.ToDecimal(it[0]) as Versement, it[2] as Periodicite, it[15] as Taux, it[5] as Police)"); Supposons maintenant que l'utilisateur souhaite prendre en compte les versements de plus de 10000 euros, il n'y a rien de plus simple : var t = l.Where("Convert.ToDecimal(it[0]) > 10000") .Select("new( Convert.ToDecimal(it[0]) as Versement, it[2] as Periodicite, it[15] as Taux, it[5] as Police)"); Nous pourrions évidemment nous satisfaire de ce développement mais l'idéal ne serait pas de récupérer un « DynamicClassN » mais un objet bien à nous dont nous aurions fourni le type au parseur. Ceci n'a pas été développé. C'est l'occasion d'enrichir ce parseur.
Il serait confortable de pouvoir fournir le type de l'objet dont on souhaite remplir les propriétés, le parseur se chargeant de l'initialisation de celui-ci. Pour cet objet : public class ContratENT { public int Periodicite {get; set;} public decimal Versement {get; set;} public decimal Taux {get; set;} public string Police { get; set; } } nous aimerions pouvoir écrire une requête de ce type : var t = l.Where("Convert.ToDecimal(it[0]) > 10000") .Select(@"new( Convert.ToDecimal(it[0]) as Versement, Convert.ToInt32(it[2]) as Periodicite, Convert.ToDecimal(it[15]) as Taux, it[5] as Police)",typeof(ContratENT)); Il nous faut donc créer une méthode d'extension avec un paramètre supplémentaire prenant en charge le type de l'objet que l'on souhaite voir rempli : public static IEnumerable<object> Select<T>(this IEnumerable<T> source, string selector, Type objectToFill, params object[] values) { if (source == null) throw new ArgumentNullException("source"); if (selector == null) throw new ArgumentNullException("selector"); return Select((IQueryable)source.AsQueryable(), selector, objectToFill, values).Cast<object>(); } public static IQueryable Select(this IQueryable source, string selector, Type objectToFill, params object[] values) { if (source == null) throw new ArgumentNullException("source"); if (selector == null) throw new ArgumentNullException("selector"); LambdaExpression lambda = DynamicExpression.ParseLambdaObjectToFill(new ParameterExpression[] { Expression.Parameter(source.ElementType, "") }, objectToFill, selector, values); return source.Provider.CreateQuery( Expression.Call( typeof(Queryable), "Select", new Type[] { source.ElementType, lambda.Body.Type }, source.Expression, Expression.Quote(lambda))); } La première méthode « Select » pour les « IEnumerable<T> » renvoie à la deuxième méthode « Select » pour les « IQueryable » prenant en paramètre le type de notre objet. L'arbre d'expression construit par le parseur devra prendre en charge ce type. Il nous faut écrire la nouvelle méthode « ParseLambdaObjectToFill » de la classe statique « DynamicExpression ». Cette dernière prendra en charge notre type : public static LambdaExpression ParseLambdaObjectToFill(ParameterExpression[] parameters, Type objectToFill, string expression, params object[] values) { ExpressionParser parser = new ExpressionParser(parameters, expression, values, objectToFill); return Expression.Lambda(parser.Parse(null), parameters); } Il faut transmettre le type au parseur « ExpressionParser » chargé de parser la chaîne de caractères pour en faire un arbre d'expressions. Au constructeur existant : public ExpressionParser(ParameterExpression[] parameters, string expression, object[] values) { if (expression == null) throw new ArgumentNullException("expression"); if (keywords == null) keywords = CreateKeywords(); symbols = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); literals = new Dictionary<Expression, string>(); if (parameters != null) ProcessParameters(parameters); if (values != null) ProcessValues(values); text = expression; textLen = text.Length; SetTextPos(0); NextToken(); } il nous faut ajouter un constructeur prenant en paramètre le type de notre objet. Nous remplaçons donc le constructeur par ces lignes : Type _objectToFill; public ExpressionParser(ParameterExpression[] parameters, string expression, object[] values, Type objectToFill) { _objectToFill = objectToFill; Parser(parameters, expression, values); } public ExpressionParser(ParameterExpression[] parameters, string expression, object[] values) { Parser(parameters, expression, values); } void Parser(ParameterExpression[] parameters, string expression, object[] values) { if (expression == null) throw new ArgumentNullException("expression"); if (keywords == null) keywords = CreateKeywords(); symbols = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); literals = new Dictionary<Expression, string>(); if (parameters != null) ProcessParameters(parameters); if (values != null) ProcessValues(values); text = expression; textLen = text.Length; SetTextPos(0); NextToken(); } Nous ne faisons que stocker le type de notre objet dans la variable locale « _objectToFill ». L'idée est simple, au lieu de créer la « DynamicClass » et de l'instancier, nous instancierons directement l'objet dont nous avons passé le type en paramètre. L'emplacement est facile à localiser puisque c'est au moment de parser le « new » dans la chaîne dynamique que nous devrons modifier le code. Ceci se situe dans la méthode « ParseNew » de la classe « ExpressionParser ». Au code : Type type = DynamicExpression.CreateClass(properties); se substitue : Type type = _objectToFill as Type; if (_objectToFill == null) type = DynamicExpression.CreateClass(properties); . Nous n'avons plus de codes à ajouter. Ces aménagements permettent désormais le remplissage des propriétés de notre propre objet. Vous avez pu donc vous rendre compte qu'il était relativement facile de faire évoluer le parseur.
En lisant la documentation, vous avez pu vous apercevoir que l'on pouvait effectuer un grand nombre d'opérations comme par exemple récupérer les deux derniers caractères d'une chaine : it[5].Substring(it[5].Length -2,2) as Version Ceci n'est qu'un exemple simple. Il faut pourtant bien avouer que si nous voulons offrir à un utilisateur la possibilité de pouvoir requêter dynamiquement, une telle syntaxe apparaît bien lourde. La question que l'on peut se poser est donc « peut-on définir nos propres fonctions ? ». La réponse est évidemment affirmative et vous allez voir que la simplicité vous permettra de concrétiser toutes vos idées ! Pour cela, localisons par une recherche, dans le code du requêteur dynamique écrit par Microsoft, la classe « Math » puisque la documentation fournie avec le parseur indique qu'il est possible de l'utiliser. Mon idée est la suivante : si nous pouvons accéder à toutes les méthodes statiques de cette classe, c'est qu'un inventaire de ses méthodes est effectué automatiquement. Si cette idée se vérifie, il suffirait donc de déclarer le type d'une classe que nous définirions avec nos propres méthodes. Localisons « Math » : static readonly Type[] predefinedTypes = { typeof(Object), typeof(Boolean), typeof(Char), typeof(String), typeof(SByte), typeof(Byte), typeof(Int16), typeof(UInt16), typeof(Int32), typeof(UInt32), typeof(Int64), typeof(UInt64), typeof(Single), typeof(Double), typeof(Decimal), typeof(DateTime), typeof(TimeSpan), typeof(Guid), typeof(Math), typeof(Convert) }; Nous pouvons constater qu'il s'agit d'un tableau de types. Et si nous tentions d'y insérer notre propre classe ? Faisons le remplacement : static readonly Type[] predefinedTypes = { typeof(Object), typeof(Boolean), typeof(Char), typeof(String), typeof(SByte), typeof(Byte), typeof(Int16), typeof(UInt16), typeof(Int32), typeof(UInt32), typeof(Int64), typeof(UInt64), typeof(Single), typeof(Double), typeof(Decimal), typeof(DateTime), typeof(TimeSpan), typeof(Guid), typeof(Math), typeof(Convert), typeof(Fx) //Ajout de Fx }; //Exemples de fonctions simples pour la démonstration : static class Fx { public static string Left(string chaine, int pos) { return chaine.Substring(0, pos); } public static string Right(string chaine, int pos) { return chaine.Substring(chaine.Length - pos, pos); } } Et si nous testions maintenant ? remplaçons ce code un peu « barbare » pour un utilisateur : it[5].Substring(it[5].Length -2,2) as Version par le plus élégant et concis : Fx.Right(it[5],2) as Version et le plus beau, c'est que tout ceci fonctionne ! Votre imagination débordante n'a donc désormais plus de limites Il n'y a pas de magie, le parseur écrit par Microsoft en exemple dans Visual Studio 2008 est très bien codé. Je vous invite vivement à l'étudier, comme j'ai pu le faire. Vous trouverez sans doute dans vos investigations d'autres idées d'améliorations. A vos claviers !
|
|
|
|
|