The Labs \ Source Viewer \ SSCLI \ System.Collections \ DictionaryBase

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //------------------------------------------------------------------------------
  16. //------------------------------------------------------------------------------
  17. namespace System.Collections
  18. {
  19.    
  20.     using System;
  21.     using System.Security.Permissions;
  22.    
  23.     // Useful base class for typed read/write collections where items derive from object
  24.     [Serializable()]
  25.     [System.Runtime.InteropServices.ComVisible(true)]
  26.     public abstract class DictionaryBase : IDictionary
  27.     {
  28.         Hashtable hashtable;
  29.        
  30.         protected Hashtable InnerHashtable {
  31.             get {
  32.                 if (hashtable == null)
  33.                     hashtable = new Hashtable();
  34.                 return hashtable;
  35.             }
  36.         }
  37.        
  38.         protected IDictionary Dictionary {
  39.             get { return (IDictionary)this; }
  40.         }
  41.        
  42.         public int Count {
  43.             // to avoid newing inner list if no items are ever added
  44.             get { return hashtable == null ? 0 : hashtable.Count; }
  45.         }
  46.        
  47.         bool IDictionary.IsReadOnly {
  48.             get { return InnerHashtable.IsReadOnly; }
  49.         }
  50.        
  51.         bool IDictionary.IsFixedSize {
  52.             get { return InnerHashtable.IsFixedSize; }
  53.         }
  54.        
  55.         bool ICollection.IsSynchronized {
  56.             get { return InnerHashtable.IsSynchronized; }
  57.         }
  58.        
  59.         ICollection IDictionary.Keys {
  60.             get { return InnerHashtable.Keys; }
  61.         }
  62.        
  63.         object ICollection.SyncRoot {
  64.             get { return InnerHashtable.SyncRoot; }
  65.         }
  66.        
  67.         ICollection IDictionary.Values {
  68.             get { return InnerHashtable.Values; }
  69.         }
  70.        
  71.         public void CopyTo(Array array, int index)
  72.         {
  73.             InnerHashtable.CopyTo(array, index);
  74.         }
  75.        
  76.         object IDictionary.this[object key]
  77.         {
  78.             get {
  79.                 object currentValue = InnerHashtable[key];
  80.                 OnGet(key, currentValue);
  81.                 return currentValue;
  82.             }
  83.             set {
  84.                 OnValidate(key, value);
  85.                 bool keyExists = true;
  86.                 object temp = InnerHashtable[key];
  87.                 if (temp == null) {
  88.                     keyExists = InnerHashtable.Contains(key);
  89.                 }
  90.                
  91.                 OnSet(key, temp, value);
  92.                 InnerHashtable[key] = value;
  93.                 try {
  94.                     OnSetComplete(key, temp, value);
  95.                 }
  96.                 catch {
  97.                     if (keyExists) {
  98.                         InnerHashtable[key] = temp;
  99.                     }
  100.                     else {
  101.                         InnerHashtable.Remove(key);
  102.                     }
  103.                     throw;
  104.                 }
  105.             }
  106.         }
  107.        
  108.         bool IDictionary.Contains(object key)
  109.         {
  110.             return InnerHashtable.Contains(key);
  111.         }
  112.        
  113.         void IDictionary.Add(object key, object value)
  114.         {
  115.             OnValidate(key, value);
  116.             OnInsert(key, value);
  117.             InnerHashtable.Add(key, value);
  118.             try {
  119.                 OnInsertComplete(key, value);
  120.             }
  121.             catch {
  122.                 InnerHashtable.Remove(key);
  123.                 throw;
  124.             }
  125.         }
  126.        
  127.         public void Clear()
  128.         {
  129.             OnClear();
  130.             InnerHashtable.Clear();
  131.             OnClearComplete();
  132.         }
  133.        
  134.         void IDictionary.Remove(object key)
  135.         {
  136.             if (InnerHashtable.Contains(key)) {
  137.                 object temp = InnerHashtable[key];
  138.                 OnValidate(key, temp);
  139.                 OnRemove(key, temp);
  140.                
  141.                 InnerHashtable.Remove(key);
  142.                 try {
  143.                     OnRemoveComplete(key, temp);
  144.                 }
  145.                 catch {
  146.                     InnerHashtable.Add(key, temp);
  147.                     throw;
  148.                 }
  149.             }
  150.         }
  151.        
  152.         public IDictionaryEnumerator GetEnumerator()
  153.         {
  154.             return InnerHashtable.GetEnumerator();
  155.         }
  156.        
  157.         IEnumerator IEnumerable.GetEnumerator()
  158.         {
  159.             return InnerHashtable.GetEnumerator();
  160.         }
  161.        
  162.         protected virtual object OnGet(object key, object currentValue)
  163.         {
  164.             return currentValue;
  165.         }
  166.        
  167.         protected virtual void OnSet(object key, object oldValue, object newValue)
  168.         {
  169.         }
  170.        
  171.         protected virtual void OnInsert(object key, object value)
  172.         {
  173.         }
  174.        
  175.         protected virtual void OnClear()
  176.         {
  177.         }
  178.        
  179.         protected virtual void OnRemove(object key, object value)
  180.         {
  181.         }
  182.        
  183.         protected virtual void OnValidate(object key, object value)
  184.         {
  185.         }
  186.        
  187.         protected virtual void OnSetComplete(object key, object oldValue, object newValue)
  188.         {
  189.         }
  190.        
  191.         protected virtual void OnInsertComplete(object key, object value)
  192.         {
  193.         }
  194.        
  195.         protected virtual void OnClearComplete()
  196.         {
  197.         }
  198.        
  199.         protected virtual void OnRemoveComplete(object key, object value)
  200.         {
  201.         }
  202.        
  203.     }
  204.    
  205. }

Developer Fusion