Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / CompMod / System / Collections / Specialized / HybridDictionary.cs / 1 / HybridDictionary.cs
//------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- namespace System.Collections.Specialized { using System.Collections; using System.Globalization; ////// [Serializable] public class HybridDictionary: IDictionary { // These numbers have been carefully tested to be optimal. Please don't change them // without doing thorough performance testing. private const int CutoverPoint = 9; private const int InitialHashtableSize = 13; private const int FixedSizeCutoverPoint = 6; // Instance variables. This keeps the HybridDictionary very light-weight when empty private ListDictionary list; private Hashtable hashtable; private bool caseInsensitive; ////// This data structure implements IDictionary first using a linked list /// (ListDictionary) and then switching over to use Hashtable when large. This is recommended /// for cases where the number of elements in a dictionary is unknown and might be small. /// /// It also has a single boolean parameter to allow case-sensitivity that is not affected by /// ambient culture and has been optimized for looking up case-insensitive symbols /// ////// public HybridDictionary() { } ///[To be supplied.] ////// public HybridDictionary(int initialSize) : this(initialSize, false) { } ///[To be supplied.] ////// public HybridDictionary(bool caseInsensitive) { this.caseInsensitive = caseInsensitive; } ///[To be supplied.] ////// public HybridDictionary(int initialSize, bool caseInsensitive) { this.caseInsensitive = caseInsensitive; if (initialSize >= FixedSizeCutoverPoint) { if (caseInsensitive) { hashtable = new Hashtable(initialSize, StringComparer.OrdinalIgnoreCase); } else { hashtable = new Hashtable(initialSize); } } } ///[To be supplied.] ////// public object this[object key] { get { //[To be supplied.] ///// Hashtable supports multiple read, one writer thread safety. // Although we never made the same guarantee for HybridDictionary, // it is still nice to do the same thing here since we have recommended // HybridDictioary as replacement for Hashtable. // // ListDictionary cachedList = list; if (hashtable != null) { return hashtable[key]; } else if (cachedList != null) { return cachedList[key]; } else { //// cachedList can be null in too cases: // (1) The dictionary is empty, we will return null in this case // (2) There is writer which is doing ChangeOver. However in that case // we should see the change to hashtable as well. // So it should work just fine. // // if (key == null) { throw new ArgumentNullException("key", SR.GetString(SR.ArgumentNull_Key)); } return null; } } set { if (hashtable != null) { hashtable[key] = value; } else if (list != null) { if (list.Count >= CutoverPoint - 1) { ChangeOver(); hashtable[key] = value; } else { list[key] = value; } } else { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); list[key] = value; } } } private ListDictionary List { get { if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); } return list; } } private void ChangeOver() { IDictionaryEnumerator en = list.GetEnumerator(); Hashtable newTable; if (caseInsensitive) { newTable = new Hashtable(InitialHashtableSize, StringComparer.OrdinalIgnoreCase); } else { newTable = new Hashtable(InitialHashtableSize); } while (en.MoveNext()) { newTable.Add(en.Key, en.Value); } //// Keep the order of writing to hashtable and list. // We assume we will see the change in hashtable if list is set to null in // this method in another reader thread. // hashtable = newTable; list = null; } ////// public int Count { get { ListDictionary cachedList = list; if (hashtable != null) { return hashtable.Count; } else if (cachedList != null) { return cachedList.Count; } else { return 0; } } } ///[To be supplied.] ////// public ICollection Keys { get { if (hashtable != null) { return hashtable.Keys; } else { return List.Keys; } } } ///[To be supplied.] ////// public bool IsReadOnly { get { return false; } } ///[To be supplied.] ////// public bool IsFixedSize { get { return false; } } ///[To be supplied.] ////// public bool IsSynchronized { get { return false; } } ///[To be supplied.] ////// public object SyncRoot { get { return this; } } ///[To be supplied.] ////// public ICollection Values { get { if (hashtable != null) { return hashtable.Values; } else { return List.Values; } } } ///[To be supplied.] ////// public void Add(object key, object value) { if (hashtable != null) { hashtable.Add(key, value); } else { if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); list.Add(key, value); } else { if (list.Count + 1 >= CutoverPoint) { ChangeOver(); hashtable.Add(key, value); } else { list.Add(key, value); } } } } ///[To be supplied.] ////// public void Clear() { if(hashtable != null) { Hashtable cachedHashtable = hashtable; hashtable = null; cachedHashtable.Clear(); } if( list != null) { ListDictionary cachedList = list; list = null; cachedList.Clear(); } } ///[To be supplied.] ////// public bool Contains(object key) { ListDictionary cachedList = list; if (hashtable != null) { return hashtable.Contains(key); } else if (cachedList != null) { return cachedList.Contains(key); } else { if (key == null) { throw new ArgumentNullException("key", SR.GetString(SR.ArgumentNull_Key)); } return false; } } ///[To be supplied.] ////// public void CopyTo(Array array, int index) { if (hashtable != null) { hashtable.CopyTo(array, index); } else { List.CopyTo(array, index); } } ///[To be supplied.] ////// public IDictionaryEnumerator GetEnumerator() { if (hashtable != null) { return hashtable.GetEnumerator(); } if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); } return list.GetEnumerator(); } ///[To be supplied.] ////// IEnumerator IEnumerable.GetEnumerator() { if (hashtable != null) { return hashtable.GetEnumerator(); } if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); } return list.GetEnumerator(); } ///[To be supplied.] ////// public void Remove(object key) { if (hashtable != null) { hashtable.Remove(key); } else if (list != null){ list.Remove(key); } else { if (key == null) { throw new ArgumentNullException("key", SR.GetString(SR.ArgumentNull_Key)); } } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. //------------------------------------------------------------------------------ //[To be supplied.] ///// Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- namespace System.Collections.Specialized { using System.Collections; using System.Globalization; ////// [Serializable] public class HybridDictionary: IDictionary { // These numbers have been carefully tested to be optimal. Please don't change them // without doing thorough performance testing. private const int CutoverPoint = 9; private const int InitialHashtableSize = 13; private const int FixedSizeCutoverPoint = 6; // Instance variables. This keeps the HybridDictionary very light-weight when empty private ListDictionary list; private Hashtable hashtable; private bool caseInsensitive; ////// This data structure implements IDictionary first using a linked list /// (ListDictionary) and then switching over to use Hashtable when large. This is recommended /// for cases where the number of elements in a dictionary is unknown and might be small. /// /// It also has a single boolean parameter to allow case-sensitivity that is not affected by /// ambient culture and has been optimized for looking up case-insensitive symbols /// ////// public HybridDictionary() { } ///[To be supplied.] ////// public HybridDictionary(int initialSize) : this(initialSize, false) { } ///[To be supplied.] ////// public HybridDictionary(bool caseInsensitive) { this.caseInsensitive = caseInsensitive; } ///[To be supplied.] ////// public HybridDictionary(int initialSize, bool caseInsensitive) { this.caseInsensitive = caseInsensitive; if (initialSize >= FixedSizeCutoverPoint) { if (caseInsensitive) { hashtable = new Hashtable(initialSize, StringComparer.OrdinalIgnoreCase); } else { hashtable = new Hashtable(initialSize); } } } ///[To be supplied.] ////// public object this[object key] { get { //[To be supplied.] ///// Hashtable supports multiple read, one writer thread safety. // Although we never made the same guarantee for HybridDictionary, // it is still nice to do the same thing here since we have recommended // HybridDictioary as replacement for Hashtable. // // ListDictionary cachedList = list; if (hashtable != null) { return hashtable[key]; } else if (cachedList != null) { return cachedList[key]; } else { //// cachedList can be null in too cases: // (1) The dictionary is empty, we will return null in this case // (2) There is writer which is doing ChangeOver. However in that case // we should see the change to hashtable as well. // So it should work just fine. // // if (key == null) { throw new ArgumentNullException("key", SR.GetString(SR.ArgumentNull_Key)); } return null; } } set { if (hashtable != null) { hashtable[key] = value; } else if (list != null) { if (list.Count >= CutoverPoint - 1) { ChangeOver(); hashtable[key] = value; } else { list[key] = value; } } else { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); list[key] = value; } } } private ListDictionary List { get { if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); } return list; } } private void ChangeOver() { IDictionaryEnumerator en = list.GetEnumerator(); Hashtable newTable; if (caseInsensitive) { newTable = new Hashtable(InitialHashtableSize, StringComparer.OrdinalIgnoreCase); } else { newTable = new Hashtable(InitialHashtableSize); } while (en.MoveNext()) { newTable.Add(en.Key, en.Value); } //// Keep the order of writing to hashtable and list. // We assume we will see the change in hashtable if list is set to null in // this method in another reader thread. // hashtable = newTable; list = null; } ////// public int Count { get { ListDictionary cachedList = list; if (hashtable != null) { return hashtable.Count; } else if (cachedList != null) { return cachedList.Count; } else { return 0; } } } ///[To be supplied.] ////// public ICollection Keys { get { if (hashtable != null) { return hashtable.Keys; } else { return List.Keys; } } } ///[To be supplied.] ////// public bool IsReadOnly { get { return false; } } ///[To be supplied.] ////// public bool IsFixedSize { get { return false; } } ///[To be supplied.] ////// public bool IsSynchronized { get { return false; } } ///[To be supplied.] ////// public object SyncRoot { get { return this; } } ///[To be supplied.] ////// public ICollection Values { get { if (hashtable != null) { return hashtable.Values; } else { return List.Values; } } } ///[To be supplied.] ////// public void Add(object key, object value) { if (hashtable != null) { hashtable.Add(key, value); } else { if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); list.Add(key, value); } else { if (list.Count + 1 >= CutoverPoint) { ChangeOver(); hashtable.Add(key, value); } else { list.Add(key, value); } } } } ///[To be supplied.] ////// public void Clear() { if(hashtable != null) { Hashtable cachedHashtable = hashtable; hashtable = null; cachedHashtable.Clear(); } if( list != null) { ListDictionary cachedList = list; list = null; cachedList.Clear(); } } ///[To be supplied.] ////// public bool Contains(object key) { ListDictionary cachedList = list; if (hashtable != null) { return hashtable.Contains(key); } else if (cachedList != null) { return cachedList.Contains(key); } else { if (key == null) { throw new ArgumentNullException("key", SR.GetString(SR.ArgumentNull_Key)); } return false; } } ///[To be supplied.] ////// public void CopyTo(Array array, int index) { if (hashtable != null) { hashtable.CopyTo(array, index); } else { List.CopyTo(array, index); } } ///[To be supplied.] ////// public IDictionaryEnumerator GetEnumerator() { if (hashtable != null) { return hashtable.GetEnumerator(); } if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); } return list.GetEnumerator(); } ///[To be supplied.] ////// IEnumerator IEnumerable.GetEnumerator() { if (hashtable != null) { return hashtable.GetEnumerator(); } if (list == null) { list = new ListDictionary(caseInsensitive ? StringComparer.OrdinalIgnoreCase : null); } return list.GetEnumerator(); } ///[To be supplied.] ////// public void Remove(object key) { if (hashtable != null) { hashtable.Remove(key); } else if (list != null){ list.Remove(key); } else { if (key == null) { throw new ArgumentNullException("key", SR.GetString(SR.ArgumentNull_Key)); } } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.[To be supplied.] ///
Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SessionStateModule.cs
- ManipulationCompletedEventArgs.cs
- WebPartsPersonalization.cs
- PrimitiveType.cs
- TimeoutException.cs
- DataSourceNameHandler.cs
- OleDbPropertySetGuid.cs
- DeferredTextReference.cs
- XmlSchemaNotation.cs
- PageThemeCodeDomTreeGenerator.cs
- StylusPointPropertyId.cs
- RequestCacheValidator.cs
- WindowsGraphicsCacheManager.cs
- PrintDialog.cs
- DesignUtil.cs
- PrintEvent.cs
- RbTree.cs
- AffineTransform3D.cs
- ActivityExecutionWorkItem.cs
- WindowsEditBoxRange.cs
- IDReferencePropertyAttribute.cs
- StringHelper.cs
- RangeContentEnumerator.cs
- Decorator.cs
- Image.cs
- EntityDataSourceMemberPath.cs
- Size3DConverter.cs
- NGCSerializerAsync.cs
- storepermissionattribute.cs
- DirectoryInfo.cs
- AuthorizationRule.cs
- _SSPIWrapper.cs
- EventMappingSettingsCollection.cs
- AssociationSetEnd.cs
- EdmType.cs
- CustomAttributeSerializer.cs
- Hashtable.cs
- ResourcePermissionBase.cs
- GreaterThan.cs
- RegexWorker.cs
- SoapAttributes.cs
- AssemblyInfo.cs
- RuleProcessor.cs
- DataControlPagerLinkButton.cs
- DataGridViewRowHeaderCell.cs
- WebPartVerbsEventArgs.cs
- DataBinding.cs
- ContextQuery.cs
- ColorAnimationBase.cs
- DomainUpDown.cs
- NullRuntimeConfig.cs
- LinkDesigner.cs
- MatrixIndependentAnimationStorage.cs
- InvalidWMPVersionException.cs
- ToolStripPanelRenderEventArgs.cs
- ColorMatrix.cs
- SpinLock.cs
- DynamicResourceExtension.cs
- AmbientLight.cs
- Size3DValueSerializer.cs
- FrameworkName.cs
- Light.cs
- HandledEventArgs.cs
- WindowsListViewItemCheckBox.cs
- DataGridPagingPage.cs
- HostedNamedPipeTransportManager.cs
- UnaryNode.cs
- ButtonField.cs
- PropertyPathWorker.cs
- SqlAliaser.cs
- StreamSecurityUpgradeInitiatorAsyncResult.cs
- TypeToken.cs
- ListManagerBindingsCollection.cs
- WindowsClaimSet.cs
- Positioning.cs
- ComplexPropertyEntry.cs
- ContextMenuStripActionList.cs
- WindowsFont.cs
- ViewUtilities.cs
- TypeDescriptionProviderAttribute.cs
- XmlAttribute.cs
- InstancePersistenceEvent.cs
- DateTimeUtil.cs
- XmlResolver.cs
- RC2CryptoServiceProvider.cs
- DataGridCommandEventArgs.cs
- CustomTypeDescriptor.cs
- NavigationProperty.cs
- AnnotationResourceChangedEventArgs.cs
- EntitySqlQueryBuilder.cs
- RulePatternOps.cs
- DocumentApplicationDocumentViewer.cs
- TypeSystem.cs
- SecurityProtocolCorrelationState.cs
- Boolean.cs
- ToolboxItemCollection.cs
- Point4D.cs
- DispatcherFrame.cs
- GridViewRowPresenter.cs
- FrameworkElementFactoryMarkupObject.cs