CodeS-SourceS est hébergé par Frontier.fr

Cliquez ici pour mettre ce site au démarrage de votre navigateur

AccueilCodesTutorielsForumsEmploiLivresGuide achatConnexion

begin process at 2009 07 05 05:02:33

SILVERLIGHT 3 : COMMUNICATION ET MULTICAST par KooKiz

[PERSO] DéCOUVERTES ESTIVALES : LINUX (PART I) par FREMYCOMPANY

[REFACTORING] RESHARPER POUR VISUAL STUDIO 2010 (PREVIEW) par tja

[REFACTORING] ANALYSER VOS EXCEPTIONS AVEC RESHARPER EXCEPTIONAL par tja

SHAREPOINT 2007 : PATTERNS & PRACTICES SHAREPOINT GUIDANCE par phil

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par spilz

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par casy

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par spilz

RE : UN CONSTRUCTEUR APPELLE UN AUTRE CONSTRUCTEUR DE LA MêME CLASS... par Robert33

MIGRATION BASE DE DONNéES par abouselma

+ de logiciels à télécharger

1 464 546 membres
54 nouveaux aujourd'hui
15 045 membres club

Trouver une ressource

Trouvez une ressource parmi 40 096 codes, 1 302 921 messages d'aide etc...

Recherche: dans [ Dernières recherches ]

Filtre:Tous les codes.NET uniquementExclure .NET

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

[.NET 2.0] - CLASSE POUR GÉRER FACILEMENT LES PREDICATE POUR LES GENERICS + CLASSE SERIALIZATION - DESERIALIZATION XML GENERIQUE

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é: 6 222 / 228

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

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

REPOSITORY GENERATOR (FOR ENTERPRISE LIBRARY)

[ CS2GEN ] - GENERATEUR DE CODE NTIERS POUR BASES DE DONNÉE...

[.NET 3.0] OPENXML MANAGER - CHARGEMENT ET EDITION/SAUVEGAR...

CS2GENLINQTOXML - XML + XPATH VISUALIZER + LINQ TO XML GENE...

[.NET 2.0 ] PERSONNALISER LES COLONNES D'UN DATAGRIDVIEW

Toutes les sources de romagny13

Sources de la même categorie

ABSTRACT FACTORY par stevchen

COM INTEROP AVEC INTERNET EXPLORER (SHDOCVW, MSHTML) EN C# par didiermeo

GESTION DES PROPRIÉTÉS DE CLASSES par edurand1

ARBRE (TREE) - STRUCTURES D'ARBRES GÉNÉRIQUES par ricklekebekoi

C# REMPLACEMENT CARACTÈRES SPÉCIAUX FICHIER XML par kiterie

Toutes les sources de la catégorie .NET

Sources en rapport avec celle ci

EVENTHANDLERS GÉNÉRIQUES par ricklekebekoi

COMPILATION ET RÉFLECTION par thiosyiasar

REFLECTION .NET par Yxion

DBMAP - AUTOGÉNÉRER DES REQUETTES MULTIBASES par Dargos

CODES POSTAUX BELGIQUE par CrocoRICo

Commentaires et avis

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 dans le forum

Serialization Soap [ par zaka48 ] j'ai un probleme avec la declaration de l'esapce de nom using System.Runtime.Serialization;using System.Runtime.Serialization.Formatters.Soap;c'est ce Reflection [ par MorpionMx ] Bonsoir a tous Voila, j'ai une dll qui implémente plusieurs méthodes static qui effectuent un traitement sur une image passée en param System.Reflection? [ par Olympe18 ] Bonjour,Je suis encore un débutant en C# et je fais face à un petit problème. La solution est sans doute simple, mais pour l'instant, j Type, string et reflection [ par bigflo93 ]  Salut à tous :)Je suis en pleine reflection en ce moment :) et je cherche à instancier une classe à partir d'une string.Enfin, pl Reflection DLL [ par RM50Man ] Voila le code ou j utilise la reflection pour appeler une méthode static dans ma DLL Assembly asm = Assembly.LoadFrom("PremiereDLL.dll"); Type[] DLL reflection [ par RM50Man ] Pour utiliser une dll est ce qu on est toujours d utiliser la reflection!!!!RM50man Serialization sélective dans un formulaire [ par Padkartiai ] Bonjour,Sauriez-vous s'il est possible de faire une sérialisation sélective dans un formulaire windows ?Je souhaite uniquement conserver la Reflection, structure et type de base [ par bigflo93 ] Salut à tous :) Voilà, dans mon programme j'utilise la réflection. J'ai besoin de différencier les "ValueType" et type réfer Instancier une classe par la Reflection: pb de constructeur. [ par bigflo93 ] Bonjour à tous :)Voilà, je fait un programme utilisant la réflection.Je voudrais instancier un objet dynamiquement. Donc je fais:object [C#] SOAP & Serialization [ par scoubidou944 ] mon code marche enfin à moitié. lors de la désérialisation, je me prend souvent SerializationException : Erreu d'analyse, aucun as