Collection basée sur une autre.

Version imprimable

27/11/2007, 18h57
maa

Collection basée sur une autre.
Bonjour,

Voici un problème sur lequel je retombe souvent.

Etant donné une collection, comment créer une seconde collection dont chaque élément renvoi une expression basée sur un élément correspondant de la première collection.

La première solution qui vient à l'idée serait d'utiliser une énumération :
Code:

1 2 MaPremiereCollection.Select(y=>expression(y));
Le problème est que l'expression est réévaluée à chaque appel sur l'énumération. Si l'expression est lourde ça peut être gourmand en terme de performance. Pire, cette solution n'est pas utilisable si on renvoi dans Select() une nouvelle instance. Par exemple :
Code:

1 2 MaPremiereCollection.Select(y=>new NewObject(expression(y)));
car alors à chaque appel sur un élément de l'énumération on crée une nouvelle instance d'objet.

On pourrait alors penser faire un ToList() pour fixer cette énumération dans une collection, mais alors celle-ci sera en décalage avec la collection de base si cette dernière à été mise à jour.

Ce que je pensais ensuite faire, c'est synchroniser la première collection et la seconde avec des événements, mais cela est fastidieux à mettre en place à chaque fois...

Auriez-vous une solution/un pattern pour ce problème ?

merci d'avance.

mathmax
28/11/2007, 09h49
Guulh

Salut,

en gros, à partir de ta liste de xi, tu veux avoir un accès facile à une liste de f(xi).
Plutôt que faire une seconde liste contenant tous les éléments de la première transformés, pourquoi ne pas faire une liste qui n'applique ta fonction f que quand c'est nécessaire ? C'est à ta dire, tant qu'on a pas fait NewList[i], tu n'appliques pas f au i-ième élément de la liste d'origine.
Après, tu peux rajouter du cache dans cette liste si besoin.

Tu as vu la BindingListView ? C'est ce qui est fait dedans, il me semble. Et puis, les sources du Framework étant (ou bientôt) dispo, tu pourras voir comment la DataView fonctionne :)
28/11/2007, 13h13
Bluedeep

Citation:

Envoyé par Guulh

Et puis, les sources du Framework étant (ou bientôt) dispo, tu pourras voir comment la DataView fonctionne :)

Bof .... avec Reflector ça se fait très bien :D
28/11/2007, 13h51
SaumonAgile

Citation:

Envoyé par Bluedeep

Bof .... avec Reflector ça se fait très bien :D

Oui mais attention à la propriété intellectuelle. D'ailleurs open source ou pas, la propriété intellectuelle s'appliquera toujours. Prudence.
28/11/2007, 14h05
maa

Citation:

en gros, à partir de ta liste de xi, tu veux avoir un accès facile à une liste de f(xi).
Plutôt que faire une seconde liste contenant tous les éléments de la première transformés, pourquoi ne pas faire une liste qui n'applique ta fonction f que quand c'est nécessaire ? C'est à ta dire, tant qu'on a pas fait NewList[i], tu n'appliques pas f au i-ième élément de la liste d'origine.

C'est exactement ce que je voudrais. :D SI tu dis que la BindingListView fait cela, c'est cool. Je n'ai malheureusement pas trouvé comment faire avec l'implémentation que j'ai. J'utilise cette BindingListView . Peut-être en utilises-tu une autre ? Ou peut-être que c'est possible à faire avec celle que j'ai ? Quelles méthodes/propriétés utilises-tu dans ce cas ?
28/11/2007, 14h35
Guulh

Citation:

Envoyé par maa

C'est exactement ce que je voudrais. :D SI tu dis que la BindingListView fait cela, c'est cool. Je n'ai malheureusement pas trouvé comment faire avec l'implémentation que j'ai. J'utilise cette BindingListView . Peut-être en utilises-tu une autre ? Ou peut-être que c'est possible à faire avec celle que j'ai ? Quelles méthodes/propriétés utilises-tu dans ce cas ?

