--- > private IDictionary<string, object> myDictionary = new
Dictionary<string,object>(); <---
This line is just something that I do when I write code. I always use the
most base class or interface that I need so that things can be changed out
without much work later. For example, at some later time I may create my own
special implementation of a Dictionary that implements the IDictionary
class. If I do this I would want code that I have written in the past to
still work with my custom implementation. If I have something that only
excepted a Dictionary instead of IDictionary then I would only be able to
use the Dictionary class and no other type of implementation. Take the
following for example..
public class SampleClass
{
private IDictionary<string, object> myDictionary;
public IDictionary<string, object> MyProperty
{
get { return myDictionary; }
set { myDictionary = value; }
}
public void DoSomethingWithTheDictionary()
{
// Do something here.
}
}
public class Class2
{
public void DoSomething()
{
SampleClass sc = new SampleClass();
sc.MyProperty = new Dictionary<string, object>();
sc.MyProperty.Add("something", new object());
sc.DoSomethingWithTheDictionary();
// The above will work just great if you used the Dictionary class
// but what if you want to do the operation on own dictionary
implementation?
// You would have to use the IDictionary interface instead. This will
allow you
// to do something like the following.
sc.MyProperty = new MyCustomDictionary();
sc.MyProperty.Add("somethingElse", new object());
sc.DoSomethingWithTheDictionary();
}
}
public class MyCustomDictionary : IDictionary<string, object>
{
public bool ContainsKey(string key)
{
throw new System.NotImplementedException();
}
public void Add(string key, object value)
{
throw new System.NotImplementedException();
}
public bool Remove(string key)
{
throw new System.NotImplementedException();
}
public bool TryGetValue(string key, out object value)
{
throw new System.NotImplementedException();
}
public object this[string key]
{
get { throw new System.NotImplementedException(); }
set { throw new System.NotImplementedException(); }
}
public ICollection<string> Keys
{
get { throw new System.NotImplementedException(); }
}
public ICollection<object> Values
{
get { throw new System.NotImplementedException(); }
}
public void Add(KeyValuePair<string, object> item)
{
throw new System.NotImplementedException();
}
public void Clear()
{
throw new System.NotImplementedException();
}
public bool Contains(KeyValuePair<string, object> item)
{
throw new System.NotImplementedException();
}
public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
{
throw new System.NotImplementedException();
}
public bool Remove(KeyValuePair<string, object> item)
{
throw new System.NotImplementedException();
}
public int Count
{
get { throw new System.NotImplementedException(); }
}
public bool IsReadOnly
{
get { throw new System.NotImplementedException(); }
}
IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string,
object>>.GetEnumerator()
{
throw new System.NotImplementedException();
}
public IEnumerator GetEnumerator()
{
return ((IEnumerable<KeyValuePair<string, object>>)this).GetEnumerator();
}
}
GiJeet said:
I thought about using getter/setter methods but Jeremy's solution
worked.
I didn't know you could use this type of syntax: sc.MyProperty["key"]
= new object();
It even works with the Add method. sc.MyProperty.Add("FirstName",
"Gi");
I know there is a slight difference but don't remember what it
is...
This line has me puzzled thou:
private IDictionary<string, object> myDictionary = new
Dictionary<string,object>();
why IDictionary? we have both a get and set so we're not concerned
about mutation, so why not just Dictionary?
G
