[c#] collections

[Bint]

Dag,

ik werk met visual studio .Net 2003, en heb een HashTable gebruikt om gegevens in op te slaan.
het bestaat uit een unieke key, en een value. Hierover wordt een hash berekend, en volgens de volgorde van deze hash, worden alle items opgeslagen.

Maar dat wil ik niet. Ik wil dat ik aan de hand van key mijn value kan opvragen, en dat de gegevens in volgorde van toevoegen worden opgeslagen. Maar ik zou niet weten welke collection type ik hiervoor moet gebruiken. Bij een arraylist kun je alleen op index zoeken, en bij een sortedlist wordt er op key gesorteerd. Weet iemand wat ik beter kan gebruiken?

[gorgi_19]

Gokje: System.Collections.Specialized.NameValueCollection

[ Voor 12% gewijzigd door gorgi_19 op 20-06-2006 14:05 ]

[-FoX-]

Hiervoor moet je even het contract van de verschillende Map implementaties bekijken, die kunnen je vast wel uitsluitsel geven. In Java is deze functionaliteit mogelijk door gebruik te maken van een LinkedHashMap die de insertion-order van de keys als volgorde zal garanderen.

[ Voor 13% gewijzigd door -FoX- op 20-06-2006 14:08 ]

[Not Pingu]

Bintje schreef op dinsdag 20 juni 2006 @ 13:59:

Maar dat wil ik niet. Ik wil dat ik aan de hand van key mijn value kan opvragen, en dat de gegevens in volgorde van toevoegen worden opgeslagen.

Bij mijn weten kan dat ook en gebeurt dat ook:

code:

Hashtable ht = new Hashtable();
ht.Add("bla", "content");
Response.Write(ht["bla"]);

[whoami]

Not Pingu: bij een hashtable worden de gegevens altijd in volgorde van de hash opgeslagen, en niet in de volgorde van inserten.

Bintje: je kan een eigen collection type maken dat inherit van NameObjectCollectionBase
Toch niet, want deze gebruikt intern ook een Hashtable zie ik in de help.

[ Voor 16% gewijzigd door whoami op 20-06-2006 14:17 ]

[Not Pingu]

whoami schreef op dinsdag 20 juni 2006 @ 14:15:
Not Pingu: bij een hashtable worden de gegevens altijd in volgorde van de hash opgeslagen, en niet in de volgorde van inserten.

Hm, ok. Dat wist ik niet zeker. Een alternatief is een SortedList met een custom IComparer, maar of je daar vrolijk van wordt...

[Macros]

Het is toch algemeen bekend dat Hashtables (en HashMaps) de hash van de key gebruiken om hun value op te slaan? Keys zijn uniek, de values niet, dus een hash over de values zou onzinnig zijn. Waarschijnlijk heeft .net ook wel en LinkedHashtable implementatie, als dat er niet is kan je 2 hashtables in een eigen class wrappen, waarbij de ene de key, value paren opslaat en de andere de key,insertion_number (of andersom) opslaat.

[Juicy]

SortedList is wat je zoekt:
http://www.youcanlearnser...ps/CSharp/SortedList.aspx

[whoami]

Een SortedList is ook niet de oplossing voor de TS, want, hij wil dat het item dat hij het eerste insert, ook op de eerste positie in de List blijft staan, het tweede op de tweede positie, etc....

Bij een SortedList wordt de volgorde ook bepaald door de waarde van de key.

[Not Pingu]

whoami schreef op dinsdag 20 juni 2006 @ 14:22:
Bij een SortedList wordt de volgorde ook bepaald door de waarde van de key.

Maar daar kun je een eigen IComparer schrijven die een andere manier van sorting implementeert. Ik bedenk me net wel dat je dan ook op de een of andere manier moet weten welke key als eerste werd geinsert (index?).

Ander alternatief is een array en een hashtable. In de array sla je de keys nog eens op. Als je daar doorheen loopt, krijg je de keys in volgorde van toevoegen, en kun je daarmee de value opvragen uit de hashtable. Omslachtig, maar het werkt.

[RedBeard]

Waarom maak je niet gewoon gebruik van de linked list

want als ik het goed begrijp wil je key value pairs opslaan en opvolgorde weer uitlezen

[url=http://http://www.c-sharpcorner.com/Code/2003/June/UsingLinkedListInCS.asp]zoiets dus[/url]

[Bint]

NameValueCollection: geen optie, want ik wil objecten opslaan, geen strings
SortedList: geen optie, want ik wil ze op volgorde van toevoegen kunnen binnenhalen

Ik zal nog eens naar die LinkedList kijken, misshcien dat dat een optie is..
bedankt alvast, en laat de goede ideeen maar binnen stromen

[Bint]

hmm..

ik heb de ListDictionary gevonden, maar die geeft meteen aan dat die geschikt is voor 10 items of minder. Heeft iemand hier ervaring mee?

Summary:
Implements IDictionary using a singly linked list. Recommended for collections that typically contain 10 items or less.

[ Voor 35% gewijzigd door Bint op 20-06-2006 15:03 ]

[RedBeard]

Bintje schreef op dinsdag 20 juni 2006 @ 15:03:
hmm..

ik heb de ListDictionary gevonden, maar die geeft meteen aan dat die geschikt is voor 10 items of minder. Heeft iemand hier ervaring mee?


[...]

van de msdn site leesik:

Items in a ListDictionary are not in any guaranteed order; code should not depend on the current order. The ListDictionary is implemented for fast keyed retrieval; the actual internal order of items is implementation-dependent and could change in future versions of the product.

Deze optie wordt dus heel snel traag omdat het zoeken naar een key gewoon topdown gebeurd.

De combinatie van wat jij beschrijft dus en via de key de value terug halen en opvolgorde is gewoon lastig.

Je zou kunnen denken aan twee Collections, een voor het snel vinden per key en 1 voor het uitlezen op volgorde.

Dit zou je eventueel kunnen doen door een eigen collectie aan te maken.

Maar ik snap nog steeds niet helemaal wat je wilt bereiken/wat de toepassing is.

[Bint]

Ik heb het al gevonden, denk ik:

de NameObjectCollectionBase.
DIe moet ik nog wel in een nieuwe class implementeren, maar dat komt wel goed.
bedankt voor de hulp!

[whoami]

Zoals ik al eerder gezegd heb, gebruikt NameObjectCollectionBase ook een hashtable achter de schermen....

[Verwijderd]

Heel misschien heb je hier iets aan? (heb het snel gemaakt, maar het gaat om het idee, moest toevallig pasgeleden zelf een hashmap implementatie maken)

code:

class HashTablePlus
    {
        ArrayList Pairs = new ArrayList();

        public object this[object Key]
        {
            get
            {
                int Index = GetIndexByKey(Key);
                if (Index != -1)
                    return ((Pair)Pairs[Index]).Value;
                else
                    throw new KeyNotFoundException();
            }
        }

        public IEnumerator GetEnumerator()
        {
            return Pairs.GetEnumerator();
        }

        public int Count
        {
            get
            {
                return Pairs.Count;
            }
        }

        public bool ContainsKey(object Key)
        {
            return GetIndexByKey(Key) != -1;
        }

        public bool ContainsValue(object Value)
        {
            return GetIndexByValue(Value) != -1;
        }

        public ArrayList Keys
        {
            get
            {
                ArrayList TmpReturn = new ArrayList();
                foreach (Pair ThisPair in Pairs)
                {
                    TmpReturn.Add(ThisPair.Key);
                }
                return TmpReturn;
            }
        }

        public ArrayList Values
        {
            get
            {
                ArrayList TmpReturn = new ArrayList();
                foreach (Pair ThisPair in Pairs)
                {
                    TmpReturn.Add(ThisPair.Value);
                }
                return TmpReturn;
            }
        }

        public void Remove(object Key)
        {
            int Index = GetIndexByKey(Key);
            if (Index != -1)
                Pairs.RemoveAt(Index);
            else
                throw new KeyNotFoundException();

        }

        public void Add(object Key, object Value)
        {
            if (GetIndexByKey(Key) == -1)
                Pairs.Add(new Pair(Key, Value));
            else
                throw new DuplicateKeyException();
        }

        private int GetIndexByKey(object Key)
        {
            for (int i = 0; i < Pairs.Count; i++)
            {
                if (((Pair)Pairs[i]).Key == Key)
                {
                    return i;
                }
            }
            return -1;
        }

        private int GetIndexByValue(object Value)
        {
            for (int i = 0; i < Pairs.Count; i++)
            {
                if (((Pair)Pairs[i]).Value == Value)
                {
                    return i;
                }
            }
            return -1;
        }

        class Pair
        {
            object _Key;
            object _Value;

            public Pair(object NewKey, object NewValue)
            {
                Key = NewKey;
                Value = NewValue;
            }

            public object Key
            {
                get
                {
                    return _Key;
                }
                set
                {
                    _Key = value;
                }
            }

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

        public class DuplicateKeyException : Exception
        {


        }

    }

[LoekD]

Wat is C# 2 dan gaaf he..

code:

    public class ListDictionary<T, U> : Dictionary<T, U>
    {
        private List<U> _innerList;

        public ListDictionary()
        { 
            _innerList = new List<U>();
        }

        public U this[int index]
        {
            get
            {
                return _innerList[index];
            }           
        }

        public new void Add(T key, U value)
        {
            base.Add(key, value);
            _innerList.Add(value);
        }

        public new void Clear()
        {
            base.Clear();
            _innerList.Clear();
        }
    }

Maar met wat Zoeken en Vervangen van type parameters met 'object' en/of 'string' en dictionary met hashtable, en wat casts moet het wel lukken in 1.1 ook.

[Bint]

whoami schreef op dinsdag 20 juni 2006 @ 15:57:
Zoals ik al eerder gezegd heb, gebruikt NameObjectCollectionBase ook een hashtable achter de schermen....

Ja, maar toch wordt alles in volgorde van toevoegen opgeslagen, volgens MSDN.
na een klein probeersel bleek dus ook dat het in volgorde van toevoegen opslaat, dus dat is gunstig voor mij.

[whoami]

Vreemd, dat vind ik niet direct terug in de MSDN.

[Bint]

hmm vreemd,

nu krijg ik het ook niet meer gevonden. Misschien dat ik het toch ergens anders heb gelezen dan.

Maar feit is, al mijn 750 items die ik heb opgeslagen, zijn op de goede volgorde opgeslagen.
Dit kan natuurlijk toeval zijn, maar ik vind het wel frappant.

[Coca-Cola]

Bintje schreef op woensdag 21 juni 2006 @ 10:34:
hmm vreemd,

nu krijg ik het ook niet meer gevonden. Misschien dat ik het toch ergens anders heb gelezen dan.

Maar feit is, al mijn 750 items die ik heb opgeslagen, zijn op de goede volgorde opgeslagen.
Dit kan natuurlijk toeval zijn, maar ik vind het wel frappant.

De vraag is natuurlijk of het ook zo blijft na deleten, moven, garbage collection, compiler optimalisaties (?) etc...