J'utilise celle-là, c'est moi qui t'avais filé le lien il y a quelques semaines :) La BLW encapsule chaque objet de sa source dans un ObjectView<T>, qui n'est créé que si nécessaire. Tu peux t'en inspirer.

@SaumonAgile : le but est pas de piquer le code de Crosoft, hein :) Juste que cette bande de zigotos a pas cru bon d'implémenter un équivalent de la DataView pour les collections classiques, c'est pourquoi ce cher maa essaie depuis un certain temps maintenant de le faire.
28/11/2007, 14h49
maa

Citation:

J'utilise celle-là, c'est moi qui t'avais filé le lien il y a quelques semaines

Oui en effet. Merci beaucoup d'ailleurs. :)

Citation:

La BLW encapsule chaque objet de sa source dans un ObjectView<T>, qui n'est créé que si nécessaire. Tu peux t'en inspirer.

Là je vois pas trop comment cela pourrait m'aider. J'ai un moyen de contrôler comment cet ObjectView est crée (je veux dire sans modifier le code) ? Et comment puis-je créer un nouvel objet se basant sur un objet de la collection d'origine.
Par exemple, j'ai une collection de Product. Je veux que ma BindingListView reflète une collection de ProductWraper, un ProductWraper s'obtenant en faisant new ProductWraper(productAssocié). Comment faire cela ?
Si tu m'aide à résoudre ce problème alors je fais un grand pas en avant. Comme tu l'as dit, cela fait un moment que je rencontre des problèmes autour de ce sujet...

J'ai des problèmes très similaires au tien. Pour l'instant, je fais :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 BindingList<Product> source; BindingList<ProductWrapper> wrappedSource; // avec abonnement à l'event ListChanged de la précédente : private void OnSourceChanged(object sender, ListChangedEventArgs e) { switch (e.ListChangedType) { case ListChangedType.ItemAdded: wrappedSource.Add(new ProductWrapper((sender as ILIst<Product>)[e.NewIndex])); break; case ListChangedType.ItemDeleted: // faire un traitement approprié case ListChangedType.Reset: _wrappedSource.Clear(); foreach (Product product in (sender as IList<Product>)) _wrappedSource.Add(new ProductWrapper(product)); break; default: break; } } BindingListView<ProductWrapper>; // avec pour DataSource la précédente.
C'est moche, mais vu que ça marche et que j'ai pas insisté... (pire : mes Product encapsulent eux-même une autre classe en provenance d'un serveur...)

Ce qu'on peut envisager, c'est d'avoir une BindingListView <T,U>, avec T le type source et U le type wrappé, en spécifiant un moyen de passer de l'un à l'autre. Que ce soit un constructeur U(T t), un opérateur de conversion, etc. Au boulot ! :)

Par exemple :
Code:

1 2 3 4 abstract class Wrapper<T> { public Wrapper(T source); }
Et là, ProductWrapper hérite de Wrapper, et tu peux faire un BLW<T, U> perso avec comme contrainte U : Wrapper<T>.

Dommage que les interfaces ne puissent pas spécifier de constructeur, d'ailleurs. Doit y avoir une bonne raison qui m'échappe.

Je pars du principe que le type de base doit être indépendant, mais que par contre qu'on a entièrement la main sur le type wrapper et qu'on peut donc le faire hériter de ce qu'on veut.

[edit] Après réflexion, vu que les constructeurs ne s'héritent pas, le code ci-dessus est faux. Mais bon y'a de l'idée :aie:

Ok, c'est en gros ce que j'ai fait aussi en attendant :

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
 
    public class SynchronizedView<TBase, TView> : IEnumerable<TView> where TView : class
    {
        private BindingList<TBase> _CollectionBase;
        private List<TView> _CollectionView;
        private Func<TBase, TView> _Selector;
        private Action<TBase, TView> _Modificator;
 
        public SynchronizedView(BindingList<TBase> collectionBase, Func<TBase, TView> selector, Action<TBase, TView> modificator)
            : this(collectionBase, selector)
        {
            _Modificator = modificator;
        }
 
        public SynchronizedView(BindingList<TBase> collectionBase, Func<TBase, TView> selector)
        {
            _CollectionBase = collectionBase;
            _Selector = selector;
            _CollectionView = _CollectionBase.Select(selector).ToList();
            _CollectionBase.ListChanged += new ListChangedEventHandler(_CollectionBase_ListChanged);
        }
 
        void _CollectionBase_ListChanged(object sender, ListChangedEventArgs e)
        {
            switch (e.ListChangedType)
            {
                case (ListChangedType.ItemAdded):
                    _CollectionView.Insert(e.NewIndex, _Selector(_CollectionBase[e.NewIndex]));
                    break;
                case (ListChangedType.ItemDeleted):
                    _CollectionView.RemoveAt(e.NewIndex);
                    break;
                case(ListChangedType.Reset):
                    _CollectionView.Clear();
                case (ListChangedType.ItemChanged):
                    if (_Modificator != null)
                        _Modificator(_CollectionBase[e.NewIndex], _CollectionView[e.NewIndex]);
                    break;
            }
        }
 
 
        #region IEnumerable<TView> Members
 
        public IEnumerator<TView> GetEnumerator()
        {
            return _CollectionView.GetEnumerator();
        }
 
        #endregion
 
        #region IEnumerable Members
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return _CollectionView.GetEnumerator();
        }
 
        #endregion
    }

