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

Ce site au démarrage

begin process at 2012 05 27 07:09:38

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

.NET

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

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

Information sur la source

Note :
Aucune note

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é :8 964 / 278

Auteur : romagny13

Ecrire un message privé

Site perso

Ce membre participe au partage de revenus publicitaires

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-HORIZO N-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

Les Membres Club peuvent 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

GESTION DES ASSURANCE DE CLIENTS par okosa

CSHARP-WINDOWS-PHONE-7-- OPENSTACK NOVA CLIENT :: MADE BY "N... par jalel1234

CLASSE D'ENVOIE DE MAIL PAR SMTPCLIENT par wortmany

SÉRIALISATION (BINAIRE) OBJECT, IMAGE, CLASS ... par wortmany

ORIONBANQUE par toutphp

Toutes les sources de la catégorie .NET

Sources en rapport avec celle ci

GENERIC NULLABLE TYPE par TheOnlyMaX

SCRIPTS DE PILOTAGE REFLECTION 8 par Renfield

RS232 USER CONTROL par DIMUSERS

[XML] SERIALISER UN DICTIONARY GÉNÉRIQUE par TheOnlyMaX

PREPAREDFORMAT par Warny

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

Nos sponsors

Derniers Blogs

IMAGINE CUP 2012, MAKE A SIGN EN FINALE par junarnoalg

KINECT 1.5 IS OUT ! par Vko

LES ACTUALITéS DE LA SEMAINE SUR C2I.FR (14 MAI - 20 MAI) par richardc

REACTIVE EXTENSIONS : CONSOMMER DES SERVICES AVEC RX PARTIE 3, LES PIèGES à éVITER par Groc

SHAREPOINT BLOG SITE, PROBLèME D'ARCHIVES par junarnoalg

Forum

RE : TRACER COURBE SINUSOIDALE C# ET CRYSTAL REPORT par amoulbou6

RE : UPDATE EN MODE DéCONNECTé par NHenry

RE : SUPPRIMER UN ENREGISTREMENT par okosa

UPDATE EN MODE DéCONNECTé par pinkettee

LINQ par okosa

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Realisation d-une version 2 d-un site e-commerce existant sous prestashop-REPUBLICATION
Budget : 5 000€
Recherche Infogerance Serveur Debian Linux
Budget : 1 800€
Creation d-un site vitrine avec MagentO
Budget : 2 000€

Logiciels

sDEVIS-FACTURES vlPRO (8.1.0.3)
SDEVIS-FACTURES VLPRO (8.1.0.3)

sDEVIS-FACTURES vlPRO a été mis au point pour les particuliers, créateurs, entrepreneurs, artisa...

Cliquez pour télécharger sDEVIS-FACTURES vlPRO
974 Application Server (12.2.4.6)
974 APPLICATION SERVER (12.2.4.6)

Développez de puissantes applications dans un environnement de 'cloud computing', clusterisé, séc...

Cliquez pour télécharger 974 Application Server
vPicture (1.4.2.1)
VPICTURE (1.4.2.1)

Avec vPicture, hébergez vos images facilement et rapidement. vPicture est un utilitaire simple, ...

Cliquez pour télécharger vPicture
Easy-Planning (2.2.1.6)
EASY-PLANNING (2.2.1.6)

Easy-Planning permet de créer des plannings sous la représentation de diagrammes et est adapté au...

Cliquez pour télécharger Easy-Planning
COM-BACKUP (2.0)
COM-BACKUP (2.0)

COM-BACKUP est un logiciel de sauvegarde qui permet de planifier les sauvegardes de vos dossiers ...

Cliquez pour télécharger COM-BACKUP