StringDictionary as a common static list?

Question

Hi, what I'm trying to do is have a project-wise static dictionary so I can access a single list from anywhere in my code.

Until now, I came up with this solution, a public static class with a public property:

public static class Common
{
    public static StringDictionary Domains
    {
        get
        {
            StringDictionary list = new StringDictionary();

            list.Add("212", "Location A");
            list.Add("555", "Location B");
            list.Add("747", "Location C");
            list.Add("000", "Location D");

            return list;
        }
    }
}

That I use in this way (I use it to replace the content of a cell in a gridview):

if (Common.Domains.ContainsKey(e.Row.Cells[5].Text))
{
    e.Row.Cells[5].Text = Common.Domains[e.Row.Cells[5].Text];
}
else
{
    e.Row.Cells[5].Text = "n/a";
}

But I don't know if this is an efficient solution, and/or if there are other (better) ways to do this... Can somebody give a hint?

Thanks in advance, Andrea.

Answer 1

Your dictionary is going to be reloaded every time you do a get on Domains

Configure a static constructor that will load and stash a readonly static copy of the list instance dictionary in memory.

Answer 2

You probably don't want to re-create the list every time the property is accessed. Move the construction into the static constructor:

public static class Common
{
    private static StringDictionary _domains;
    static Common()
    {
        _domains = new StringDictionary();
        _domains.Add("212", "Location A");
        _domains.Add("555", "Location B");
        _domains.Add("747", "Location C");
        _domains.Add("000", "Location D");
    }
    public static StringDictionary Domains
    {
        get
        {
            return _domains;
        }
    }
}

And you should be aware, that the dictionary returned is not read-only. So a client of this class could modify the collection (e.g. add/remove some entries).

Answer 3

Consider using the Singleton pattern instead:

http://en.wikipedia.org/wiki/Singleton_pattern

It's not a must since every program has its own special needs , I only recommand you read about this pattern and rethink about your design again.

If your program is multithreaded you might wanna check whether StringDictionary is thread safe , if it isn't thread safe (and your program is multithreaded), you should add some synchronization mechanism to your class.

Answer 4

@Jeff Fritz is correct in his answer, but I just wanted to add a little more about the shared access of this field among multiple threads. StringDictionary is only thread-safe for read operations, and not write operations, so you'll want to be careful not to modify this collection without proper locking, and you'll also want to lock the collection when iterating over it.

To iterate:

lock(Common.Domains) {
    foreach(var domain in Common.Domains) {
    }
}

To add a domain outside the static constructor:

lock(Common.Domains) {
    Common.Domains.Add("111", "Location 3");
}

In general, I'd be very careful when sharing a non-readonly collection via a static field so that the field isn't modified. You may want to make StringDictionary a ReadOnlyCollection instead and mark the field "readonly":

public static readonly ReadOnlyCollection<Pair<string, string>> domains

You won't get O(1) lookups, but I'm assuming this collection will be very small, so that won't matter anyway.