mais tu m'avais parlé d'une solution avec la BindingListView... ? Ne permet t-elle que de filtrer, trier, concaténer des collections existantes ? Ou peut-on préciser un transformateur ou une expression de sorte que les objectView renvoient autre chose (une expression basée sur un objet de la collection initiale ou même un nouvel objet, par exemple un wrapper) ?

28/11/2007, 17h18
Guulh

Pour parler en termes BDD, La BLW permet d'agréger n listes et de filtrer sur les lignes, mais n'agit pas sur les colonnes. Pas d'ajout, pas de modification, pas de suppression, rien. Comme la DataView, en fait.
28/11/2007, 17h27
maa

Alors je ne suis pas sûr d'avoir compris ce que tu avais dit là :

Citation:

en gros, à partir de ta liste de xi, tu veux avoir un accès facile à une liste de f(xi).
Plutôt que faire une seconde liste contenant tous les éléments de la première transformés, pourquoi ne pas faire une liste qui n'applique ta fonction f que quand c'est nécessaire ? C'est à ta dire, tant qu'on a pas fait NewList[i], tu n'appliques pas f au i-ième élément de la liste d'origine.
Après, tu peux rajouter du cache dans cette liste si besoin.

Tu as vu la BindingListView ? C'est ce qui est fait dedans, il me semble.

Je croyais que tu disais qu'on pouvait faire cela avec la BindingListView. :roll:

Sinon, il ne reste qu'à améliorer la BindingListView... 8-)
28/11/2007, 18h08
Guulh

La BLW est très générale, donc ObjectView<T> n'apporte rien en plus de T. Je voulais dire que la BLW, avec comme DataSource un IList<T>, était elle même une IList<ObjectView<T>>, et que tu pourrais la modifier pour que cet ObjectView<T> fasse ce que tu veux. Comme j'écrivais plus haut, il doit y avoir moyen de faire une BLW<TSource, TWrapped> pourvu qu'on ait un moyen de convertir l'un en l'autre.
28/11/2007, 18h58
maa

Oui c'est un peu ce que j'avais fait avec ma SynchronizedView<TBase, TView> rapidement bricolé pour les besoins du moments.
Mais c'est vrai qu'avoir une BLW bien faite et gérant un plus grand nombre de cas serait super... Qui a envie de développer ? :)