baylor wrote:
Hashtable has a property IsReadOnly. i can't figure out how this gets set.
i can do this by writing my own custom class (and maybe inheriting
ReadOnlyCollectionBase) but i'd rather use a built in class if one is
available
You will need to proxy the collection.
Note that you need to trust the caller not to downcast the Values, Keys,
GetEnumerator(), ... if you don't want to proxy those.
Below is some exaple code you can use as:
IDictionary dict = some_dictionary_which_may_be_read_write;
return ReadOnlyDictionary.Make(dict);
class ReadOnlyDictionary: IDictionary
{
public static IDictionary Make(IDictionary dict)
{
if ( dict.IsReadOnly )
return dict;
else
return new ReadOnlyDictionary(dict);
}
class Immutable: NotSupportedException
{ public Immutable(): base("Immutable data-structure") {} }
protected IDictionary Parent;
protected ReadOnlyDictionary(IDictionary dict)
{ this.Parent = dict; }
#region IDictionary Members
public bool IsReadOnly { get { return true; } }
/* IDictionaryEnumerator doesn't provide mutation
so we can reuse parents without proxy
if we trust the caller not to downcast
to the real type
*/
public IDictionaryEnumerator GetEnumerator()
{ return Parent.GetEnumerator(); }
public object this[object key]
{
get { return Parent[key]; }
set { throw new Immutable(); }
}
public void Remove(object key) { throw new Immutable(); }
public bool Contains(object key) { return Parent.Contains(key); }
public void Clear() { throw new Immutable(); }
/* ICollection doesn't provide mutation
so we can reuse parents without proxy
if we trust the caller not to downcast
to the real type
*/
public ICollection Values { get { return Parent.Values; } }
public void Add(object key, object value) { throw new Immutable(); }
/* ICollection doesn't provide mutation
so we can reuse parents without proxy
if we trust the caller not to downcast
to the real type
*/
public ICollection Keys { get { return Parent.Keys; } }
public bool IsFixedSize { get { return Parent.IsFixedSize; } }
#endregion
#region ICollection Members
public bool IsSynchronized
{ get { return Parent.IsSynchronized; } }
public int Count { get { return Parent.Count; } }
public void CopyTo(Array array, int index)
{ Parent.CopyTo(array, index); }
public object SyncRoot { get { return Parent.SyncRoot; } }
#endregion
#region IEnumerable Members
IEnumerator System.Collections.IEnumerable.GetEnumerator()
{ return ((IEnumerable)Parent).GetEnumerator(); }
#endregion
public override bool Equals(object obj)
{ return Parent.Equals(obj); }
public override int GetHashCode() { return Parent.GetHashCode(); }
public override string ToString() { return Parent.ToString(); }
}
So is there a way to use one of the built-in collections to expose read-only
data or do i need to create my own?
Just use a proxy, it's rather convinient.
Remember, that this doesn't guard you against people using reflection or
whatnot. The only alternative is to copy your returned hashtable's, that
way you don't *care* if the caller edits it.
return new Hashtable(dict);
But that's awfully expensive.
--
Helge Jensen
mailto:he**********@slog.dk
sip:he**********@slog.dk
-=> Sebastian cover-music:
http://ungdomshus.nu <=-
