comment implémenter []

Version imprimable

06/06/2008, 12h11
5:35pm

comment implémenter []

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 =)
06/06/2008, 12h20
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 ...
06/06/2008, 13h21
5:35pm

Citation:

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.

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

Code:

protected myType[,] myArray;

Code:

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

06/06/2008, 13h24
5:35pm

ok j'ai trouvé, je dois dériver PropertyCollection de DictionaryBase.
06/06/2008, 13h32
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"; }

Citation:

Envoyé par 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"; }

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:

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
    }

Quoi que finalement DictionnaryBase est pas plus mal:

Code:

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

06/06/2008, 14h21
Yodabis

Et une HashTable ?
06/06/2008, 14h38
Guulh

Et un Dictionary<TKey, TValue> ?

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

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" :)

06/06/2008, 14h39
5:35pm

Citation:

Et un Dictionary<TKey, TValue> ?

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