Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CompMod / System / Collections / Specialized / OrderedDictionary.cs / 1305376 / OrderedDictionary.cs
//------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- namespace System.Collections.Specialized { using System; using System.Collections; using System.Diagnostics.CodeAnalysis; using System.Runtime.Serialization; using System.Security.Permissions; ////// [Serializable] public class OrderedDictionary : IOrderedDictionary, ISerializable, IDeserializationCallback { private ArrayList _objectsArray; private Hashtable _objectsTable; private int _initialCapacity; private IEqualityComparer _comparer; private bool _readOnly; private Object _syncRoot; private SerializationInfo _siInfo; //A temporary variable which we need during deserialization. private const string KeyComparerName = "KeyComparer"; private const string ArrayListName = "ArrayList"; private const string ReadOnlyName = "ReadOnly"; private const string InitCapacityName = "InitialCapacity"; public OrderedDictionary() : this(0) { } public OrderedDictionary(int capacity) : this(capacity, null) { } public OrderedDictionary(IEqualityComparer comparer) : this(0, comparer) { } public OrderedDictionary(int capacity, IEqualityComparer comparer) { _initialCapacity = capacity; _comparer = comparer; } private OrderedDictionary(OrderedDictionary dictionary) { if (dictionary == null) { throw new ArgumentNullException("dictionary"); } _readOnly = true; _objectsArray = dictionary._objectsArray; _objectsTable = dictionary._objectsTable; _comparer = dictionary._comparer; _initialCapacity = dictionary._initialCapacity; } protected OrderedDictionary(SerializationInfo info, StreamingContext context) { // We can't do anything with the keys and values until the entire graph has been deserialized // and getting Counts and objects won't fail. For the time being, we'll just cache this. // The graph is not valid until OnDeserialization has been called. _siInfo = info; } ////// OrderedDictionary offers IDictionary syntax with ordering. Objects /// added or inserted in an IOrderedDictionary must have both a key and an index, and /// can be retrieved by either. /// OrderedDictionary is used by the ParameterCollection because MSAccess relies on ordering of /// parameters, while almost all other DBs do not. DataKeyArray also uses it so /// DataKeys can be retrieved by either their name or their index. /// /// OrderedDictionary implements IDeserializationCallback because it needs to have the /// contained ArrayList and Hashtable deserialized before it tries to get its count and objects. /// ////// Gets the size of the table. /// public int Count { get { return objectsArray.Count; } } ////// Indicates that the collection can grow. /// bool IDictionary.IsFixedSize { get { return _readOnly; } } ////// Indicates that the collection is not read-only /// public bool IsReadOnly { get { return _readOnly; } } ////// Indicates that this class is not synchronized /// bool ICollection.IsSynchronized { get { return false; } } ////// Gets the collection of keys in the table in order. /// public ICollection Keys { get { return new OrderedDictionaryKeyValueCollection(objectsArray, true); } } private ArrayList objectsArray { get { if (_objectsArray == null) { _objectsArray = new ArrayList(_initialCapacity); } return _objectsArray; } } private Hashtable objectsTable { get { if (_objectsTable == null) { _objectsTable = new Hashtable(_initialCapacity, _comparer); } return _objectsTable; } } ////// The SyncRoot object. Not used because IsSynchronized is false /// object ICollection.SyncRoot { get { if (_syncRoot == null) { System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null); } return _syncRoot; } } ////// Gets or sets the object at the specified index /// public object this[int index] { get { return ((DictionaryEntry)objectsArray[index]).Value; } set { if (_readOnly) { throw new NotSupportedException(SR.GetString(SR.OrderedDictionary_ReadOnly)); } if (index < 0 || index >= objectsArray.Count) { throw new ArgumentOutOfRangeException("index"); } object key = ((DictionaryEntry)objectsArray[index]).Key; objectsArray[index] = new DictionaryEntry(key, value); objectsTable[key] = value; } } ////// Gets or sets the object with the specified key /// public object this[object key] { get { return objectsTable[key]; } set { if (_readOnly) { throw new NotSupportedException(SR.GetString(SR.OrderedDictionary_ReadOnly)); } if (objectsTable.Contains(key)) { objectsTable[key] = value; objectsArray[IndexOfKey(key)] = new DictionaryEntry(key, value); } else { Add(key, value); } } } ////// Returns an arrayList of the values in the table /// public ICollection Values { get { return new OrderedDictionaryKeyValueCollection(objectsArray, false); } } ////// Adds a new entry to the table with the lowest-available index. /// public void Add(object key, object value) { if (_readOnly) { throw new NotSupportedException(SR.GetString(SR.OrderedDictionary_ReadOnly)); } objectsTable.Add(key, value); objectsArray.Add(new DictionaryEntry(key, value)); } ////// Clears all elements in the table. /// public void Clear() { if (_readOnly) { throw new NotSupportedException(SR.GetString(SR.OrderedDictionary_ReadOnly)); } objectsTable.Clear(); objectsArray.Clear(); } ////// Returns a readonly OrderedDictionary for the given OrderedDictionary. /// public OrderedDictionary AsReadOnly() { return new OrderedDictionary(this); } ////// Returns true if the key exists in the table, false otherwise. /// public bool Contains(object key) { return objectsTable.Contains(key); } ////// Copies the table to an array. This will not preserve order. /// public void CopyTo(Array array, int index) { objectsTable.CopyTo(array, index); } private int IndexOfKey(object key) { for (int i = 0; i < objectsArray.Count; i++) { object o = ((DictionaryEntry)objectsArray[i]).Key; if (_comparer != null) { if (_comparer.Equals(o, key)) { return i; } } else { if (o.Equals(key)) { return i; } } } return -1; } ////// Inserts a new object at the given index with the given key. /// public void Insert(int index, object key, object value) { if (_readOnly) { throw new NotSupportedException(SR.GetString(SR.OrderedDictionary_ReadOnly)); } if (index > Count || index < 0) { throw new ArgumentOutOfRangeException("index"); } objectsTable.Add(key, value); objectsArray.Insert(index, new DictionaryEntry(key, value)); } ////// Handles the deserization event. This method can be overridden. /// protected virtual void OnDeserialization(object sender) { if (_siInfo == null) { throw new SerializationException(SR.GetString(SR.Serialization_InvalidOnDeser)); } _comparer = (IEqualityComparer)_siInfo.GetValue(KeyComparerName, typeof(IEqualityComparer)); _readOnly = _siInfo.GetBoolean(ReadOnlyName); _initialCapacity = _siInfo.GetInt32(InitCapacityName); object[] serArray = (object[])_siInfo.GetValue(ArrayListName, typeof(object[])); if (serArray != null) { foreach (object o in serArray) { DictionaryEntry entry; try { // DictionaryEntry is a value type, so it can only be casted. entry = (DictionaryEntry)o; } catch { throw new SerializationException(SR.GetString(SR.OrderedDictionary_SerializationMismatch)); } objectsArray.Add(entry); objectsTable.Add(entry.Key, entry.Value); } } } ////// Removes the entry at the given index. /// public void RemoveAt(int index) { if (_readOnly) { throw new NotSupportedException(SR.GetString(SR.OrderedDictionary_ReadOnly)); } if (index >= Count || index < 0) { throw new ArgumentOutOfRangeException("index"); } object key = ((DictionaryEntry)objectsArray[index]).Key; objectsArray.RemoveAt(index); objectsTable.Remove(key); } ////// Removes the entry with the given key. /// public void Remove(object key) { if (_readOnly) { throw new NotSupportedException(SR.GetString(SR.OrderedDictionary_ReadOnly)); } if (key == null) { throw new ArgumentNullException("key"); } int index = IndexOfKey(key); if (index < 0) { return; } objectsTable.Remove(key); objectsArray.RemoveAt(index); } #region IDictionary implementation ///public virtual IDictionaryEnumerator GetEnumerator() { return new OrderedDictionaryEnumerator(objectsArray, OrderedDictionaryEnumerator.DictionaryEntry); } #endregion #region IEnumerable implementation /// IEnumerator IEnumerable.GetEnumerator() { return new OrderedDictionaryEnumerator(objectsArray, OrderedDictionaryEnumerator.DictionaryEntry); } #endregion #region ISerializable implementation [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase", Justification="mscorlib removed all link demands, so don't warn when overriding a method " + "with no link demand. Replace the LinkDemand with a SecurityCritical" + "annotation when the assembly is moved to the v4 security model.")] [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.SerializationFormatter)] public virtual void GetObjectData(SerializationInfo info, StreamingContext context) { if (info == null) { throw new ArgumentNullException("info"); } info.AddValue(KeyComparerName, _comparer, typeof(IEqualityComparer)); info.AddValue(ReadOnlyName, _readOnly); info.AddValue(InitCapacityName, _initialCapacity); object[] serArray = new object[Count]; _objectsArray.CopyTo(serArray); info.AddValue(ArrayListName, serArray); } #endregion #region IDeserializationCallback implementation void IDeserializationCallback.OnDeserialization(object sender) { OnDeserialization(sender); } #endregion /// /// OrderedDictionaryEnumerator works just like any other IDictionaryEnumerator, but it retrieves DictionaryEntries /// in the order by index. /// private class OrderedDictionaryEnumerator : IDictionaryEnumerator { private int _objectReturnType; internal const int Keys = 1; internal const int Values = 2; internal const int DictionaryEntry = 3; private IEnumerator arrayEnumerator; internal OrderedDictionaryEnumerator (ArrayList array, int objectReturnType) { arrayEnumerator = array.GetEnumerator(); _objectReturnType = objectReturnType; } ////// Retrieves the current DictionaryEntry. This is the same as Entry, but not strongly-typed. /// public object Current { get { if (_objectReturnType == Keys) { return ((DictionaryEntry)arrayEnumerator.Current).Key; } if (_objectReturnType == Values) { return ((DictionaryEntry)arrayEnumerator.Current).Value; } return Entry; } } ////// Retrieves the current DictionaryEntry /// public DictionaryEntry Entry { get { return new DictionaryEntry(((DictionaryEntry)arrayEnumerator.Current).Key, ((DictionaryEntry)arrayEnumerator.Current).Value); } } ////// Retrieves the key of the current DictionaryEntry /// public object Key { get { return ((DictionaryEntry)arrayEnumerator.Current).Key; } } ////// Retrieves the value of the current DictionaryEntry /// public object Value { get { return ((DictionaryEntry)arrayEnumerator.Current).Value; } } ////// Moves the enumerator pointer to the next member /// public bool MoveNext() { return arrayEnumerator.MoveNext(); } ////// Resets the enumerator pointer to the beginning. /// public void Reset() { arrayEnumerator.Reset(); } } ////// OrderedDictionaryKeyValueCollection implements a collection for the Values and Keys properties /// that is "live"- it will reflect changes to the OrderedDictionary on the collection made after the getter /// was called. /// private class OrderedDictionaryKeyValueCollection : ICollection { private ArrayList _objects; bool isKeys; public OrderedDictionaryKeyValueCollection(ArrayList array, bool isKeys) { this._objects = array; this.isKeys = isKeys; } void ICollection.CopyTo(Array array, int index) { if (array==null) throw new ArgumentNullException("array"); if (index < 0) throw new ArgumentOutOfRangeException("index"); foreach (object o in _objects) { array.SetValue(isKeys ? ((DictionaryEntry)o).Key : ((DictionaryEntry)o).Value, index); index++; } } int ICollection.Count { get { return _objects.Count; } } bool ICollection.IsSynchronized { get { return false; } } object ICollection.SyncRoot { get { return _objects.SyncRoot; } } IEnumerator IEnumerable.GetEnumerator() { return new OrderedDictionaryEnumerator(_objects, isKeys == true ? OrderedDictionaryEnumerator.Keys : OrderedDictionaryEnumerator.Values); } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- X509CertificateClaimSet.cs
- WebPartVerbsEventArgs.cs
- Stylus.cs
- SchemaImporterExtensionElement.cs
- BuildProvidersCompiler.cs
- DynamicActivity.cs
- HttpResponseInternalWrapper.cs
- ExternalDataExchangeClient.cs
- RewritingPass.cs
- UIElementHelper.cs
- DataBindingsDialog.cs
- CompatibleIComparer.cs
- ParameterBuilder.cs
- Border.cs
- ServiceControllerDesigner.cs
- DbXmlEnabledProviderManifest.cs
- EventProperty.cs
- BuildResultCache.cs
- CqlQuery.cs
- Schema.cs
- LiteralDesigner.cs
- ProfileSection.cs
- RegionData.cs
- AvTraceFormat.cs
- SerializationObjectManager.cs
- TargetControlTypeCache.cs
- DataGridViewRowContextMenuStripNeededEventArgs.cs
- ProbeRequestResponseAsyncResult.cs
- CapabilitiesAssignment.cs
- DiscoveryRequestHandler.cs
- AnnotationAuthorChangedEventArgs.cs
- CodeChecksumPragma.cs
- ArgumentOutOfRangeException.cs
- VectorValueSerializer.cs
- x509store.cs
- InputGestureCollection.cs
- ReferenceConverter.cs
- WmlSelectionListAdapter.cs
- SmtpFailedRecipientsException.cs
- AssemblyAttributesGoHere.cs
- HTTP_SERVICE_CONFIG_URLACL_KEY.cs
- CodeDirectoryCompiler.cs
- UniqueEventHelper.cs
- wmiprovider.cs
- loginstatus.cs
- NGCSerializerAsync.cs
- HostProtectionException.cs
- DiscoveryDocumentLinksPattern.cs
- Helper.cs
- DeflateEmulationStream.cs
- KoreanCalendar.cs
- ProtocolsConfigurationHandler.cs
- PropertyEmitterBase.cs
- OLEDB_Util.cs
- HostSecurityManager.cs
- BinaryHeap.cs
- CodeAttributeDeclaration.cs
- WebPartDescriptionCollection.cs
- VirtualizingStackPanel.cs
- XamlFilter.cs
- CapiNative.cs
- SystemFonts.cs
- RegexCompiler.cs
- ConfigXmlComment.cs
- BamlReader.cs
- UnauthorizedWebPart.cs
- ImageDrawing.cs
- ServiceHostingEnvironment.cs
- oledbmetadatacollectionnames.cs
- QueryOptionExpression.cs
- CodeIdentifier.cs
- CategoryGridEntry.cs
- ProcessModelInfo.cs
- PageThemeParser.cs
- RegistrationServices.cs
- XmlAnyElementAttributes.cs
- TypefaceCollection.cs
- ActiveXSerializer.cs
- AdornerHitTestResult.cs
- SimpleHandlerFactory.cs
- Context.cs
- WebPartVerb.cs
- TcpClientCredentialType.cs
- SqlRowUpdatedEvent.cs
- DocumentGridContextMenu.cs
- SurrogateChar.cs
- SerializationEventsCache.cs
- PlatformCulture.cs
- CodeCommentStatementCollection.cs
- RangeValuePattern.cs
- DataTableMapping.cs
- CodeObject.cs
- HtmlInputPassword.cs
- SimpleHandlerBuildProvider.cs
- SchemaDeclBase.cs
- SqlSupersetValidator.cs
- ValidationEventArgs.cs
- SQLInt64Storage.cs
- GenericIdentity.cs
- XmlDownloadManager.cs