public override bool Remove(ref DictionaryStorage storage, object key) {
            // check the strKey only if we have some exception info set
            ExceptionState exState = _exceptionState;
            if (exState != null || _setValues != 0) {
                string strKey = key as string;
                if (strKey != null) {
                    switch (strKey) {
                        case "exc_type":
                            lock (this) {
                                _excType = null;
                                _setValues &= ~ExceptionStateFlags.Type;
                                _removedValues |= ExceptionStateFlags.Type;
                            }
                            break;
                        case "exc_value":
                            lock (this) {
                                _excValue = null;
                                _setValues &= ~ExceptionStateFlags.Value;
                                _removedValues |= ExceptionStateFlags.Value;
                            }
                            break;
                        case "exc_traceback":
                            lock (this) {
                                _excTraceback = null;
                                _setValues &= ~ExceptionStateFlags.Traceback;
                                _removedValues |= ExceptionStateFlags.Traceback;
                            }
                            break;
                    }
                }
            }

            return base.Remove(ref storage, key);
        }

        /// <summary>
        /// Adds items from this dictionary into the other dictionary
        /// </summary>
        public virtual void CopyTo(DictionaryStorage/*!*/ into) {
            Debug.Assert(into != null);

            foreach (KeyValuePair<object, object> kvp in GetItems()) {
                into.Add(kvp.Key, kvp.Value);
            }
        }

        public override bool Remove(ref DictionaryStorage storage, object key) {
            if (key is string) {
                return TryRemoveExtraValue((string)key) ?? _storage.Remove(key);

            }
            return _storage.Remove(key);
        }

 public override void AddNoLock(ref DictionaryStorage storage, object key, object value) {            
     // add always needs to check...
     string strKey = key as string;
     if (strKey != null) {
         switch (strKey) {
             case "exc_type":
                 _setValues |= ExceptionStateFlags.Type;
                 _removedValues &= ~ExceptionStateFlags.Type;
                 _excType = value;
                 break;
             case "exc_value":
                 _setValues |= ExceptionStateFlags.Value;
                 _removedValues &= ~ExceptionStateFlags.Value;
                 _excValue = value;
                 break;
             case "exc_traceback":
                 _setValues |= ExceptionStateFlags.Traceback;
                 _removedValues &= ~ExceptionStateFlags.Traceback;
                 _excTraceback = value;
                 break;
         }
     }
     
     base.AddNoLock(ref storage, key, value);
 }

        public override bool Remove(ref DictionaryStorage storage, object key) {
            if (_hidden.Contains(key)) {
                return false;
            }

            return _data.Remove(key);
        }

 public override bool Remove(ref DictionaryStorage storage, object key) {
     try {
         PythonContext.GetContext(_context).DelIndex(_backing, key);
         return true;
     } catch (KeyNotFoundException) {
         return false;
     }
 }

 public override void Add(ref DictionaryStorage storage, object key, object value) {
     string strKey = key as string;
     if (strKey != null) {
         _data[SymbolTable.StringToId(strKey)] = value;
     } else {
         _data.AddObjectKey(key, value);
     }
 }

 public override bool Remove(ref DictionaryStorage storage, object key) {
     string strKey = key as string;
     if (strKey != null) {
         return _data.Remove(SymbolTable.StringToId(strKey));
     } else {
         return _data.RemoveObjectKey(key);
     }
 }

 public override void Add(ref DictionaryStorage storage, object key, object value) {
     string strKey = key as string;
     if (strKey != null) {
         PythonOps.ScopeSetMember(_context.SharedContext, _scope, strKey, value);
     } else {
         PythonScopeExtension ext = (PythonScopeExtension)_context.EnsureScopeExtension(_scope);
         ext.EnsureObjectKeys().Add(key, value);
     }
 }

 public override void Add(ref DictionaryStorage storage, object key, object value) {
     string strkey = key as string;
     if (strkey != null) {
         if (strkey == "__import__") {
             _import = value;
         }
         _change(this, new ModuleChangeEventArgs(strkey, ModuleChangeType.Set, value));
     }
     base.Add(ref storage, key, value);
 }

 public override bool Remove(ref DictionaryStorage storage, object key) {
     string strkey = key as string;
     if (strkey != null) {
         if (strkey == "__import__") {
             _import = null;
         }
         _change(this, new ModuleChangeEventArgs(strkey, ModuleChangeType.Delete));
     }
     return base.Remove(ref storage, key);
 }

 public override void Add(ref DictionaryStorage storage, object key, object value) {
     lock (this) {
         string strKey = key as string;
         if (strKey != null) {
             _dict[strKey] = value;
         } else {
             EnsureObjectDictionary();
             _objDict[BaseSymbolDictionary.NullToObj(key)] = value;
         }
     }
 }

        public override void Clear(ref DictionaryStorage storage) {
            lock (this) {
                if (storage == this) {
                    storage = EmptyDictionaryStorage.Instance;
                    return;
                }
            }

            // race, try again
            storage.Clear(ref storage);
        }

 public override void Add(ref DictionaryStorage storage, object key, object value) {
     lock (this) {
         if (storage == this) {
             CommonDictionaryStorage newStorage = new CommonDictionaryStorage();
             newStorage.AddNoLock(key, value);
             storage = newStorage;
             return;
         }
     }
     
     // race, try again...
     storage.Add(ref storage, key, value);
 }

        public override bool Remove(ref DictionaryStorage storage, object key) {
            lock (this) {
                string strKey = key as string;
                if (strKey != null) {
                    return _dict.Remove(strKey);
                }

                if (_objDict != null) {
                    return _objDict.Remove(BaseSymbolDictionary.NullToObj(key));
                }

                return false;
            }
        }

        public override bool Remove(ref DictionaryStorage storage, object key) {
            string strKey = key as string;
            if (strKey == null) {
                return base.Remove(ref storage, key);
            }

            bool found = base.Remove(ref storage, key);
            object value;
            if (TryGetLazyValue(strKey, out value)) {
                // hide the deleted value
                base.Add(key, Uninitialized.Instance);
                found = true;
            }

            return found;
        }

        public override bool Remove(ref DictionaryStorage storage, object key) {
            if (_storage.Contains(key)) {
                lock (this) {
                    if (storage == this) {
                        var newStore = new CommonDictionaryStorage();
                        _storage.CopyTo(newStore);
                        newStore.Remove(key);
                        storage = newStore;
                        return true;
                    }
                }

                // race, try again
                return storage.Remove(ref storage, key);
            }
            
            return false;
        }

 public override void Clear(ref DictionaryStorage storage) {
     lock (this) {
         _dict.Clear();
         if (_objDict != null) {
             _objDict.Clear();
         }
     }
 }

 public override void Clear(ref DictionaryStorage storage) {
     foreach (var item in GetItems()) {
         Remove(item.Key);
     }
 }

 public override bool Remove(ref DictionaryStorage storage, object key) {
     return Remove(key);
 }