[.net 2.0] - classe pour gérer facilement les predicate pour les generics + classe serialization - deserialization xml gener

Télécharger le projet
Commenter

Description

Si on y regarde bien les collections et plus particulièrement les collections génériques offrent toutes les méthodes dont on peut avoir besoin (tant pour ajouter 1 ou plusieurs objets à la fois à une collection,modifier,supprimer ,sélectionner un ou plusieurs éléments,etc. ) voir le tuto que j?ai fait >
http://www.csharpfr.com/tutoriaux/NET-TOUR-HORIZON-MEMBRES-GENERICS-SYSTEM-COLLECTIONS-GENERIC_685.aspx

Par contre pour sélectionner selon des critères bien précis,on risque vite d?avoir à ajouter beaucoup de méthodes si on doit utiliser les predicate (avec les méthodes de sélection comme Find,FindAll,etc. des generics)
J?ai développé ces classes qui ne sont pas parfaites certainement mais qui évitent d?avoir à coder les méthodes pour chaque « filtre » que l?on aurait voulu, il suffit d?instancier une des classes (selon le type de la propriété visée int,string,datetime,Double) ?
Passer au constructeur :
- le type de comparaison à faire (ex : pour stringPredicateHelper > ce sera StartWith pour trouver tous les noms commencant ou contains , etc.)
- le nom de la propriété visée (ex : la propriété « ContactName » de la classe Contact)
- et la valeur comparée (ex : passer « A » pour trouver tous les contacts dont les noms commenceraient par « A »)
il suffit ensuite d?appeler la méthode Predicate
ce qui donne par exemple ;

//Tous les contacts dont le nom commence par A
stringPredicateHelper oStringPredicateHelper = new stringPredicateHelper(stringComparaison.StartWith, "ContactName", "A");
List<Contact> oSearchContacts = oContacts.FindAll(oStringPredicateHelper.Predicate);

dataGridView1.DataSource = oSearchContacts;

J?ai inclus également
- un exemple de code montrant comment on peut passer des paramètres à un predicate (grâce aux méthodes anonymes)
- un exemple de code comment trier sur plusieurs colonnes avec IComparer (ce que je viens de connaitre grâce au forum :p)
- une classe de sérialization Xml générique

