C# collection indexed by property?

Question

A problem I often run into is needing to store a collection of objects in such a way that I can retrieve them by a particular field/property that is a unique "index" for that object. For example, I have a Person object for which the name field is a unique identifier, and I want to be able to retrieve from some collection of Person objects the Person whose name="Sax Russell". In Java I usually accomplish this by using a Map where I actually want a Set, and always using the "index" field of the object as its key in the map, i.e. peopleMap.add(myPerson.getName(), myPerson). I was thinking of doing the same thing in C# with Dictionarys, like this:

class Person {
    public string Name {get; set;}
    public int Age {get; set;}
    //...
}

Dictionary<string, Person> PersonProducerMethod() {
    Dictionary<string, Person> people = new Dictionary<string, Person>();
    //somehow produce Person instances...
    people.add(myPerson.Name, myPerson);
    //...
    return people;
}

void PersonConsumerMethod(Dictionary<string, Person> people, List<string> names) {
    foreach(var name in names) {
        person = people[name];
        //process person somehow...
    }
}

However, this seems clumsy, and introduces a rather loose coupling between the keys of the Dictionary and its values; I implicitly depend on every producer of Person dictionaries using the Name property as the key under which to store each Person. I have no guarantee that the element at people["Sax Russell"] is actually a Person with Name="Sax Russell" unless I double-check every time I access the dictionary.

Might there be some way to explicitly ensure that my collection of Person objects is indexed by name, using custom equality comparers and/or LINQ queries? It's important that lookup stay constant-time, which is why I can't just use List.Find or Enumerable.Where. I've tried using a HashSet and constructing it with an equality comparer that compares just the Name field of the objects it's given, but there doesn't seem to be any way to then retrieve the Person objects using just their name.

Just stumbled upon this, but have you considered the [KeyedCollection](https://msdn.microsoft.com/en-us/library/ms132438(v=vs.110).aspx) class? — ygoe, Oct 06 '16 at 11:34

lc. · Answer 1 · 2013-07-09T00:58:05.843

7

I'm not sure if there's anything built-in that does what you want, but there's nothing stopping you from wrapping a dictionary specifying the key yourself, and implementing IList<Person>. The key here (no pun intended) is the consumer does not has access to the underlying dictionary so you can be assured the keys are accurate.

Part of the implementation might look like the following, note the custom indexer as well:

public partial class PersonCollection : IList<Person>
{

    //the underlying dictionary
    private Dictionary<string, Person> _dictionary;

    public PersonCollection()
    {
        _dictionary = new Dictionary<string, Person>();
    }

    public void Add(Person p)
    {
        _dictionary.Add(p.Name, p);
    }

    public Person this[string name]
    {
        get
        {
            return _dictionary[name];
        }
    }

}

As a side bonus, you are also free to change the implementation later without having to change the consuming code.

edited Jul 09 '13 at 00:58

answered Jul 09 '13 at 00:52

lc.

113,939
20
158
187

That's exactly what I was going to say. :) – Michael Bray Jul 09 '13 at 00:53
What if the key is not unique? – Alex from Jitbit Jul 29 '22 at 18:14
@AlexfromJitbit It's perhaps a little ugly but I usually get around it by storing lists in the dictionary, i.e. a `Dictionary>`. Initialize the list on an add operation for a new key; return the whole list when indexed into. You can return an IEnumerable instead and lazily enumerate through the underlying lists in the indexer if you don't want to expose them to the public. – lc. Aug 26 '22 at 05:48
@lc thanks, but I came up with a `Lookup` solution, see my answer below – Alex from Jitbit Aug 26 '22 at 21:47

score 4 · Accepted Answer · edited Feb 14 '14 at 21:22

4

You can build your own collection backed by a dictionary to accomplish this task. The idea is to store a delegate that takes a Person and returns a string by reading the Name property.

Here is a skeletal solution of such a collection:

public class PropertyMap<K,V> : ICollection<V> {
    private readonly IDictionary<K,V> dict = new Dictionary<K,V>();
    private readonly Func<V,K> key;
    public PropertyMap(Func<V,K> key) {
        this.key = key;
    }
    public void Add(V v) {
        dict.Add(key(v));
    }
    // Implement other methods of ICollection
    public this[K k] {
        get { return dict[k]; }
        set { dict[k] = value; }
    }
}

Here is how to use it:

PropertyMap<string,Person> mp = new PropertyMap<string,Person>(
    p => p.Name
);
mp.Add(p1);
mp.Add(p2);

edited Feb 14 '14 at 21:22

CSJ

3,641
2
19
29

answered Jul 09 '13 at 00:58

Sergey Kalinichenko

714,442
84
1,110
1,523

I like this. Definitely a nice generic solution to the problem. – lc. Jul 09 '13 at 02:06
Both answers are good, but I like how generic this is, and how it takes advantage of C#'s function delegates to encapsulate the definition of "deriving a key from this object." – Edward Jul 09 '13 at 18:53
What you need now is a Linq provider so that Linq to Objects will use the index for lookups: `mp.Where(person => person.Name == "Bob").FirstOrDefault()` – Simon Gillbee Apr 22 '14 at 21:32

score 0 · Answer 3 · edited Aug 14 '22 at 13:51

0

If your property value is NOT UNIQUE and you still want to "index" a collection by that property (for example by a person's first name, so that you can quickly find everyone named "Bob" in your people collection) - then you can use the .NET built-in Lookup class as described in this question: Duplicate keys in .NET dictionaries?

edited Aug 14 '22 at 13:51

Eric Aya

69,473
35
181
253

answered Aug 14 '22 at 12:45

Alex from Jitbit

53,710
19
160
149

C# collection indexed by property?

3 Answers3

Linked