0

For the purpose of XML serialisation I had to disband a Dictionary collection I was using. I wrote a very straightforward alternative which consists of 2 classes:

  • NameValueItem: contains Name (Key) and Value
  • NameValueCollection: derived from CollectionBase and maintains a collection of NameValueItem objects.

I've included some standard methods to help maintain the collection (Add, Contains and Remove). So just like most Dictionary types, the Name (or Key) is unique: 

    public bool Contains(NameValueItem item)
    {
        foreach (NameValueItem lItem in List)
            if(lItem.Name.Equals(item.Name))
                return true;

        return false;
    }

Add uses this Contains method to determine whether to include a given item into the collection: 

    public void Add(NameValueItem item)
    {
        if (!Contains(item))
            List.Add(item);
    }

As bog standard, straightforward and easy as this code appears it's proving to be a little sluggish. Is there anything that can be done to improve the performance of this? Or alternatives I could use?

I was considering creating a NameValueHashSet, which is derived from HashSet.

Optional...:

I had a question which I was going to ask in a separate thread, but I'll leave it up to you as to whether you'd like to address it or not.

I wanted to add 2 properties to the NameValueCollection, Names and Values, which return a List of strings from the Collection of NameValueItem objects. Instead I built them into methods GetNames() and GetValues(), as I have to build the collection (i.e. create a List (names/values), iterate over collection adding names/value to List and return List).

Is this a better alternative? In terms of good coding practise, performance, etc.? As my thoughts regarding properties has always been to have it as stripped back as possible, that only references, arithmetic, etc. should exist, with no layers of processes. If that is the case, then it should be built into a method. Thoughts?

user1092809
  • 107
  • 1
  • 7

1 Answers1

0

Perhaps you shouldn't try to rebuild what the framework already provides? Your implementation of a dictionary is going to perform poorly as it does not scale. The built in Dictionary<TKey, TValue> has O(1) access performance and for most insert and delete operations (unless there are collisions or the internal storage must be expanded).

You can extend the existing dictionary to provide XML serialization support; see this question and answers: Serialize Class containing Dictionary member

As for your second question - Dictionary already provides methods for getting an IEnumerable of the keys and values. This enumerates the keys and/or values as requested by the caller; that is delayed execution and is likely the preferred method over building a full List every time (which requires iterating through all the elements in the dictionary). If the caller wants a list then they just do dictionary.Values.ToList().

Community
  • 1
  • 1
Kevin Brock
  • 8,874
  • 1
  • 33
  • 37
  • By using 'SerializableDictionary' I would be "rebuild[ing] what the framework already provides". With any solution I choose there's going to be work involved, even the NOLC are pretty much the same if not less for the solution I built. Though of course the performance of continuing to use Dictionary is highly beneficial, however, I am losing control of how I build the XML elements and attributes, or how would I get around that? The second question was actually more geared towards good practises rather than specific class definitions. – user1092809 Mar 17 '14 at 17:22
  • Did you look at the answers at the question I linked? The second answer provides a very good solution to your problem. This is not rebuilding the dictionary but extends it to add XML serialization capability. You have total control over how the dictionary is serialized and deserialized with that solution. If you want more of a specific answer about using Properties vs. Methods - you can probably search here for that or you should create a new question. – Kevin Brock Mar 17 '14 at 18:23