using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Threading;

namespace Rocky
{
public class SyncDictionary : IDictionary
{
#region wrap
private IDictionary wrapDictionary;

public SyncDictionary()
: this(new HybridDictionary())
{

}
public SyncDictionary(IDictionary dictionary)
{
if (dictionary == null)
{
throw new ArgumentNullException("dictionary");
}
wrapDictionary = dictionary;
}
#endregion

#region IDictionary 成员
public void Add(object key, object value)
{
if (!wrapDictionary.Contains(key))
{
lock (wrapDictionary.SyncRoot)
{
if (!wrapDictionary.Contains(key))
{
wrapDictionary.Add(key, value);
}
}
}
}

public void Clear()
{
if (wrapDictionary.Count > 0)
{
lock (wrapDictionary.SyncRoot)
{
if (wrapDictionary.Count > 0)
{
wrapDictionary.Clear();
}
}
}
}

public bool Contains(object key)
{
return wrapDictionary.Contains(key);
}

public IDictionaryEnumerator GetEnumerator()
{
return wrapDictionary.GetEnumerator();
}

bool IDictionary.IsFixedSize
{
get { return wrapDictionary.IsFixedSize; }
}

bool IDictionary.IsReadOnly
{
get { return wrapDictionary.IsReadOnly; }
}

public ICollection Keys
{
get
{
lock (wrapDictionary.SyncRoot)
{
return wrapDictionary.Keys;
}
}
}

public void Remove(object key)
{
if (wrapDictionary.Contains(key))
{
lock (wrapDictionary.SyncRoot)
{
if (wrapDictionary.Contains(key))
{
wrapDictionary.Remove(key);
}
}
}
}

public ICollection Values
{
get
{
lock (wrapDictionary.SyncRoot)
{
return wrapDictionary.Values;
}
}
}

public object this[object key]
{
set
{
lock (wrapDictionary.SyncRoot)
{
wrapDictionary[key] = value;
}
}
get
{
return wrapDictionary[key];
}
}
#endregion

#region ICollection 成员
public void CopyTo(Array array, int index)
{
lock (wrapDictionary.SyncRoot)
{
wrapDictionary.CopyTo(array, index);
}
}

public int Count
{
get { return wrapDictionary.Count; }
}

bool ICollection.IsSynchronized
{
get { return true; }
}

object ICollection.SyncRoot
{
get { return wrapDictionary.SyncRoot; }
}
#endregion

#region IEnumerable 成员
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
#endregion
}

public class SyncDictionary<TKey, TValue> : IDictionary<TKey, TValue>
{
#region wrap
private object syncRoot;
private IDictionary<TKey, TValue> wrapDictionary;

private object SyncRoot
{
get
{
if (syncRoot == null)
{
Interlocked.CompareExchange(ref syncRoot, new object(), null);
}
return syncRoot;
}
}

public SyncDictionary()
: this(new Dictionary<TKey, TValue>())
{

}
public SyncDictionary(IDictionary<TKey, TValue> dictionary)
{
if (dictionary == null)
{
throw new ArgumentNullException("dictionary");
}
wrapDictionary = dictionary;
}
#endregion

#region IDictionary<TKey,TValue> 成员
public void Add(TKey key, TValue value)
{
if (!wrapDictionary.ContainsKey(key))
{
lock (this.SyncRoot)
{
if (!wrapDictionary.ContainsKey(key))
{
wrapDictionary.Add(key, value);
}
}
}
}

public bool ContainsKey(TKey key)
{
return wrapDictionary.ContainsKey(key);
}

public ICollection<TKey> Keys
{
get
{
lock (this.SyncRoot)
{
return wrapDictionary.Keys;
}
}
}

public bool Remove(TKey key)
{
if (wrapDictionary.ContainsKey(key))
{
lock (this.SyncRoot)
{
if (wrapDictionary.ContainsKey(key))
{
return wrapDictionary.Remove(key);
}
}
}
return false;
}

public bool TryGetValue(TKey key, out TValue value)
{
lock (this.SyncRoot)
{
return wrapDictionary.TryGetValue(key, out value);
}
}

public ICollection<TValue> Values
{
get
{
lock (this.SyncRoot)
{
return wrapDictionary.Values;
}
}
}

public TValue this[TKey key]
{
set
{
lock (this.SyncRoot)
{
wrapDictionary[key] = value;
}
}
get
{
TValue value;
wrapDictionary.TryGetValue(key, out value);
return value;
}
}
#endregion

#region ICollection<KeyValuePair<TKey,TValue>> 成员
void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
{
lock (this.SyncRoot)
{
((ICollection<KeyValuePair<TKey, TValue>>)wrapDictionary).Add(item);
}
}

public void Clear()
{
if (wrapDictionary.Count > 0)
{
lock (this.SyncRoot)
{
if (wrapDictionary.Count > 0)
{
wrapDictionary.Clear();
}
}
}
}

bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> item)
{
return ((ICollection<KeyValuePair<TKey, TValue>>)wrapDictionary).Contains(item);
}

public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
{
lock (this.SyncRoot)
{
((ICollection<KeyValuePair<TKey, TValue>>)wrapDictionary).CopyTo(array, arrayIndex);
}
}

public int Count
{
get { return wrapDictionary.Count; }
}

bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
{
get { return false; }
}

bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
{
lock (this.SyncRoot)
{
return ((ICollection<KeyValuePair<TKey, TValue>>)wrapDictionary).Remove(item);
}
}
#endregion

#region IEnumerable<KeyValuePair<TKey,TValue>> 成员
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
{
return ((ICollection<KeyValuePair<TKey, TValue>>)wrapDictionary).GetEnumerator();
}
#endregion

#region IEnumerable 成员
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
#endregion
}
}