Discussion :

[mister3957]

Bonjour,

Je suis en train d'implémenter un système de Property:

Voici la classe de base.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
    abstract class IProperty<T>
    {
        public void SetValue(T oValue)
        {
            m_tValue = oValue;
        }
 
        public T GetValue()
        {
            return m_tValue;
        }
 
        public abstract void FromString(string s);
 
        private T m_tValue;
    }

Voici une propriété de date:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
    class EdiDate : IProperty<DateTime>
    {
        public override void FromString(string s)
        {
            SetValue(DateTime.Parse(s));
        }
    }

Voici une propriété de string:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
    class EdiString : IProperty<string>
    {
        public override void FromString(string s)
        {
            SetValue(s);
        }
    }

Maintenant, j'aimerai avoir une liste de Property, mais je ne peux pas faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
private List<IProperty> m_oList;

J'ai pas trop envie de faire des listes de date ou de string, mais une liste rassemblant toutes les propriétés...

Il y a une solution à ce genre de problème?

Merci beaucoup,

A bientôt

[Sphax]

Salut,

Tu peux toujours faire une List<object> pour stocker tes propriétés, c'est pas fortement typé mais c'est privé, ensuite tu fais des accesseurs publiques (éventuellement génériques aussi) qui renvoient uniquement un certain type de propriété. Par exemple une méthode :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
   public List<IProperty<T>> GetProperties<T>();

Que tu utilises comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
   List<IProperty<string>> StringProperties = MonObjet.GetProperties<string>();

Je ne vois pas ce que tu peux faire d'autre vu ques tes différentes propriétés n'ont rien en commun à par le fait d'être des objets : IProperty<int> n'est pas une IProperty<string> , rien de commun si ce n'est des noms de méthodes (mais signature différente, aucune interface commune, ce sont juste deux instances d'un même template).

[mister3957]

Mouais... pas très flexible .NET.

Finalement j'ai fait une IPropertyBase qui possède la méthode public abstract void FromString(string s); et en dessous la IProperty<T>.

Je pense également que je vais faire des évènnements à la C++ (avec une interface d'écoute et une liste d'écouteur à notifier) car avec les évènnements .NET, on peut pas en déclencher un d'une classe de base depuis une classe fille.

Merci quand même

[Sphax]

Mouais... pas très flexible .NET.

Tu souhaitais pouvoir avoir une liste unique, je te propose de faire une liste d'objets, est ce que ça ne te convient pas et pourquoi ? Sinon tu aurais voulu pouvoir faire quoi exactement ?

Finalement j'ai fait une IPropertyBase qui possède la méthode public abstract void FromString(string s); et en dessous la IProperty<T>.

Oui plutot que de faire une liste d'object tu peux alors faire une liste de IPropertyBase s'il y a un comportement réellement commun. Cela dit si qqun veut récupérer une propriété particulière avec un type particulier il te faut bien une solution, ma fonction générique te convient ?

Je pense également que je vais faire des évènnements à la C++ (avec une interface d'écoute et une liste d'écouteur à notifier) car avec les évènnements .NET, on peut pas en déclencher un d'une classe de base depuis une classe fille.

Tu trouveras ici le moyen propre de déclancher un évenement d'une classe de base depuis une classe dérivée. Rien de réellement impossible, seulement .net force l'encapsulation en qque sorte.

[mister3957]

Dans ton exemple, comment à partir d'une List<object> je peux récupérer les List<IProperty<T>> à part devoir entretenir un switch qui teste le type de chaque objet (pour remplir le retour) dans la liste au fur et à mesure que l'application évoluera?

Je voulais une liste unique pour pouvoir renvoyer tous les objets contenus, se brancher à leur évènnement de modification et leurs définir une valeur via une chaîne de caractère de manière indépendante de leur type mais également positionner/récupérer une valeur dans leur type (c'est pour faire un système de chargement/sauvegarde via des chaîne de caractère en gardant l'aide du compilo pour l'utilisation du développeur.).
Réclamer une liste par type géré ne me convient pas, je voudrais en rajouter un sans avoir à modifier les appelants.

Oui elles ont des comportements communs mais je voulais quand même garder le typage dans les Set/Get Value pour utiliser la compilation en guise de vérificateur de cohérence et limiter au maximum les erreurs de l'utilisateur de cette librairie.

Je vais regarder en détail le fonctionnement de ces évennements dès demain (je ne connais qu'une méthode actuellement) et je vais tenter de mixer ça pour sortir quelque chose de correct.

Je te tiens au courant,

Merci beaucoup

A bientôt

[Sphax]

Dans ton exemple, comment à partir d'une List<object> je peux récupérer les List<IProperty<T>> à part devoir entretenir un switch qui teste le type de chaque objet (pour remplir le retour) dans la liste au fur et à mesure que l'application évoluera?

Pas besoin de switch il suffit de se baser sur l'égalité des types, une implémentation par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
class MaClasseAvecDesProp
{
   private List<object> _ListeProps;
 
   public List<IProperty<T>> GetProps<T>()
   {
      List<IProperty<T>> Result = new List<IProperty<T>>();
      foreach(object Prop in _ListeProps)
      {
         //attention ici il y a peut être une subtilité
         //il faut peut être plutôt demander si Prop implémente l'interface IProperty<T>
         if(Prop.GetType() == typeof(IProperty<T>))
         {
            Result.Add((IProperty<T>)Prop);
         }
      }
 
      return Result;
   }
}

Te permet d'avoir des propriétés d'un nouveau type sans rien changer à la méthode.

Je voulais une liste unique pour pouvoir renvoyer tous les objets contenus, se brancher à leur évènnement de modification et leurs définir une valeur via une chaîne de caractère de manière indépendante de leur type

Tu peux définir l'évenement et une méthode pour lever l'évenement au niveau de ton interface comme pour ta méthode FromString.

mais également positionner/récupérer une valeur dans leur type (c'est pour faire un système de chargement/sauvegarde via des chaîne de caractère en gardant l'aide du compilo pour l'utilisation du développeur.).

La je suis pas sûr de comprendre. Si tu veux récupérer leur valeur sous forme de chaine alors ton interface de base IPropertyBase convient trés bien. Par contre si tu veux pouvoir récupérer leur valeur correctement typée alors tu ne peux pas le faire sans connaitre leur vrai type. Tu ne peux pas avoir le beurre et l'argent du beurre en qque sorte...

Réclamer une liste par type géré ne me convient pas, je voudrais en rajouter un sans avoir à modifier les appelants. Oui elles ont des comportements communs mais je voulais quand même garder le typage dans les Set/Get Value pour utiliser la compilation en guise de vérificateur de cohérence et limiter au maximum les erreurs de l'utilisateur de cette librairie.

Tu voudrais pouvoir ajouter quoi, un nouveau type de propriété ? Si c'est ça je ne vois pas pourquoi tu devrais changer les appelants. Pour ajouter une propriété dans la liste des propriétés de ta classe conteneur il te suffit d'une seule méthode Add , de la même façon que pour ma méthode GetProps<T>.
Si par contre ce que tu veux dire c'est que'un appelant puisse traiter une seule liste de Property et pouvoir récupérer les valeurs fortement typées sur chacune de ces 'Property' , il faut bien de tte façon que l'appelant soit au courant du vrai type, on revient à l'histoire du beurre... Je suis pas sûr d'etre trés clair .