[C#] Key value collection met dubbele keys

[4of9]

Hallo,

Ik wil graag een collectie die bestaat uit een key value pair (string,dictionary) die toestaat om dubbele keys op te slaan.

ik heb nu dit:

C#:

Dictionary<string, Dictionary<string, string>> commands = 
  new Dictionary<string, Dictionary<string, string>>();

Deze accepteerd echter geen dubbele string values en dat heb ik wel nodig.

is er een datatype waarbij dit wel mogelijk is.

Ik weet niet hoeveel waardes ik ga toevoegen dus ik kan geen array gebruiken, en eigenlijk zou ik het ook dmv generics willen doen om het typesafe te houden.

ik hoop dat jullie mij verder op weg kunnen helpen.

[MTWZZ]

Je kunt zoiets doen:

C#:

using System;
using System.Collections.Generic;

public class test {
    public static void Main(string[] args)
    {
        Dictionary<string, List<string>> collection = new Dictionary<string, List<string>>();

        collection.Add("foo", new List<string>());

        collection["foo"].Add("bar");
        collection["foo"].Add("baz");
        collection["foo"].Add("qux");
    }
}

[ Voor 14% gewijzigd door MTWZZ op 12-12-2006 11:45 ]

[4of9]

MTWZZ schreef op dinsdag 12 december 2006 @ 11:44:
Je kunt zoiets doen:

C#:

using System;
using System.Collections.Generic;

public class test {
    public static void Main(string[] args)
    {
        Dictionary<string, List<string>> collection = new Dictionary<string, List<string>>();

        collection.Add("foo", new List<string>());

        collection["foo"].Add("bar");
        collection["foo"].Add("baz");
        collection["foo"].Add("qux");
    }
}

nee dat gaat niet werken, want dan kan ik niet doen:

code:

collection.Add("foo", new List<string>());
collection.Add("foo", new List<string>());

en de structuur moet ook zijn:

Collectie[<string>,Dictionary<string,string>]

[Ruudjah]

DIT BERICHT IS PREVENTIEF VERWIJDERD DOOR DE GEBRUIKER

[ Voor 91% gewijzigd door Ruudjah op 01-12-2009 21:59 ]

[4of9]

nee dat is geen optie.

Ik moet echt dubbele keys opslaan.

[ Voor 29% gewijzigd door 4of9 op 12-12-2006 12:27 ]

[Woy]

Waarom zou je dat willen? Het idee van een Dictionary is juist dat je aan de hand van een key een value terug krijgt.
Wat verwacht je dan dat je terug krijgt als je

C#:

myDict["key"];

doet? Als er meerdere keren dezelfde key in zit weet de dictionary nooit wat je wilt doen.

Wat je eventueel kunt doen is een list van KeyValuePairs maken

C#:

List<KeyValuePair<string,Dictionary<string,string>> dict;
//of
Dictionary<string,Dictionary<string,string>> dict;

Je zou hier dan natuurlijk een class omheen kunnen bouwen die het gebruik wat makkelijker maakt.

edit:
Wat is eigenlijk precies je bedoeling? Je wilt aan de hand van een key meerdere dictionaries terug krijgen?

[ Voor 9% gewijzigd door Woy op 12-12-2006 12:31 ]

[MTWZZ]

Je kunt denk ik beter een simpele wrapper class maken voor dit probleem en Add etc overriden zodat je kun checken of een key al voorkomt en zo ja de nieuwe value toevoegen aan de List<> die bij die key hoort.
De indexer kun je dan op dezelfde manier overriden om die ook een List<> te laten returnen.

[Woy]

MTWZZ schreef op dinsdag 12 december 2006 @ 12:37:
Je kunt denk ik beter een simpele wrapper class maken voor dit probleem en Add etc overriden zodat je kun checken of een key al voorkomt en zo ja de nieuwe value toevoegen aan de List<> die bij die key hoort.
De indexer kun je dan op dezelfde manier overriden om die ook een List<> te laten returnen.

Idd dan doe je gewoon zoiets

C#:

public class MyCollection
{
    private Dictionary<string, List<Dictionary<string,string>>> dict = new Dictionary<string, List<Dictionary<string, string>>>();
    
    public void Add(string key, Dictionary<string,string> value)
    {
        if( dict.ContainsKey(key))
        {
            dict[key].Add(value);
        }
        else
        {
            List<Dictionary<string, string>> newList = new List<Dictionary<string, string>>();
            newList.Add(value);
            dict.Add(key, newList);
        }
    }
    
    public List<Dictionary<string,string>> this[string key]
    {
        get
        {
            if( !dict.ContainsKey(key))
                return null;
            return dict[key];
        }
    }
}

Het is dan nog wel handig om een aantal interfaces zoals IEnumerable te implementeren zodat je het ook in foreach loopjes en dergelijke kan gebruiken.

Maar ik vraag me toch echt af wat je er mee wilt bereiken. Mischien is er wel een veel betere oplossing voor.

[mulder]

Gewoon een dataset gebruiken?

[Verwijderd]

4of9 schreef op dinsdag 12 december 2006 @ 12:26:
Ik moet echt dubbele keys opslaan.

Ik moet de echte Mona Lisa twee keer hebben.

[Janoz]

* Janoz is ook erg benieuwd naar de reden van de dubbele key's.

[whoami]

Ik ook.
Waarom gebruik je dan eigenlijk een Dictionary / Hashtable ?

Of, ik zal het anders zeggen: als je dan dit doet:

code:

Dictionary d = theCollection["foo"];

En je hebt 2 entries voor 'foo', hoe ga je dan bepalen welke 'foo' je wil ?

[EfBe]

C#:

/// <summary>
/// Specialized hashtable which can store multiple values for a given key. All values are stored in an UniqueValueList as value. When the
/// value is requested, the UniqueValueList is returned, not the actual value. 
/// </summary>
public class MultiValueHashtable<TKey, TValue> : Dictionary<TKey, UniqueValueList<TValue>>
{
    /// <summary>
    /// Initializes a new instance of the MultiValueHashtable class.
    /// </summary>
    /// <param name="capacity">Capacity.</param>
    public MultiValueHashtable(int capacity):base(capacity)
    {
    }

    /// <summary>
    /// Initializes a new instance of the MultiValueHashtable class.
    /// </summary>
    public MultiValueHashtable():base()
    {
    }


    /// <summary>
    /// Adds an element with the specified key and value to the set.
    /// </summary>
    /// <param name="key">The key of the element to add.</param>
    /// <param name="value">The value of the element to add. If the key is already existing, the value is added to the existing list of values
    /// for that key, unless the value also already exists.</param>
    public void Add(TKey key, TValue value)
    {
        UniqueValueList<TValue> valuesStored = null;
        if(base.ContainsKey(key))
        {
            // already there.
            valuesStored = base[key];
        }
        else
        {
            // new
            valuesStored = new UniqueValueList<TValue>();
            base.Add(key, valuesStored);
        }
        valuesStored.Add(value);
    }


    /// <summary>
    /// Adds the objects as values for the specified key.
    /// </summary>
    /// <param name="key">Key.</param>
    /// <param name="values">Values.</param>
    public void Add(TKey key, ICollection<TValue> values)
    {
        UniqueValueList<TValue> valuesStored = null;
        if(base.ContainsKey(key))
        {
            // already there.
            valuesStored = base[key];
        }
        else
        {
            // new
            valuesStored = new UniqueValueList<TValue>();
            base.Add(key, valuesStored);
        }
        valuesStored.AddRange(values);
    }

    /// <summary>
    /// Determines whether the multivaluehashtable contains the key, and if so, if the list of values stored under the key contains the value specified.
    /// </summary>
    /// <param name="key">Key.</param>
    /// <param name="value">Value.</param>
    /// <returns>true if the key exists and the list of values contains the specified value</returns>
    public virtual bool Contains(TKey key, TValue value)
    {
        if(!base.ContainsKey(key))
        {
            return false;
        }

        return this[key].Contains(value);
    }


    /// <summary>
    /// Gets / sets a value for the given key. Hides original indexer
    /// </summary>
    /// <remarks>returns null if not found</remarks>
    public new UniqueValueList<TValue> this[TKey key]
    {
        get
        {
            if(!base.ContainsKey(key))
            {
                return null;
            }
            return base[key];
        }
        set
        {
            this.Add(key, value);
        }
    }
}


/// <summary>
/// ArrayList which contains solely unique values. 
/// </summary>
public class UniqueValueList<T> : Collection<T>
{
    /// <summary>
    /// Creates a new UniqueValueList instance.
    /// </summary>
    public UniqueValueList():base()
    {
    }

    /// <summary>
    /// Creates a new UniqueValueList instance.
    /// </summary>
    /// <param name="c">Collection of objects to add to this collection. It will use the </param>
    public UniqueValueList(ICollection<T> c)
    {
        foreach(T o in c)
        {
            this.Add(o);
        }
    }

    /// <summary>
    /// Adds the range specified
    /// </summary>
    /// <param name="c">Collection with new objects to add</param>
    public void AddRange(ICollection<T> c)
    {
        UniqueValueList<T> toAdd = c as UniqueValueList<T>;
        if(toAdd==null)
        {
            toAdd = new UniqueValueList<T>(c);
        }

        foreach(T o in toAdd)
        {
            this.Add(o);
        }
    }

    /// <summary>
    /// Inserts an element into the <see cref="T:System.Collections.ObjectModel.Collection`1"></see> at the specified index, if the object doesn't exist in
    /// the list yet.
    /// </summary>
    /// <param name="index">The zero-based index at which item should be inserted.</param>
    /// <param name="item">The object to insert. The value can be null for reference types.</param>
    /// <exception cref="T:System.ArgumentOutOfRangeException">index is less than zero.-or-index is greater than <see cref="P:System.Collections.ObjectModel.Collection`1.Count"></see>.</exception>
    protected override void InsertItem( int index, T item )
    {
        if( !this.Contains( item ) )
        {
            base.InsertItem( index, item );
        }
    }


    /// <summary>
    /// Replaces the element at the specified index, if the item doesn't exist in the list yet.
    /// </summary>
    /// <param name="index">The zero-based index of the element to replace.</param>
    /// <param name="item">The new value for the element at the specified index. The value can be null for reference types.</param>
    /// <exception cref="T:System.ArgumentOutOfRangeException">index is less than zero.-or-index is greater than <see cref="P:System.Collections.ObjectModel.Collection`1.Count"></see>.</exception>
    protected override void SetItem( int index, T item )
    {
        if( (IndexOf( item ) == index) || !Contains( item ) )
        {
            base.SetItem( index, item );
        }
    }
}

Wellicht moet je het hier en daar nog even aanpassen, maar het idee is dat je meerdere keren Add kunt aanroepen met dezelfde key en meerdere values, en dat die dan als meerdere values onder dezelfde key worden opgeslagen.

[DroogKloot]

C# heeft geen equivalent van de C++ std::multimap container, zelf klussen dus.

[4of9]

Verwijderd schreef op dinsdag 12 december 2006 @ 12:50:
[...]
Ik moet de echte Mona Lisa twee keer hebben.

Dank je voor deze contructieve bijdrage...

Goed ik zal proberen uit te leggen waarom ik op zoek ben naar een datastructuur waarbij ik dit nodig heb.

Ik wil een commando XML file opbouwen samen met parameters met hun values.

voorbeeld:

XML:

<commandos>
  <commando name="updatevalues">
      <parameters>
          <id type="int">1</id>
          <value type="string">piep</string>
       </parameters>
    <commando>
  <commando name="updatevalues">
      <parameters>
          <id type="int">2</id>
          <value type="string">piep2</string>
       </parameters>
    <commando>
   <commando name="getvaluesbyid">
      <parameters>
          <id type="int">14</id>
       </parameters>
    <commando>
<commandoss>

Ik weet echter niet hoeveel commando's ik ga krijgen (ik bouw dit dynamisch op).
De commando naam kan zowel hetzelfde als verschillend zijn. (Vandaar de dubbele keys)
Beschouw het maar als een contract dat afgesloten is: als ik wil updaten moet mijn xml er zo uit zien.

Ik bouw mijn commando's dynamisch op, en lees ook de parameters dynamisch uit.
Vandaar dat ik het op wil slaan als "commandonaam", parameters<string,string>

waarbij het aantal parameters ook dynamisch is.

ik hoop dat het iets duidelijker wordt

[Janoz]

In dat geval snap ik niet waarom je over keys praat. Het lijkt me veel handiger om gewoon een commando object te maken met hierin, naast de naam ook een lijst met parameters. Die commando objecten kun je dan keurig in een list stoppen.

Is volgorde ook van belang?

[whoami]

4of9 schreef op dinsdag 12 december 2006 @ 15:35:
[...]


Dank je voor deze contructieve bijdrage...

Mark Platvoet heeft daar toch echt een punt hoor; hij zegt net hetzelfde als hetgeen ik me afvraag, maar dan iets anders verwoord.

Goed ik zal proberen uit te leggen waarom ik op zoek ben naar een datastructuur waarbij ik dit nodig heb.

Ik wil een commando XML file opbouwen samen met parameters met hun values.

Zoals reeds gezegd: waarom is een Dictionary die per key een collection bevat dan niet goed genoeg ? En dat is blijkbaar net hetgeen wat de code die EfBe gepost heeft, doet.

[4of9]

whoami schreef op dinsdag 12 december 2006 @ 15:39:

Mark Platvoet heeft daar toch echt een punt hoor; hij zegt net hetzelfde als hetgeen ik me afvraag, maar dan iets anders verwoord.

Ik vind de verwoording niet echt bijdragen aan mijn vraag.

whoami schreef op dinsdag 12 december 2006 @ 15:39:
Zoals reeds gezegd: waarom is een Dictionary die per key een collection bevat dan niet goed genoeg ? En dat is blijkbaar net hetgeen wat de code die EfBe gepost heeft, doet.

omdat mijn xml structuur dat volgens mij niet toelaat.

ieder commando moet apart in de xml staan met de parameters met verschillende values.

In dat geval snap ik niet waarom je over keys praat. Het lijkt me veel handiger om gewoon een commando object te maken met hierin, naast de naam ook een lijst met parameters. Die commando objecten kun je dan keurig in een list stoppen.

Is volgorde ook van belang?

Zo'n commando object is denk ik wel een juiste oplossing.

de volgorde is niet van belang.

Ik praat over keys omdat ik dacht dat het dictionary object de gechikte collectie was om zo'n datastructuur op te slaan. Dit blijkt dat dit niet zo is (dat was ook mijn vraag)


Als je

[Woy]

Ik zou dan inderdaad iets doen als wat Janoz zegt

C#:

class Commando
{
    string name;
    List<Parameter> parameters;
}
class Parameter
{
    int id;
    object value;
    Type type;
}

en dan gewoon een List van Commando's gebruiken

[Verwijderd]

4of9 schreef op dinsdag 12 december 2006 @ 15:49:
Ik vind de verwoording niet echt bijdragen aan mijn vraag.

De bedoeling van die opmerking was om jou te laten nadenken over de vraag. En dan op zo'n manier zodat je zelf het surrealistische gehalte van je vraag zou inzien.

Helaas, ik heb gefaalt

[Verwijderd]

offtopic:
Dankje efBe, ik was juist naar een dergelijke constructie op zoek, ben bezig met een in-memory inverted file search applicatie en daar komt een dergelijke constructie mij zeer goed van pas (maw. je bespaart me een hoop werk ).

Chapeau!

[whoami]

4of9 schreef op dinsdag 12 december 2006 @ 15:49:
[...]

omdat mijn xml structuur dat volgens mij niet toelaat.

ieder commando moet apart in de xml staan met de parameters met verschillende values.

Hoe maak je dat XML bestand ?
Als je zelf een algoritme schrijft die jouw lijst naar jouw gewenste XML structuur omzet, zie ik niet in wat het probleem is.

[4of9]

Verwijderd schreef op dinsdag 12 december 2006 @ 16:04:
[...]
De bedoeling van die opmerking was om jou te laten nadenken over de vraag. En dan op zo'n manier zodat je zelf het surrealistische gehalte van je vraag zou inzien.

Helaas, ik heb gefaalt

ik heb altijd geleerd om op zeer abstract niveau te praten over wat ik probeer te bereiken.
Implementatie doet er verder niet toe en ook de voor en achter liggende stappen niet. Vandaar misschien iets of wat surrealistisch.

Ik was gewoon op zoek naar een datastructuur maar dat was ook niet helemaal duidelijk.

Helaas, ook ik heb gefaald

[Janoz]

Dan ben ik benieuwd waar je de verkeerde weg ingeslagen bent toen je begon met "Ik heb een lijst met commando's".

[4of9]

whoami schreef op dinsdag 12 december 2006 @ 16:13:
[...]
Hoe maak je dat XML bestand ?
Als je zelf een algoritme schrijft die jouw lijst naar jouw gewenste XML structuur omzet, zie ik niet in wat het probleem is.

omdat ik iets kan krijgen in een zeer specifiek geval:

code:

"insert"
"id","1"
"value","piep"
"id","2"
"value","piep1"
"id","3"
"value","piep2"
"id","4"
"value","piep3"
"id","5"
"value","piep4"
"id","6"
"value","piep5"
"id","7"
"value","piep6"
etc. etc.

lijkt me gewoon niet handig om daar een xml van te fabrieken.
(en dan loop ik overigens ook weer tegen het dubbele key verhaal aan tenzij ik een NameValueCollectie gebruik)

Dan ben ik benieuwd waar je de verkeerde weg ingeslagen bent toen je begon met "Ik heb een lijst met commando's".

eh? ik snap niet helemaal wat je bedoelt.

[ Voor 10% gewijzigd door 4of9 op 12-12-2006 16:28 ]

[Janoz]

Nou, het was meer een reactie op je verhaal over abstract niveau en de zoektoch naar de juiste datastructuur. Ik vroeg me af hoe je zo naar een dictionary/map afgedwaald was terwijl een lijst imho zo obvious lijkt.

[4of9]

Ah zo.

Is er geen lijst waarbij je kan doen:

List<string,Dictionary<string,string>> ?
(daar was ik eigenlijk naar op zoek maar kon het niet vinden.

hoewel dat commando object me nu wel aanstaat.

iig bedankt allemaal voor het meedenken.

[ Voor 12% gewijzigd door 4of9 op 12-12-2006 16:43 ]

[whoami]

Je kan toch gewoon je eigen custom objects aan een lijst gaan toevoegen ?
Ik zie toch niet in waarom je een key/value list wil, want voor zover ik kan zien, gebruik je die functionaliteit toch niet ?

[Janoz]

4of9 schreef op dinsdag 12 december 2006 @ 16:43:
Ah zo.

Is er geen lijst waarbij je kan doen:

List<string,Dictionary<string,string>> ?
(daar was ik eigenlijk naar op zoek maar kon het niet vinden.

En dat is dus precies wat ik niet snap. Je start met "ik heb een lijst met commando's". Ikzelf denk dan: "Mooi, dan pak ik een lijst en stop ik daar commando's in". En vervolgens denk ik verder: "Zo, een commando heeft een naam en een lijst parameters". Pas op dat moment kom ik bij Stringetjes en integertjes uit. Sowieso heb je een soort tupel. Iets dat uit 2 dingen bestaat. Waarom grijp je dan naar een map/dictionary wat eerder een verzameling objectjes is die je vervolgens makkelijk met een key op kunt zoeken.

[EfBe]

Verwijderd schreef op dinsdag 12 december 2006 @ 16:10:

offtopic:
Dankje efBe, ik was juist naar een dergelijke constructie op zoek, ben bezig met een in-memory inverted file search applicatie en daar komt een dergelijke constructie mij zeer goed van pas (maw. je bespaart me een hoop werk ).

Chapeau!

offtopic:
Geen dank

[roy-t]

Edit: Woops... mja in mijn hoofd leek het verband te houden gevalletje: de klok horen luiden, maar niet weten waar de klepel hangt.... *verwijdert zichzelf van dit topic*

[ Voor 87% gewijzigd door roy-t op 14-12-2006 12:04 ]

[PhysicsRules]

Je kan met behulp van de juiste attributen aangeven hoe je objecten geserialiseerd moeten worden naar XML. Ben je daar ook meteen klaar mee. Even Googelen voor de juiste syntax.

[whoami]

therat10430 schreef op dinsdag 12 december 2006 @ 20:00:
[...]


Is dit niet iets voor je, meerdere dingen onder meerdere dingen opslaan? (sorry als het er totaal niet mee te maken heeft, maar ik las dit toevallig en ik moest aan dit topic denken)

source: http://www.c-sharpcorner....uly/WorkingWithArrays.asp
(hoewel ik die site nogal onduidelijk vind, ze geven wel hoe je een array maakt maar niet hoe je ze uitleest .. logica!)

Dit heeft er echt niets mee te maken. Misschien beter om enkel te replien als je zelf zeker weet dat het er wel mee te maken kan hebben ?

[Verwijderd]

offtopic:
@ EfBe; uiteindelijk had ik het niet eens nodig -> HashMap<String, LinkedList> was al voldoende

[4of9]

Janoz schreef op dinsdag 12 december 2006 @ 17:07:
[...]

En dat is dus precies wat ik niet snap. Je start met "ik heb een lijst met commando's". Ikzelf denk dan: "Mooi, dan pak ik een lijst en stop ik daar commando's in". En vervolgens denk ik verder: "Zo, een commando heeft een naam en een lijst parameters". Pas op dat moment kom ik bij Stringetjes en integertjes uit. Sowieso heb je een soort tupel. Iets dat uit 2 dingen bestaat. Waarom grijp je dan naar een map/dictionary wat eerder een verzameling objectjes is die je vervolgens makkelijk met een key op kunt zoeken.

Waarschijnlijk omdat ik verder niet hoef te zoeken.

Maar ik moet gewoon de commando naam opslaan met daaraan de parameters (collectie van key value pairs), maar dat commando object gaat me er wel uit laten komen

[Woy]

PhysicsRules heeft overigens nog wel een handige tip. Aan de hand van het XmlElementAttribute en nog wat andere Attributes kan je precies bepalen hoe het geserializeerd moet worden.

[4of9]

naar aanleiding van dit topic ben ik mijn code aan het herschrijven met zo'n command object. Dit werkt idd handig en logischer (bedankt daarvoor)

nu wil ik echter een method vervangen door een nieuwe maar de oude nog even tijdelijk laten staan maar de compiler zegt dat de 2 methods het zelfde zijn.

C#:

//oude method
public void AddCommand(Dictionary<string, string> parameters, string commandName)

//nieuwe method
 public void AddCommand(ReadOnlyCollection<CommandParameter> parameters, string commandName)

even buitenbeschouwing gelaten of het goed is of niet dat ik eerst een dictionary gebruikte, waarom krijg ik deze error?

error

Error 2 The call is ambiguous between the following methods or properties: 'XmlCommandComposer.AddCommand(System.Collections.ObjectModel.ReadOnlyCollection<CommandParameter>, string)' and 'XmlCommandComposer.AddCommand(System.Collections.Generic.Dictionary<string,string>, string)

[Janoz]

Staat er toch? "The call is ambiguous". Dat betekend dat de compiler enit weet welke hij moet kiezen. Roep je hem ergens aan met een superclass van Dictionary of ReadOnlyCollection oid?

[4of9]

Nee ik roep hem alleen nog aan met de oude aanroep,

dus AddCommand(Dictionary, string)

en op de nieuwe plaats natuurlijk met de (ReadonlyCollection, string)

Dit zijn toch verschillende typen?

[farlane]

Dat zou alleen kunnen als

System.Collections.ObjectModel.ReadOnlyCollection<CommandParameter>

Te casten is naar een

System.Collections.Generic.Dictionary<string,string>

Nu zie ik niet zo snel dat dat mogelijk is maar daar zul je misschien zelf meer inzicht in hebben

[4of9]

Nee die cast gaat niet goed wat mij logisch lijkt omdat de ReadonlyCollectie bestaat uit parameterobjectjes.

vandaar dat ik de foutmelding ook niet snap, de compiler zou toch moeten weten welke method hij moet nemen, ze hebben toch 2 verschillende signatures?

[MTWZZ]

ReadOnlyCollection en Dictionary implementeren allebei ICollection<T> dus misschien dat ie daarom de mist in gaat. Wel een beetje ver gezocht maar dit zou het kunnen zijn.
Dat CommandParameter object van jou overerft niet van KeyValuePair?

[farlane]

MTWZZ schreef op donderdag 14 december 2006 @ 09:52:
ReadOnlyCollection en Dictionary implementeren allebei ICollection<T> dus misschien dat ie daarom de mist in gaat. Wel een beetje ver gezocht maar dit zou het kunnen zijn.
Dat CommandParameter object van jou overerft niet van KeyValuePair?

Zoiets zou het wel moeten zijn schat ik

[.oisyn]

Maar een Dictionary<String, String> vertaalt zich niet op een of andere manier naar een ICollection<CommandParameter>. Ik vind de error ook vaag moet ik zeggen.

Tenzij de compiler niet kan overloaden op basis van een generic type? Want dan is een ICollection<CommandParameter> natuurlijk niet veel andes dan een ICollection<DictionaryEntry<string, string>> oid.

[ Voor 72% gewijzigd door .oisyn op 14-12-2006 10:56 ]

[4of9]

MTWZZ schreef op donderdag 14 december 2006 @ 09:52:
ReadOnlyCollection en Dictionary implementeren allebei ICollection<T> dus misschien dat ie daarom de mist in gaat. Wel een beetje ver gezocht maar dit zou het kunnen zijn.
Dat CommandParameter object van jou overerft niet van KeyValuePair?

Nee mijn commandParameter object erft niet van KeyValue pair.

Blijf het vaag vinden.

Ik heb even als tijdelijke oplossingen de string en collection omgedraaid in de aanroep van de nieuwe method. (beetje vies maar de oude method gaat toch verdwijnen.)

Feit blijft dat de error er dan nog is en (voor mij) niet te verklaren is, en dat kan ik vaak niet echt hebben

[MTWZZ]

Nogal van de vreemde. Als ik ff een testje in elkaar schroef gaat het goed:

C#:

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

public class main {
    public static void Main(string[] args) {
        overload o = new overload();

        o.Add(new Dictionary<string, string>(), "test");
        o.Add(new ReadOnlyCollection<string>("foo"), "test");
    }
}

public class test{ 
    public void Add(Dictionary<string, string> parameters, string commandName)
    {
    }
}

public class overload : test {
    public void Add(ReadOnlyCollection<CommandParameter> parameters, string commandName)
    {
    }
}

public class CommandParameter { }

[.oisyn]

Duh, overload.Add heeft voorrang op test.Add. Je moet beide functies in dezelfde class zetten, en dan ook nog eens aan 4of9 vragen met wat voor type hij z'n method nou eigenlijk aanroept

[4of9]

Raar, maar mijn methodes zitten in dezelfde classe, en bij jou zit de overload in een classe die afgeleid is.

Ik mag toch gewoon overloads in dezelfde classe zetten?

.oisyn schreef op donderdag 14 december 2006 @ 13:34:
Duh, overload.Add heeft voorrang op test.Add. Je moet beide functies in dezelfde class zetten, en dan ook nog eens aan 4of9 vragen met wat voor type hij z'n method nou eigenlijk aanroept

ik roep de methodes aan met Add(dictionary<string,string>, string)

Of op de nieuwe manier Add(ReadOnlyCollection<CommandParam>,string)

ik doe hier toch niks gek?


edit:

kan het zijn dat de compiler ook verwacht dat er een null meegegeven kan worden?
want dan kan ik het me voorstellen dat ie niet weet welke method hij moet pakken en zo ja hoe is dit dan te voorkomen?

[ Voor 102% gewijzigd door 4of9 op 14-12-2006 13:49 ]

[farlane]

4of9 schreef op donderdag 14 december 2006 @ 13:36:
kan het zijn dat de compiler ook verwacht dat er een null meegegeven kan worden?

Dan zou volgens mij elke overload die als parameter een reference type heeft niet geoverload kunnen worden. Volgens mij wordt dat niet meegenomen in de signature.

Probeer em eens expliciet naar het nieuwe type te casten bij de aanroep, kijken of de compiler er dan wel uitkomt (testje)

[ Voor 14% gewijzigd door farlane op 14-12-2006 13:58 ]

[Janoz]

Tenzij je daadwerkelijk ergens een aanroep met null hebt. (en dan bedoel ik een uitgeschreven null, niet een nog niet geinitialiseerde variabele) Op dat moment weet de compiler natuurlijk neit welke methode hij moet pakken.

[4of9]

Dat is niet het geval....

achteraf gezien ook niet logisch omdat je dan idd geen enkele method met een referentie type kan overloaden zoals hier boven al verteld....

[.oisyn]

Nope

C#:

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace CsTest1
{
    class Program
    {
        static void foo(Dictionary<string,string> d)
        {
        }

        static void foo(ReadOnlyCollection<string> r)
        {
        }

        static void Main(string[] args)
        {
            ReadOnlyCollection<string> s = new ReadOnlyCollection<string>(new List<string>());
            foo(s);
        }
    }
}

Compileert prima hier.

[ Voor 26% gewijzigd door .oisyn op 14-12-2006 14:43 ]

[farlane]

Idd ... nu ben ik toch wel benieuwd met welke code je deze functie _exact_ aanroept..

[4of9]

zoals ik al een aantal keer gezegd heb:

oude manier

C#:

//ergens vul ik mijn parameters
Dictionary<string,string> cmdParams = new Dictionary<string,string>();
cmdParams.Add("paramname","value");

Add(cmdParams,"mycommand");

//OF

//ergens maak ik mijn parameter dictionary aan
Dictionary<string,string> cmdParams = new Dictionary<string,string>();
//maar vul ik hem niet

//en wordt uiteindelijk add aangeroepen
Add(cmdParams,"mystring");

en ook (nieuwe manier)

C#:

//ergens doe ik dit
Command command = new Command("myCommandName");
command.AddParameters("param","value")

//en uiteindelijk wordt dit ergens aangeroepen 
// command.Parameters returned een ReadOnlyCollection<CommandParameters>

Add(command.Parameters,command.CommanName);

//OF

//ergens doe ik dit
Command command = new Command("myCommandName");
// worden geen parameters toegevoegd maar mijn CommandParamater list wordt 
// wel geinit in mijn command object

//en uiteindelijk wordt dit ergens aangeroepen 
// command.Parameters returned een ReadOnlyCollection<CommandParameters>

Add(command.Parameters,command.CommanName);

En ik heb een find all references gedaan en daar zit nergens een andere aanroep tussen.

[ Voor 4% gewijzigd door 4of9 op 14-12-2006 15:29 ]

[farlane]

Hmmm raar zeg

Returned je command.Parameters property misschien een verkeerd type ( object bv ) ? Treedt de fout op bij beide calls ( oude en nieuwe ) ?


( Ben nu een beetje in het wilde weg aan het schieten )

[ Voor 3% gewijzigd door farlane op 14-12-2006 16:18 ]

[.oisyn]

.edit: moet comments lezen

Ergens klopt je code gewoon niet. Want mijn voorbeeld werkt toch duidelijk wel. En de enige reden die ik kan bedenken die zo'n error geeft is als je een object gebruikt dat zowel een Dictionary<string,string> als een ReadOnlyCollection<CommandParameters> is, maar dat kan niet, want het zijn beide classes, en .Net ondersteunt geen multiple inheritance

[ Voor 204% gewijzigd door .oisyn op 14-12-2006 16:37 ]

[Janoz]

Waarom maak je een command en ga je vervolgens de apparte onderdelen van dat command toevoegen? Het is echt niet verboden om je eigen objecten in een lijst te stoppen! Ik snap niet hoe jij het voor elkaar krijgt om het je zo moeilijk te maken.

[.oisyn]

Dat ook ja, maar dat verklaard deze error nog niet

[4of9]

Ik heb het zelf ook even nagebootst en dat werkt ook prima (ik doe hier exact hetzelfde alleen dan even wat korter geschreven)

C#:

namespace ConsoleApplication1
{
    class CommandParam
    {
        private string iets;
        private string ietsanders;

    }

    class Command
    {
        private List<CommandParam> param = new List<CommandParam>();

        public ReadOnlyCollection<CommandParam> Param
        { 
            get
            {
                return param.AsReadOnly();
            }
        }
    }

    class Program
    {

        static void Foo(Dictionary<string, string> piep, string test)
        {
 
        }

        static void Foo(ReadOnlyCollection<CommandParam> piep, string test)
        {

        }



        static void Main(string[] args)
        {
            Dictionary<string, string> test = new Dictionary<string, string>();
            //test.Add("piep", "piep");

            Foo(test, "bla");

            Command command = new Command();

            Foo(command.Param, "test2");
        }

en dit werkt gewoon prima.....

[4of9]

Janoz schreef op donderdag 14 december 2006 @ 16:31:
Waarom maak je een command en ga je vervolgens de apparte onderdelen van dat command toevoegen? Het is echt niet verboden om je eigen objecten in een lijst te stoppen! Ik snap niet hoe jij het voor elkaar krijgt om het je zo moeilijk te maken.

Ik maak toch een lijst van mijn eigen CommandParam Objecten?


edit:

ik snap al waar de verwarring zit...
Die Add voegt niets aan de objecten toe.
Die Add is eigenlijk AddXmlCommand in een Ander object dat een XmlDocument Samenstelt.

Ik zie nu echter wel weer een verbetering die mogelijk is...

[ Voor 21% gewijzigd door 4of9 op 14-12-2006 16:52 ]

[Janoz]

Nee, dat lijkt me redelijk duidelijk.

Waarom:
Add(command.Parameters,command.CommanName);

Waarom heb je niet gewoon een lijst waarbij je vervolgens het volgende doet:
Add(command)

[4of9]

Janoz schreef op donderdag 14 december 2006 @ 16:51:
Nee, dat lijkt me redelijk duidelijk.

Waarom:
Add(command.Parameters,command.CommanName);

Waarom heb je niet gewoon een lijst waarbij je vervolgens het volgende doet:
Add(command)

Mja dat zag ik net ook

maar de error blijft...

[ Voor 3% gewijzigd door 4of9 op 14-12-2006 16:53 ]