|
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
// <OWNER>Microsoft</OWNER>
//
namespace System.Collections.ObjectModel
{
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
[Serializable]
[System.Runtime.InteropServices.ComVisible(false)]
[DebuggerTypeProxy(typeof(Mscorlib_KeyedCollectionDebugView<,>))]
[DebuggerDisplay("Count = {Count}")]
public abstract class KeyedCollection<TKey,TItem>: Collection<TItem>
{
const int defaultThreshold = 0;
IEqualityComparer<TKey> comparer;
Dictionary<TKey,TItem> dict;
int keyCount;
int threshold;
protected KeyedCollection(): this(null, defaultThreshold) {}
protected KeyedCollection(IEqualityComparer<TKey> comparer): this(comparer, defaultThreshold) {}
protected KeyedCollection(IEqualityComparer<TKey> comparer, int dictionaryCreationThreshold) {
if (comparer == null) {
comparer = EqualityComparer<TKey>.Default;
}
if (dictionaryCreationThreshold == -1) {
dictionaryCreationThreshold = int.MaxValue;
}
if( dictionaryCreationThreshold < -1) {
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.dictionaryCreationThreshold, ExceptionResource.ArgumentOutOfRange_InvalidThreshold);
}
this.comparer = comparer;
this.threshold = dictionaryCreationThreshold;
}
public IEqualityComparer<TKey> Comparer {
get {
return comparer;
}
}
public TItem this[TKey key] {
get {
if( key == null) {
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
}
if (dict != null) {
return dict[key];
}
foreach (TItem item in Items) {
if (comparer.Equals(GetKeyForItem(item), key)) return item;
}
ThrowHelper.ThrowKeyNotFoundException();
return default(TItem);
}
}
public bool Contains(TKey key) {
if( key == null) {
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
}
if (dict != null) {
return dict.ContainsKey(key);
}
if (key != null) {
foreach (TItem item in Items) {
if (comparer.Equals(GetKeyForItem(item), key)) return true;
}
}
return false;
}
private bool ContainsItem(TItem item) {
TKey key;
if( (dict == null) || ((key = GetKeyForItem(item)) == null)) {
return Items.Contains(item);
}
TItem itemInDict;
bool exist = dict.TryGetValue(key, out itemInDict);
if( exist) {
return EqualityComparer<TItem>.Default.Equals(itemInDict, item);
}
return false;
}
public bool Remove(TKey key) {
if( key == null) {
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
}
if (dict != null) {
if (dict.ContainsKey(key)) {
return Remove(dict[key]);
}
return false;
}
if (key != null) {
for (int i = 0; i < Items.Count; i++) {
if (comparer.Equals(GetKeyForItem(Items[i]), key)) {
RemoveItem(i);
return true;
}
}
}
return false;
}
protected IDictionary<TKey,TItem> Dictionary {
get { return dict; }
}
protected void ChangeItemKey(TItem item, TKey newKey) {
// check if the item exists in the collection
if( !ContainsItem(item)) {
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_ItemNotExist);
}
TKey oldKey = GetKeyForItem(item);
if (!comparer.Equals(oldKey, newKey)) {
if (newKey != null) {
AddKey(newKey, item);
}
if (oldKey != null) {
RemoveKey(oldKey);
}
}
}
protected override void ClearItems() {
base.ClearItems();
if (dict != null) {
dict.Clear();
}
keyCount = 0;
}
protected abstract TKey GetKeyForItem(TItem item);
protected override void InsertItem(int index, TItem item) {
TKey key = GetKeyForItem(item);
if (key != null) {
AddKey(key, item);
}
base.InsertItem(index, item);
}
protected override void RemoveItem(int index) {
TKey key = GetKeyForItem(Items[index]);
if (key != null) {
RemoveKey(key);
}
base.RemoveItem(index);
}
protected override void SetItem(int index, TItem item) {
TKey newKey = GetKeyForItem(item);
TKey oldKey = GetKeyForItem(Items[index]);
if (comparer.Equals(oldKey, newKey)) {
if (newKey != null && dict != null) {
dict[newKey] = item;
}
}
else {
if (newKey != null) {
AddKey(newKey, item);
}
if (oldKey != null) {
RemoveKey(oldKey);
}
}
base.SetItem(index, item);
}
private void AddKey(TKey key, TItem item) {
if (dict != null) {
dict.Add(key, item);
}
else if (keyCount == threshold) {
CreateDictionary();
dict.Add(key, item);
}
else {
if (Contains(key)) {
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_AddingDuplicate);
}
keyCount++;
}
}
private void CreateDictionary() {
dict = new Dictionary<TKey,TItem>(comparer);
foreach (TItem item in Items) {
TKey key = GetKeyForItem(item);
if (key != null) {
dict.Add(key, item);
}
}
}
private void RemoveKey(TKey key) {
Contract.Assert(key != null, "key shouldn't be null!");
if (dict != null) {
dict.Remove(key);
}
else {
keyCount--;
}
}
}
}
|