Indexer une liste d'objets

Signaler
Messages postés
403
Date d'inscription
vendredi 28 octobre 2005
Statut
Membre
Dernière intervention
31 août 2008
-
Messages postés
403
Date d'inscription
vendredi 28 octobre 2005
Statut
Membre
Dernière intervention
31 août 2008
-
Bonjour,

Je cherche une manière simple d'indexer une liste d'objets selon certaines propriétés de ces objets. Actuellement, à chaque fois que je veux indexer sur un propriété, je construit un dictionnary<type de ma propriété index, type de mon objet>. Mais je suis obligé de créer un dictionnary pour chaque propriété-index. Je voulais donc savoir si il existe une manière plus simple de procéder ?

merci d'avance pour vos conseils.

Mathmax

9 réponses

Messages postés
1024
Date d'inscription
mardi 4 février 2003
Statut
Membre
Dernière intervention
7 juin 2010
64
Hello,

Si tu travailles en 2.0, tu peux utiliser la méthode Findall des List, ou même des tableaux.

Un peu de doc ici : http://msdn2.microsoft.com/fr-fr/library/fh1w7y8z(vs.80).aspx

C'est très souple, car tu n'as cas désigner un delegate valide pour ta recherche.

Par contre, il doit parcourir toute la liste pour trouver les éléments correspondants, donc tu perdra un peu en efficacité, mais tu gagneras en espace mémoire par rapport au multiples dictionnary. A toi de voir en fonction de ce que tu fais ce qui est le plus efficace.

Amicalement, SharpMao
Messages postés
2671
Date d'inscription
vendredi 25 janvier 2002
Statut
Membre
Dernière intervention
6 février 2013
2
Jette donc un oeil du coté des collections.

Shell
Messages postés
403
Date d'inscription
vendredi 28 octobre 2005
Statut
Membre
Dernière intervention
31 août 2008

Merci SharpMao, je connaissais Findall, mais je recherche quelque chose qui fait des recherches dichotomiques sur les propriété des mes objets.

DeAtHCrAsH, je ne vois pas trop ce que tu veux dire. Je cherche un moyen de définir des indexeurs pour une collection,
qui ne parcourent pas toutes les propriétés avant de renvoyer l'objet
voulu. Connais-tu un moyen plus efficace que de créer un dictionary pour chaque indexeur ?

Mathmax
Messages postés
1024
Date d'inscription
mardi 4 février 2003
Statut
Membre
Dernière intervention
7 juin 2010
64
Alors, désolé, mais personnellement je ne vois pas de meilleure solution que les dictionnary.

Mais je suis loin d'avoir la science absolue en .Net.

Amicalement, SharpMao
Messages postés
1160
Date d'inscription
vendredi 23 juillet 2004
Statut
Membre
Dernière intervention
21 octobre 2010
18
les hastables sont une sorte de liste de dictionnary. Ca te simplifie grandement et l'écriture, et les recherches...
Messages postés
403
Date d'inscription
vendredi 28 octobre 2005
Statut
Membre
Dernière intervention
31 août 2008

Les Hashtable sont identiques aux Dictionary sauf qu'elles ne sont pas génériques non ?

Mathmax
Messages postés
1160
Date d'inscription
vendredi 23 juillet 2004
Statut
Membre
Dernière intervention
21 octobre 2010
18
Effectivement autant pour moi, j'ai cru que tu parlais de DictionaryEntry -et donc que tu réinventais la roue ^^ -(un peu a l'ouest)...
Et en effet, je ne vois pas de meilleur solution que les dictionnary. Si tes types, que ce soit clés ou valeur, sont des types référence, je ne vois pas le soucis, que ce soit en temps de traitement, simplicité du code, ou meme en terme de charge mémoire, tu fera pas beaucoup mieux (ou alors faudra sacrifier un des paramètres ci dessus ^^).
Messages postés
403
Date d'inscription
vendredi 28 octobre 2005
Statut
Membre
Dernière intervention
31 août 2008

En fait je pense qu'avec linq on aura la solution à ce problème. On pourra séléctionner dans une collection d'objet, seulement ceux dont une propriété vaut telle valeur. Par contre, en terme de performance, je ne sais pas ce qui se passe derrière une requête linq. Est-ce que les propriétés sont toutes parcourues (et donc celà revientà utiliser une boucle foreach avec un break quand on a trouvé l'objet) ou bien la recherche sera t-elle comparable à celle réalisée par un dictionary ?

Mathmax
Messages postés
403
Date d'inscription
vendredi 28 octobre 2005
Statut
Membre
Dernière intervention
31 août 2008

J'ai écrit une méthode d'extension qui permet de faire une recherche dichotomique dans une liste d'objet triée selon une propriétée. Je me damande pourquoi une telle fonction n'existe pas en natif dans le framework. Quand on a une liste très longue, pour peu qu'elle soit triée, la recherche est bien plus rapide.

Voici le code :

    public static class ListExtensions
    {
        public delegate IComparable dlgProperty<S>(S o);

        public static S Find<S>(this List<S> list, dlgProperty<S> dlg, IComparable value) where S : class
        {
            int left = 0;
            int right = list.Count;
            int middle;
            while ((middle = (int)Math.Floor((decimal)((right - left) / 2) + left))!=left)
            {
                S current = list[middle];
                switch (dlg(current).CompareTo(value))
                {
                    case (1):
                        right = middle;  
                        break;
                    case (-1):
                        left = middle;
                        break;
                    default:
                        return current;
                }
            }
            return null;
        }
    }
Et voici de quoi la tester :

    class Program
    {
        static void Main(string[] args)
        {
            List<Test> tests = new List<Test>();
            for (int i = 0; i < 9365220; i++)
                tests.Add(new Test(i.ToString()));

            Stopwatch sw = new Stopwatch( );
            sw.Reset();
            sw.Start();
            //Test test = tests.Find(y=>y.Value, "7023915");
            Test test = tests.Find(y=>y.Value == "7023915");
            sw.Stop();

            Console.WriteLine("Temps pour la recherche {0} ms",sw.ElapsedMilliseconds);
            Console.WriteLine("Valeur trouvée : {0}", test.Value);
        }
    }

    public class Test
    {
        private string _Value;

        public Test(string value)
        {
            _Value = value;
        }

        public string Value
        {
            get { return _Value; }
            set { _Value = value; }
        }
    }

    public static class ListExtensions
    {
        public delegate IComparable dlgProperty<S>(S o);

        public static S Find<S>(this List<S> list, dlgProperty<S> dlg, IComparable value) where S : class
        {
            int left = 0;
            int right = list.Count;
            int middle;
            while ((middle = (int)Math.Floor((decimal)((right - left) / 2) + left))!=left)
            {
                S current = list[middle];
                switch (dlg(current).CompareTo(value))
                {
                    case (1):
                        right = middle;  
                        break;
                    case (-1):
                        left = middle;
                        break;
                    default:
                        return current;
                }
            }
            return null;
        }
    }
   
Q'uen pensez-vous ?

Mathmax