Discussion :

[Neitsa]

Bonjour,

Je cherche un moyen de retourner à l'utilisateur d'une bibliothèque une collection qui ne puisse pas être modifiée en taille (pas de Add() ni Remove() par exemple) mais dont les données puissent être modifiée.

Problème en profondeur :

J'écris en ce moment une bibliothèque pour lire/écrire des fichiers binaires normés (chaque champs a sa place propre et est documenté).

Imaginons que le fichier binaire commence (en-tête du fichier) par 5 shorts (System.Int16), je crée un BinaryReader et je met mes 5 shorts dans un conteneur de type List<short>.

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public class EnTete
{
     // membre privé
     private List<short> m_list;
 
     // propriété
     public ??? Header { get { return m_list.??? ; } }
 
     //ctor
     // [...] initialisation de m_list et lecture de 5 shorts [ m_list.Add() ]
}

Ce que j'aimerais c'est trouver un conteneur (ou autre chose) que je puisse retourner à l'utilisateur et qui lui permette de modifier les shorts compris dans le membre m_list, mais qu'il ne soit pas possible de modifier la taille de m_list.

Quel serait le meilleur moyen de parvenir à ce résultat selon vous ? (quitte à utiliser autre chose qu'un conteneur de type List<T>)

Je vous remercie !

P.S : je travaille en C# avec le framework 3.0

[_skip]

Ca va te paraitre con mais il suffirait de retourner un simple tableau [].

[Neitsa]

Ca va te paraitre con mais il suffirait de retourner un simple tableau [].

Ca serait effectivement une solution. J'y ai bien pensé mais j'aurais du préciser que le mieux serait une propriété indexable, plus facile d'utilisation. Hors, en retour de propriété ça n'est pas indexable [ return m_list.AsArray() ].

Tiré de "Properties should not return arrays" :

http://msdn2.microsoft.com/en-us/lib...kc(VS.80).aspx

Typically, users will not understand the negative performance implications of calling such a property. Specifically, they might use the property as an indexed property.

[maa]

Sinon, tu peux toujours te faire une classe wraper du genre :

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
 
    public class ListWraper<T>
    {
        private List<T> InternalList;
 
        public ListWraper(IEnumerable<T> en)
        {
            InternalList = new List<T>(en);
        }
 
        public T this[int index]
        {
            get { return InternalList[index]; }
            set { InternalList[index] = value; }
        }
    }

[SirJulio]

ReadOnlyCollection<> est ton amie. =)

Tu peux l'instancier depuis une List<> existante (.AsReadOnly()) ou sur un new (IList<>). Ca fournit exactement ce que Maa disait au dessus, un wrapper bati sur IList en lecture seule.

[maa]

J'y ai bien pensé mais j'aurais du préciser que le mieux serait une propriété indexable, plus facile d'utilisation. Hors, en retour de propriété ça n'est pas indexable [ return m_list.AsArray() ].

Je ne comprends pas trop ce que cela veux dire. Quelqu'un pourrait me l'expliquer ?

[Neitsa]

Hmm oui désolé, c'est confus. En fait ce que je voulais dire c'est que le fait de retourner un tableau à l'utilisateur (et que celui-ci met à jour le tableau) ne met pas à jour la list interne à la classe...

[_skip]

Dans le cas de type de donnée valeur, en effet non.

[Neitsa]

Oui effectivement le wrapper me semble une bonne option ! (je me sent bête de ne pas y avoir pensé... ).

La première solution qui me vient à l'esprit, c'est de créer ta propre implémentation de l'interface que tu veux.

J'avais tenté d'implémenter des interface de collection (IList<T> et ICollection<T> notamment), mais ce qui me gênais c'est le fait de lancer une exception (NotImplementedException) sur certaines méthodes. Même si on les documentent, elles reste (les méthodes/propriétés "prohibées") disponibles.

ReadOnlyCollection<> est ton amie. =)

J'ai essayé, mais c'est ReadOnly dans tout les sens du terme... (pas moyen de modifier le contenu même de la collection).

Je vais faire des tests mais l'option "wrapping" me semble très bien.

Merci pour vos réponses. Si je bloque je reviendrais à la charge

[DonkeyMaster]

La première solution qui me vient à l'esprit, c'est de créer ta propre implémentation de l'interface que tu veux (on va dire que c'est une IList).

Tiens, je te donne le début :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class MaListe<T> : IList<T>
{
    private List<T> _liste_interne;
 
    public MaListe () {
        _liste_interne = new List<T>();
    }
 
 
    public int IndexOf (T item) {
        return _liste_interne.IndexOf(item);
    }
}

et puis, quand on arrive à Add et Remove

Code :

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

1
2
3
4
5
6
7
public void Add (T item) {
    throw new Exception( "Opération illégale" );
}
 
public void Clear () {
    throw new Exception( "Opération illégale" );
}

et ainsi de suite... (Insert, RemoveAt, mais tu tomberas bien dessus au fur et à mesure).