> dans le cas ou on veut ajouter des fonctionnalités à une classe par exemple à stringPredicateHelper :
- ajouter une valeur à l'enum correspondante (dans le cas stringPredicateHelper c'est donc StringComparaison)
- ajouter la comparaison dans la méthode Predicate (ajouter la valeur de l'enum au switch) qui renverra le booléen "result"

Bon voila je sais que j?ai peut être pas été très clair dans les explications et que pas forcément tout le monde connait et utilise les predicate, mais j?ai mis un zip qui contient un projet de test très simple et très clair
De plus il est très facile d?ajouter, personnaliser ou d?améliorer des méthodes ..
++

Source / Exemple : 


using System;
using System.Collections.Generic;
using System.Text;

namespace Cs2Predicate
{
    /// <summary>
    /// permet de gérer les prédicats pour les propriétés de type string
    /// </summary>
    public class stringPredicateHelper
    {
        private stringComparaison _Comparaison;

        /// <summary>
        /// la comparaison
        /// </summary>
        public stringComparaison Comparaison
        {
            get { return _Comparaison; }
            set { _Comparaison = value; }
        }
        private string _Property;

        /// <summary>
        /// la propriété ciblée de la comparaison
        /// </summary>
        public string Property
        {
            get { return _Property; }
            set { _Property = value; }
        }
        private string _Value;

        /// <summary>
        /// la valeur de comparaison de la propriété ciblée
        /// </summary>
        public string Value
        {
            get { return _Value; }
            set { _Value = value; }
        }

        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public stringPredicateHelper()
        { }
        /// <summary>
        /// Constructeur
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public stringPredicateHelper(stringComparaison Comparaison, string Property, string Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// méthode permettant d'affecter rapidement les valeurs aux propriétés de la classe,
        /// le but étant la réutilisation d'une instance de la classe sans réinstanciation
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public void SetProperties(stringComparaison Comparaison, string Property, string Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// compare la valeur courante de l'objet passé à la valeur définie pour un type de comparaison
        /// </summary>
        /// <param name="obj">l'objet reçu</param>
        /// <returns>vrai ou faux</returns>
        public bool Predicate(object obj)
        {
            bool result = false;
            string CurrentPropertyValue = Convert.ToString(PredicateUtils.GetValue(obj, Property));

            switch (Comparaison)
            {
                case stringComparaison.Contains:
                    result = CurrentPropertyValue.Contains(Value);
                    break;
                case stringComparaison.EndWith:
                    result = CurrentPropertyValue.EndsWith(Value);
                    break;
                case stringComparaison.Equals:
                    result = CurrentPropertyValue.Equals(Value);
                    break;
                case stringComparaison.Length:
                    if (CurrentPropertyValue.Length > Convert.ToInt32(Value))
                        result = true;
                    else
                        result = false;
                    break;
                case stringComparaison.StartsWith:
                    result = CurrentPropertyValue.StartsWith(Value);
                    break;
            }

            return result;
        }
    }
    /// <summary>
    /// permet de gérer les prédicats pour les propriétés de type int
    /// </summary>
    public class intPredicateHelper
    {
        private intComparaison _Comparaison;

        /// <summary>
        /// la comparaison
        /// </summary>
        public intComparaison Comparaison
        {
            get { return _Comparaison; }
            set { _Comparaison = value; }
        }
        private string _Property;

        /// <summary>
        /// la propriété ciblée de la comparaison
        /// </summary>
        public string Property
        {
            get { return _Property; }
            set { _Property = value; }
        }
        private int _Value;

        /// <summary>
        /// la valeur de comparaison de la propriété ciblée
        /// </summary>
        public int Value
        {
            get { return _Value; }
            set { _Value = value; }
        }
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public intPredicateHelper()
        { }
        /// <summary>
        /// Constructeur
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public intPredicateHelper(intComparaison Comparaison, string Property, int Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// méthode permettant d'affecter rapidement les valeurs aux propriétés de la classe,
        /// le but étant la réutilisation d'une instance de la classe sans réinstanciation
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public void SetProperties(intComparaison Comparaison, string Property, int Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// compare la valeur courante de l'objet passé à la valeur définie pour un type de comparaison
        /// </summary>
        /// <param name="obj">l'objet reçu</param>
        /// <returns>vrai ou faux</returns>
        public bool Predicate(object obj)
        {
            bool result = false;
            Nullable<int> CurrentPropertyValue = (Nullable<int>)PredicateUtils.GetValue(obj, Property);

            switch (Comparaison)
            {
                case intComparaison.Equals:
                    result = CurrentPropertyValue.Equals(Value);
                    break;
                case intComparaison.inf:
                    if (CurrentPropertyValue < Value)
                        result = true;
                    break;
                case intComparaison.Sup:
                    if (CurrentPropertyValue > Value)
                        result = true;
                    break;
            }

            return result;
        }
    }
    /// <summary>
    /// permet de gérer les prédicats pour les propriétés de type Double
    /// </summary>
    public class DoublePredicateHelper
    {
        /// <summary>
        /// la comparaison
        /// </summary>
        private DoubleComparaison _Comparaison;

        /// <summary>
        /// la propriété ciblée de la comparaison
        /// </summary>
        public DoubleComparaison Comparaison
        {
            get { return _Comparaison; }
            set { _Comparaison = value; }
        }
        private string _Property;

        /// <summary>
        /// la valeur de comparaison de la propriété ciblée
        /// </summary>
        public string Property
        {
            get { return _Property; }
            set { _Property = value; }
        }
        private Double _Value;

        public Double Value
        {
            get { return _Value; }
            set { _Value = value; }
        }
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public DoublePredicateHelper()
        { }
        /// <summary>
        /// Constructeur
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public DoublePredicateHelper(DoubleComparaison Comparaison, string Property, Double Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// méthode permettant d'affecter rapidement les valeurs aux propriétés de la classe,
        /// le but étant la réutilisation d'une instance de la classe sans réinstanciation
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public void SetProperties(DoubleComparaison Comparaison, string Property, Double Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// compare la valeur courante de l'objet passé à la valeur définie pour un type de comparaison
        /// </summary>
        /// <param name="obj">l'objet reçu</param>
        /// <returns>vrai ou faux</returns>
        public bool Predicate(object obj)
        {
            bool result = false;
            Nullable<Double> CurrentPropertyValue = (Nullable<Double>)PredicateUtils.GetValue(obj, Property);
            switch (Comparaison)
            {
                case DoubleComparaison.Equals:
                    result = CurrentPropertyValue.Equals(Value);
                    break;
                case DoubleComparaison.inf:
                    if (CurrentPropertyValue < Value)
                        result = true;
                    break;
                case DoubleComparaison.Sup:
                    if (CurrentPropertyValue > Value)
                        result = true;
                    break;
            }

            return result;
        }

    }
    /// <summary>
    /// permet de gérer les prédicats pour les propriétés de type DateTime
    /// </summary>
    public class DateTimePredicateHelper
    {
        /// <summary>
        /// la comparaison
        /// </summary>
        private DateTimeComparaison _Comparaison;

        /// <summary>
        /// la propriété ciblée de la comparaison
        /// </summary>
        public DateTimeComparaison Comparaison
        {
            get { return _Comparaison; }
            set { _Comparaison = value; }
        }
        private string _Property;

        /// <summary>
        /// la valeur de comparaison de la propriété ciblée
        /// </summary>
        public string Property
        {
            get { return _Property; }
            set { _Property = value; }
        }
        private DateTime _Value;

        /// <summary>
        /// la valeur de comparaison de la propriété ciblée
        /// </summary>
        public DateTime Value
        {
            get { return _Value; }
            set { _Value = value; }
        }
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public DateTimePredicateHelper()
        { }
        /// <summary>
        /// Constructeur
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public DateTimePredicateHelper(DateTimeComparaison Comparaison, string Property, DateTime Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// méthode permettant d'affecter rapidement les valeurs aux propriétés de la classe,
        /// le but étant la réutilisation d'une instance de la classe sans réinstanciation
        /// </summary>
        /// <param name="Comparaison">la comparaison à effectuer</param>
        /// <param name="Property">la propriété ciblée</param>
        /// <param name="Value">la valeur de comparaison</param>
        public void SetProperties(DateTimeComparaison Comparaison, string Property, DateTime Value)
        {
            this.Comparaison = Comparaison;
            this.Property = Property;
            this.Value = Value;
        }
        /// <summary>
        /// compare la valeur courante de l'objet passé à la valeur définie pour un type de comparaison
        /// </summary>
        /// <param name="obj">l'objet reçu</param>
        /// <returns>vrai ou faux</returns>
        public bool Predicate(object obj)
        {
            bool result = false;
            Nullable<DateTime> CurrentPropertyValue = (Nullable<DateTime>)PredicateUtils.GetValue(obj,Property);

            switch (Comparaison)
            {
                case DateTimeComparaison.Equals:
                    result = CurrentPropertyValue.Equals(Value);
                    break;
                case DateTimeComparaison.inf:
                    if (CurrentPropertyValue < Value)
                        result = true;
                    break;
                case DateTimeComparaison.Sup:
                    if (CurrentPropertyValue > Value)
                        result = true;
                    break;
            }

            return result;
        }

    }
    /// <summary>
    /// classe contenant des méthodes utiles pour les classes d'aide aux predicats static 
    /// </summary>
    public class PredicateUtils
    {
        /// <summary>
        /// retourne la valeur de la propriété
        /// </summary>
        /// <param name="obj">le type</param>
        /// <param name="Property">la propriété dont la valeur doit être extraite</param>
        /// <returns>la valeur de la propriété ou null</returns>
        public static object GetValue(object obj,string Property)
        {
            return obj.GetType().GetProperty(Property).GetValue(obj, null);
        }
    }
    /// <summary>
    /// Types de comparaisons disponibles pour la classe d'aide aux predicats string
    /// </summary>
    public enum stringComparaison
    {
        Contains,
        EndWith,
        Equals,
        Length,
        StartsWith
    }
    /// <summary>
    /// Types de comparaisons disponibles pour la classe d'aide aux predicats int
    /// </summary>
    public enum intComparaison
    {
        Equals,
        Sup,
        inf
    }
    /// <summary>
    /// Types de comparaisons disponibles pour la classe d'aide aux predicats Double
    /// </summary>
    public enum DoubleComparaison
    {
        Equals,
        Sup,
        inf
    }
    /// <summary>
    /// Types de comparaisons disponibles pour la classe d'aide aux predicats DateTime
    /// </summary>
    public enum DateTimeComparaison
    {
        Equals,
        Sup,
        inf
    }

}

Conclusion :


Bon cette fois l'ensemble arrive normalement à son terme même si je ne suis pas satisfait par le manque de généricité (4 classes - 1 par type) .
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (romagny13)