Discussion :

[5:35pm]

Bonjour, le titre n'est peut être pas très explicite,
j'ai un tableau: Property[] properties.
J'aurais besoin de pouvoir obtenir un élément du tableau à partir d'un string, comme un Dictionnary:

Property maPropriete = properties["discriminationPositive"];

si j'ai bien compris je dois créer une collection PropertyCollection?
pouvez vous m'éclairer merci =)

[Yodabis]

Bonjour, question innocente :
es-tu obligé de partir d'un tableau?

Avec une List<Property> ou un dictionnary tu as directement plus de possibilités ...

[5:35pm]

es-tu obligé de partir d'un tableau?

justement non, pour le moment j'ai un tableau, mais j'ai l'intention d'utiliser une collection personnalisé, (PropertyCollection) notamment parce que j'aimerai que cette collection implémente des opérations sur toute les Property.

[ZaaN]

j avais un truc comme ca pour acceder un tableau de ce style.

Code :

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

protected myType[,] myArray;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public myType this[uint _uiRow, uint _uiLine]
        {
            set
            {
               //verifier index
                   //verifier le nouvel elem
                       //renregistrer le nouvel elem
            }
            get
            {
                //verifier index
                     //retourner l elem
            }
        }

[5:35pm]

ok j'ai trouvé, je dois dériver PropertyCollection de DictionaryBase.

[Yodabis]

Ok, moi je ferais :

List<Property> properties = new List<Property>();

et appliquer une méthode à ts les items via

foreach(Property p in properties)
Méthode(p);

je peux faire un find avec
Property myP =
properties.Find(delegate(Property p)
{ return p.StringId == "discriminationPositive"; }

[5:35pm]

Ok, moi je ferais :

List<Property> properties = new List<Property>();

et appliquer une méthode à ts les items via

foreach(Property p in properties)
Méthode(p);

je peux faire un find avec
Property myP =
properties.Find(delegate(Property p)
{ return p.StringId == "discriminationPositive"; }

oui, je connais bien ça.
mais en faisant comme ça, d'une part ce n'est pas un conteneur associatif (et faudra systematiquement iterer pour trouver un élément ou faire un predicate et utiliser find), d'autre part toute les opérations de groupe sont a l'extérieur de la collection.

Mais j'ai trouvé encore mieux que DictionaryBase (qui n'est pas générique).
c'est l'interface IDictionnary<key,value>, ce qui donne:

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
    public class PropertyCollection : IDictionary<string,AbstractProperty>
    {
 
        #region IDictionary<string,AbstractProperty> Membres
 
 
        public bool ContainsKey(string key)
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        ICollection<string> IDictionary<string, AbstractProperty>.Keys
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }
 
        public bool Remove(string key)
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        public bool TryGetValue(string key, out AbstractProperty value)
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        public ICollection<AbstractProperty> Values
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }
 
        #endregion
 
        #region ICollection<KeyValuePair<string,AbstractProperty>> Membres
 
        public void Add(KeyValuePair<string, AbstractProperty> item)
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        public bool Contains(KeyValuePair<string, AbstractProperty> item)
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        public void CopyTo(KeyValuePair<string, AbstractProperty>[] array, int arrayIndex)
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        public bool IsReadOnly
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }
 
        public bool Remove(KeyValuePair<string, AbstractProperty> item)
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        #endregion
 
        #region IEnumerable<KeyValuePair<string,AbstractProperty>> Membres
 
        public new IEnumerator<KeyValuePair<string, AbstractProperty>> GetEnumerator()
        {
            throw new Exception("The method or operation is not implemented.");
        }
 
        #endregion
    }

[5:35pm]

Quoi que finalement DictionnaryBase est pas plus mal:

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
22
23
24
25
26
27
28
29
 
    public class PropertyCollection : DictionaryBase
    {
        public AbstractProperty this[string key]
        {
            get { return (AbstractProperty)this.Dictionary[key]; }
 
            set { this.Dictionary[key] = value; }
        }
        //add a phone number based on key 
 
        public void Add(string key, AbstractProperty property)
        {
            this.Dictionary.Add(key, property);
        }
        //see if collection contains an entry corresponding to key
 
        public bool Contains(string key)
        {
            return this.Dictionary.Contains(key);
        }
 
        //we will get to this later
 
        public ICollection Keys
        {
            get { return this.Dictionary.Keys; }
        }
    }

cette solution est seulement casse couille pour les foreach...
mmm je me tate...

[Yodabis]

Et une HashTable ?

[Guulh]

Et un Dictionary<TKey, TValue> ?

[5:35pm]

pas essayé, mais je tiens la solution, la vrai, la simple, la performante:

Code :

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

1
2
3
4
5
6
 
 
    public class PropertyCollection : System.Collections.Generic.SortedDictionary<string, AbstractProperty>
    {
         //opérations de sur les properties
    }

j'ai pas trouvé le bouton "doublement résolu"

[5:35pm]

Et un Dictionary<TKey, TValue> ?

bien vu =)
c'était pourtant évident non?