[.NET 2.0] - CLASSE POUR GÉRER FACILEMENT LES PREDICATE POUR LES GENERICS + CLASSE SERIALIZATION - DESERIALIZATION XML GENERIQUE predicate, generic, icomparer, reflection, serialization, Source N°4287

Information sur la source

Catégorie :.NET

Classé sous : predicate, generic, icomparer, reflection, serialization Niveau : Initié Date de création : 28/05/2007 Date de mise à jour : 29/05/2007 12:57:05 Vu / téléchargé: 5 044 / 197

Auteur : romagny13

Site perso

Ecrire un message privé

Ce membre participe au partage de revenus publicitaires

Note :
Aucune note

Commentaire sur cette source (2)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

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

Version Visual Basic de ce code disponible !

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
}
}

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) .

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Cs2Predicate
- Cs2Predicate.sln 925 octets
- Cs2Predicate.suo22 528 octets
- Cs2Predicate
  - ClassDiagram1.cd2 608 octets
  - Contact.cs 3 563 octets
  - Cs2Predicate.csproj 3 418 octets
  - MainForm.cs 6 302 octets
  - MainForm.Designer.cs 9 262 octets
  - MainForm.resx 5 814 octets
  - PredicateHelper.cs 15 475 octets
  - Program.cs 487 octets
  - SerializeManager.cs 1 663 octets
  - Properties
    - AssemblyInfo.cs 1 378 octets
    - Resources.Designer.cs 3 047 octets
    - Resources.resx 5 612 octets
    - Settings.Designer.cs 1 097 octets
    - Settings.settings249 octets

Télécharger le zip

Historique

29 mai 2007 00:12:00 :: . prise en charge des Nullables + ajout d'une classe de sérialization générique
29 mai 2007 00:13:10 :: .
29 mai 2007 12:57:05 :: .

Sources du même auteur

Toutes les sources de romagny13

Sources de la même categorie

Toutes les sources de la catégorie .NET

Sources en rapport avec celle ci

Commentaires

Commentaire de romagny13 le 01/06/2007 13:07:41

Bon si vous avez des idées ou recettes qui marchent mieux
car en fait les faiblesses que je vois à mon code(même si il marche et peut être déja pratique) sont :
- utilisation de la reflection (pas top notament pour récupèrer les nullables et les valeurs)
- le manque de généricité (4 classes ,1 par type)

si vous avez des idées pour améliorer cela je suis à votre écoute
+
Commentaire de Dargos le 07/06/2007 16:35:56

pour ton histoire de multitude de predicateHelper, tu devrais peut etre faire une classe generique genre
public class PredicateHelper<T>{}
ca t'eviterais de reecrire plusieurs fois la meme chose.
tu devrais peut etre implementer l'interface IComparable.. je sais pas..

sinon, pour les List<T>, dans la methode FindAll(predicate(T)) par exemple, tu peux utiliser une syntaxe comme ceci :
int valSup=10;
List<int> MyIntList = new List<int>();
foreach (int myInt in MyIntList.FindAll(delegate(int di) { return di > valSup; }))
{
Console.WriteLine(myInt.ToString());
}

ce code va tout simplement te sortir les items de ta liste qui sont >10 sans avoir à créer une fonction qui ne servirait qu'une seule fois...

;)

Ajouter un commentaire

Discussions en rapport avec ce code source

Serialization Soap par zaka48

Reflection par MorpionMx

System.Reflection? par Olympe18

Type, string et reflection par bigflo93

Reflection DLL par RM50Man

DLL reflection par RM50Man

Serialization sélective dans un formulaire par Padkartiai

Reflection, structure et type de base par bigflo93

Instancier une classe par la Reflection: pb de constructeur. par bigflo93

[C#] SOAP & Serialization par scoubidou944