ConcurrentDictionary.cs System::Collections::Concurrent::ConcurrentDictionary System::Collections::Concurrent::ConcurrentDictionary::ConcurrentDictionaryEnumerator System System::Collections System::Collections::Concurrent //ConcurrentDictionary.cs // //Copyright(c)2009Jérémie"Garuma"Laval // //Permissionisherebygranted,freeofcharge,toanypersonobtainingacopy //ofthissoftwareandassociateddocumentationfiles(the"Software"),todeal //intheSoftwarewithoutrestriction,includingwithoutlimitationtherights //touse,copy,modify,merge,publish,distribute,sublicense,and/orsell //copiesoftheSoftware,andtopermitpersonstowhomtheSoftwareis //furnishedtodoso,subjecttothefollowingconditions: // //Theabovecopyrightnoticeandthispermissionnoticeshallbeincludedin //allcopiesorsubstantialportionsoftheSoftware. // //THESOFTWAREISPROVIDED"ASIS",WITHOUTWARRANTYOFANYKIND,EXPRESSOR //IMPLIED,INCLUDINGBUTNOTLIMITEDTOTHEWARRANTIESOFMERCHANTABILITY, //FITNESSFORAPARTICULARPURPOSEANDNONINFRINGEMENT.INNOEVENTSHALLTHE //AUTHORSORCOPYRIGHTHOLDERSBELIABLEFORANYCLAIM,DAMAGESOROTHER //LIABILITY,WHETHERINANACTIONOFCONTRACT,TORTOROTHERWISE,ARISINGFROM, //OUTOFORINCONNECTIONWITHTHESOFTWAREORTHEUSEOROTHERDEALINGSIN //THESOFTWARE. // // #ifNET_4_0||UNITY_5_3_OR_NEWER usingSystem; usingSystem.Threading; usingSystem.Collections; usingSystem.Collections.Generic; usingSystem.Runtime.Serialization; usingSystem.Diagnostics; namespaceSystem.Collections.Concurrent { [DebuggerDisplay("Count={Count}")] [DebuggerTypeProxy(typeof(CollectionDebuggerView<,>))] publicclassConcurrentDictionary<TKey,TValue>:IDictionary<TKey,TValue>, ICollection<KeyValuePair<TKey,TValue>>,IEnumerable<KeyValuePair<TKey,TValue>>, IDictionary,ICollection,IEnumerable { IEqualityComparer<TKey>comparer; SplitOrderedList<TKey, KeyValuePair<TKey, TValue>>internalDictionary; publicConcurrentDictionary():this(EqualityComparer<TKey>.Default) { } publicConcurrentDictionary(IEnumerable<KeyValuePair<TKey,TValue>>collection) :this(collection,EqualityComparer<TKey>.Default) { } publicConcurrentDictionary(IEqualityComparer<TKey>comparer) { this.comparer=comparer; this.internalDictionary=newSplitOrderedList<TKey, KeyValuePair<TKey, TValue>>(comparer); } publicConcurrentDictionary(IEnumerable<KeyValuePair<TKey,TValue>>collection,IEqualityComparer<TKey>comparer) :this(comparer) { foreach(KeyValuePair<TKey,TValue>pairincollection) Add(pair.Key,pair.Value); } //Parametersunused publicConcurrentDictionary(intconcurrencyLevel,intcapacity) :this(EqualityComparer<TKey>.Default) { } publicConcurrentDictionary(intconcurrencyLevel, IEnumerable<KeyValuePair<TKey,TValue>>collection, IEqualityComparer<TKey>comparer) :this(collection,comparer) { } //Parametersunused publicConcurrentDictionary(intconcurrencyLevel,intcapacity,IEqualityComparer<TKey>comparer) :this(comparer) { } voidCheckKey(TKeykey) { if(key==null) thrownewArgumentNullException("key"); } voidAdd(TKeykey,TValuevalue) { while(!TryAdd(key,value)); } voidIDictionary<TKey,TValue>.Add(TKeykey,TValuevalue) { Add(key,value); } publicboolTryAdd(TKeykey,TValuevalue) { CheckKey(key); returninternalDictionary.Insert(Hash(key),key,Make(key,value)); } voidICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>pair) { Add(pair.Key,pair.Value); } publicTValueAddOrUpdate(TKeykey,Func<TKey,TValue>addValueFactory,Func<TKey,TValue,TValue>updateValueFactory) { CheckKey(key); if(addValueFactory==null) thrownewArgumentNullException("addValueFactory"); if(updateValueFactory==null) thrownewArgumentNullException("updateValueFactory"); returninternalDictionary.InsertOrUpdate(Hash(key), key, ()=>Make(key,addValueFactory(key)), (e)=>Make(key,updateValueFactory(key,e.Value))).Value; } publicTValueAddOrUpdate(TKeykey,TValueaddValue,Func<TKey,TValue,TValue>updateValueFactory) { returnAddOrUpdate(key,(_)=>addValue,updateValueFactory); } TValueAddOrUpdate(TKeykey,TValueaddValue,TValueupdateValue) { CheckKey(key); returninternalDictionary.InsertOrUpdate(Hash(key), key, Make(key,addValue), Make(key,updateValue)).Value; } TValueGetValue(TKeykey) { TValuetemp; if(!TryGetValue(key,outtemp)) thrownewKeyNotFoundException(key.ToString()); returntemp; } publicboolTryGetValue(TKeykey,outTValuevalue) { CheckKey(key); KeyValuePair<TKey,TValue>pair; boolresult=internalDictionary.Find(Hash(key),key,outpair); value=pair.Value; returnresult; } publicboolTryUpdate(TKeykey,TValuenewValue,TValuecomparisonValue) { CheckKey(key); returninternalDictionary.CompareExchange(Hash(key),key,Make(key,newValue),(e)=>e.Value.Equals(comparisonValue)); } publicTValuethis[TKeykey]{ get{ returnGetValue(key); } set{ AddOrUpdate(key,value,value); } } publicTValueGetOrAdd(TKeykey,Func<TKey,TValue>valueFactory) { CheckKey(key); returninternalDictionary.InsertOrGet(Hash(key),key,Make(key,default(TValue)),()=>Make(key,valueFactory(key))).Value; } publicTValueGetOrAdd(TKeykey,TValuevalue) { CheckKey(key); returninternalDictionary.InsertOrGet(Hash(key),key,Make(key,value),null).Value; } publicboolTryRemove(TKeykey,outTValuevalue) { CheckKey(key); KeyValuePair<TKey,TValue>data; boolresult=internalDictionary.Delete(Hash(key),key,outdata); value=data.Value; returnresult; } boolRemove(TKeykey) { TValuedummy; returnTryRemove(key,outdummy); } boolIDictionary<TKey,TValue>.Remove(TKeykey) { returnRemove(key); } boolICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>pair) { returnRemove(pair.Key); } publicboolContainsKey(TKeykey) { CheckKey(key); KeyValuePair<TKey,TValue>dummy; returninternalDictionary.Find(Hash(key),key,outdummy); } boolIDictionary.Contains(objectkey) { if(!(keyisTKey)) returnfalse; returnContainsKey((TKey)key); } voidIDictionary.Remove(objectkey) { if(!(keyisTKey)) return; Remove((TKey)key); } objectIDictionary.this[objectkey] { get{ if(!(keyisTKey)) thrownewArgumentException("keyisn'tofcorrecttype","key"); returnthis[(TKey)key]; } set{ if(!(keyisTKey)||!(valueisTValue)) thrownewArgumentException("keyorvaluearen'tofcorrecttype"); this[(TKey)key]=(TValue)value; } } voidIDictionary.Add(objectkey,objectvalue) { if(!(keyisTKey)||!(valueisTValue)) thrownewArgumentException("keyorvaluearen'tofcorrecttype"); Add((TKey)key,(TValue)value); } boolICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>pair) { returnContainsKey(pair.Key); } publicKeyValuePair<TKey,TValue>[]ToArray() { //Thisismostcertainlynotoptimumbutthereis //notalotofpossibilities returnnewList<KeyValuePair<TKey,TValue>>(this).ToArray(); } publicvoidClear() { //Pronk internalDictionary=newSplitOrderedList<TKey, KeyValuePair<TKey, TValue>>(comparer); } publicintCount{ get{ returninternalDictionary.Count; } } publicboolIsEmpty{ get{ returnCount==0; } } boolICollection<KeyValuePair<TKey,TValue>>.IsReadOnly{ get{ returnfalse; } } boolIDictionary.IsReadOnly{ get{ returnfalse; } } publicICollection<TKey>Keys{ get{ returnGetPart<TKey>((kvp)=>kvp.Key); } } publicICollection<TValue>Values{ get{ returnGetPart<TValue>((kvp)=>kvp.Value); } } ICollectionIDictionary.Keys{ get{ return(ICollection)Keys; } } ICollectionIDictionary.Values{ get{ return(ICollection)Values; } } ICollection<T>GetPart<T>(Func<KeyValuePair<TKey,TValue>,T>extractor) { List<T>temp=newList<T>(); foreach(KeyValuePair<TKey,TValue>kvpinthis) temp.Add(extractor(kvp)); returntemp.AsReadOnly(); } voidICollection.CopyTo(Arrayarray,intstartIndex) { KeyValuePair<TKey,TValue>[]arr=arrayasKeyValuePair<TKey,TValue>[]; if(arr==null) return; CopyTo(arr,startIndex,Count); } voidCopyTo(KeyValuePair<TKey,TValue>[]array,intstartIndex) { CopyTo(array,startIndex,Count); } voidICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[]array,intstartIndex) { CopyTo(array,startIndex); } voidCopyTo(KeyValuePair<TKey,TValue>[]array,intstartIndex,intnum) { foreach(varkvpinthis){ array[startIndex++]=kvp; if(--num<=0) return; } } publicIEnumerator<KeyValuePair<TKey,TValue>>GetEnumerator() { returnGetEnumeratorInternal(); } IEnumeratorIEnumerable.GetEnumerator() { return(IEnumerator)GetEnumeratorInternal(); } IEnumerator<KeyValuePair<TKey,TValue>>GetEnumeratorInternal() { returninternalDictionary.GetEnumerator(); } IDictionaryEnumeratorIDictionary.GetEnumerator() { returnnewConcurrentDictionaryEnumerator(GetEnumeratorInternal()); } classConcurrentDictionaryEnumerator:IDictionaryEnumerator { IEnumerator<KeyValuePair<TKey,TValue>>internalEnum; publicConcurrentDictionaryEnumerator(IEnumerator<KeyValuePair<TKey,TValue>>internalEnum) { this.internalEnum=internalEnum; } publicboolMoveNext() { returninternalEnum.MoveNext(); } publicvoidReset() { internalEnum.Reset(); } publicobjectCurrent{ get{ returnEntry; } } publicDictionaryEntryEntry{ get{ KeyValuePair<TKey,TValue>current=internalEnum.Current; returnnewDictionaryEntry(current.Key,current.Value); } } publicobjectKey{ get{ returninternalEnum.Current.Key; } } publicobjectValue{ get{ returninternalEnum.Current.Value; } } } objectICollection.SyncRoot{ get{ returnthis; } } boolIDictionary.IsFixedSize{ get{ returnfalse; } } boolICollection.IsSynchronized{ get{returntrue;} } staticKeyValuePair<U,V>Make<U,V>(Ukey,Vvalue) { returnnewKeyValuePair<U,V>(key,value); } uintHash(TKeykey) { return(uint)comparer.GetHashCode(key); } } } #endif