collections/specialized/nameobjectcollectionbase.cs

//------------------------------------------------------------------------------
// <copyright file="NameObjectCollectionBase.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

/*
 * Ordered String/Object collection of name/value pairs with support for null key
 *
 * This class is intended to be used as a base class
 *
 * Copyright (c) 2000 Microsoft Corporation
 */

namespace System.Collections.Specialized {

    using Microsoft.Win32;
    using System.Collections;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.Runtime.Serialization;
    using System.Security.Permissions;


    /// <devdoc>
    /// <para>Provides the <see langword='abstract '/>base class for a sorted collection of associated <see cref='System.String' qualify='true'/> keys
    ///    and <see cref='System.Object' qualify='true'/> values that can be accessed either with the hash code of
    ///    the key or with the index.</para>
    /// </devdoc>
    [Serializable()]
    public abstract class NameObjectCollectionBase : ICollection, ISerializable, IDeserializationCallback {
        // const names used for serialization
        private const String ReadOnlyName = "ReadOnly";
        private const String CountName = "Count";
        private const String ComparerName = "Comparer";
        private const String HashCodeProviderName = "HashProvider";
        private const String KeysName = "Keys";
        private const String ValuesName = "Values";
        private const String KeyComparerName = "KeyComparer";
        private const String VersionName = "Version";

        private bool _readOnly = false;
        private ArrayList _entriesArray;
        private IEqualityComparer _keyComparer;
        private volatile Hashtable _entriesTable;
        private volatile NameObjectEntry _nullKeyEntry;
        private KeysCollection _keys;
        private SerializationInfo _serializationInfo;
        private int _version;
        [NonSerialized]
        private Object _syncRoot;

        private static StringComparer defaultComparer = StringComparer.InvariantCultureIgnoreCase;

        /// <devdoc>
        /// <para> Creates an empty <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance with the default initial capacity and using the default case-insensitive hash
        ///    code provider and the default case-insensitive comparer.</para>
        /// </devdoc>
        protected NameObjectCollectionBase() :this(defaultComparer) {
        }

        protected NameObjectCollectionBase(IEqualityComparer equalityComparer)
        {
           _keyComparer = (equalityComparer == null) ? defaultComparer : equalityComparer;
           Reset();
        }

        protected NameObjectCollectionBase(Int32 capacity, IEqualityComparer equalityComparer) : this (equalityComparer)
        {
            Reset(capacity);
        }


        /// <devdoc>
        /// <para>Creates an empty <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance with
        ///    the default initial capacity and using the specified case-insensitive hash code provider and the
        ///    specified case-insensitive comparer.</para>
        /// </devdoc>

#pragma warning disable 618
        [Obsolete("Please use NameObjectCollectionBase(IEqualityComparer) instead.")]
        protected NameObjectCollectionBase(IHashCodeProvider hashProvider, IComparer comparer) {
            _keyComparer = new CompatibleComparer( comparer, hashProvider);
            Reset();
        }
#pragma warning restore 618

        /// <devdoc>
        /// <para>Creates an empty <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance with the specified
        ///    initial capacity and using the specified case-insensitive hash code provider
        ///    and the specified case-insensitive comparer.</para>
        /// </devdoc>
#pragma warning disable 618
        [Obsolete("Please use NameObjectCollectionBase(Int32, IEqualityComparer) instead.")]
        protected NameObjectCollectionBase(int capacity, IHashCodeProvider hashProvider, IComparer comparer) {
            _keyComparer = new CompatibleComparer( comparer, hashProvider);
            Reset(capacity);
        }
#pragma warning restore 618

        /// <devdoc>
        /// <para>Creates an empty <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance with the specified
        ///    initial capacity and using the default case-insensitive hash code provider
        ///    and the default case-insensitive comparer.</para>
        /// </devdoc>
        protected NameObjectCollectionBase(int capacity) {
            _keyComparer = StringComparer.InvariantCultureIgnoreCase;
            Reset(capacity);
        }

        // Allow internal extenders to avoid creating the hashtable/arraylist.
        internal NameObjectCollectionBase(DBNull dummy)
        {
        }

        //
        // Serialization support
        //

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected NameObjectCollectionBase(SerializationInfo info, StreamingContext context) {
            _serializationInfo = info;
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        [SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase", Justification = "System.dll is still using pre-v4 security model and needs this demand")]
        [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.SerializationFormatter)]
        public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {
            if (info == null)
                throw new ArgumentNullException("info");

            info.AddValue(ReadOnlyName, _readOnly);

#pragma warning disable 618
            // Maintain backward serialization compatibility if new APIs are not used.
            if( _keyComparer == defaultComparer) {
                info.AddValue(HashCodeProviderName, CompatibleComparer.DefaultHashCodeProvider, typeof(IHashCodeProvider));
                info.AddValue(ComparerName, CompatibleComparer.DefaultComparer, typeof(IComparer));
            }
            else if(_keyComparer == null) {
                info.AddValue(HashCodeProviderName, null, typeof(IHashCodeProvider));
                info.AddValue(ComparerName, null, typeof(IComparer));
            }
            else if(_keyComparer is CompatibleComparer) {
                CompatibleComparer c = (CompatibleComparer)_keyComparer;
                info.AddValue(HashCodeProviderName, c.HashCodeProvider, typeof(IHashCodeProvider));
                info.AddValue(ComparerName, c.Comparer, typeof(IComparer));
            }
            else {
                info.AddValue(KeyComparerName, _keyComparer, typeof(IEqualityComparer));
            }
#pragma warning restore 618

            int count = _entriesArray.Count;
            info.AddValue(CountName, count);

            String[] keys = new String[count];
            Object[] values = new Object[count];

            for (int i = 0; i < count; i++) {
                NameObjectEntry entry = (NameObjectEntry)_entriesArray[i];
                keys[i] = entry.Key;
                values[i] = entry.Value;
            }

            info.AddValue(KeysName, keys, typeof(String[]));
            info.AddValue(ValuesName, values, typeof(Object[]));
            info.AddValue(VersionName, _version);
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public virtual void OnDeserialization(Object sender) {
            if (_keyComparer != null) {
                return;//Somebody had a dependency on this hashtable and fixed us up before the ObjectManager got to it.
            }

            if (_serializationInfo == null)
                throw new SerializationException();

            SerializationInfo info = _serializationInfo;
            _serializationInfo = null;

            bool readOnly = false;
            int count = 0;
            String[] keys = null;
            Object[] values = null;
#pragma warning disable 618
            IHashCodeProvider hashProvider = null;
#pragma warning restore 618
            IComparer comparer = null;
            bool hasVersion = false;
            int serializedVersion = 0;

            SerializationInfoEnumerator enumerator = info.GetEnumerator();
            while( enumerator.MoveNext())
            {
                switch( enumerator.Name)
                {
                    case ReadOnlyName:
                        readOnly = info.GetBoolean(ReadOnlyName);;
                        break;
                    case HashCodeProviderName:
#pragma warning disable 618
                        hashProvider = (IHashCodeProvider)info.GetValue(HashCodeProviderName, typeof(IHashCodeProvider));;
#pragma warning restore 618
                        break;
                    case ComparerName:
                        comparer = (IComparer)info.GetValue(ComparerName, typeof(IComparer));
                        break;
                    case KeyComparerName:
                        _keyComparer = (IEqualityComparer)info.GetValue(KeyComparerName, typeof(IEqualityComparer));
                        break;
                    case CountName:
                        count = info.GetInt32(CountName);
                        break;
                    case KeysName:
                        keys = (String[])info.GetValue(KeysName, typeof(String[]));
                        break;
                    case ValuesName:
                        values = (Object[])info.GetValue(ValuesName, typeof(Object[]));
                        break;
                    case VersionName:
                        hasVersion = true;
                        serializedVersion = info.GetInt32(VersionName);
                        break;
                }
            }

            if( _keyComparer == null) {
                if(comparer == null || hashProvider == null)
                {
                    throw new SerializationException();
                }
                else {
                    // create a new key comparer for V1 Object
                    _keyComparer = new CompatibleComparer(comparer, hashProvider);
                }
            }

            if ( keys == null || values == null)
                throw new SerializationException();

            Reset(count);

            for (int i = 0; i < count; i++)
                BaseAdd(keys[i], values[i]);

            _readOnly = readOnly;  // after collection populated
            if(hasVersion) {
                _version = serializedVersion;
            }
        }

        //
        // Private helpers
        //

        private void Reset() {
            _entriesArray = new ArrayList();
            _entriesTable = new Hashtable(_keyComparer);
            _nullKeyEntry = null;
            _version++;
        }

        private void Reset(int capacity) {
            _entriesArray = new ArrayList(capacity);
            _entriesTable = new Hashtable(capacity, _keyComparer);
            _nullKeyEntry = null;
            _version++;
        }

        private NameObjectEntry FindEntry(String key) {
            if (key != null)
                return (NameObjectEntry)_entriesTable[key];
            else
                return _nullKeyEntry;
        }

        internal IEqualityComparer Comparer
        {
            get
            {
                return _keyComparer;
            }
            set
            {
                _keyComparer = value;
            }

        }


        /// <devdoc>
        /// <para>Gets or sets a value indicating whether the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance is read-only.</para>
        /// </devdoc>
        protected bool IsReadOnly {
            get { return _readOnly; }
            set { _readOnly = value; }
        }

        /// <devdoc>
        /// <para>Gets a value indicating whether the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance contains entries whose
        ///    keys are not <see langword='null'/>.</para>
        /// </devdoc>
        protected bool BaseHasKeys() {
            return (_entriesTable.Count > 0);  // any entries with keys?
        }

        //
        // Methods to add / remove entries
        //

        /// <devdoc>
        ///    <para>Adds an entry with the specified key and value into the
        ///    <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected void BaseAdd(String name, Object value) {
            if (_readOnly)
                throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));

            NameObjectEntry entry = new NameObjectEntry(name, value);

            // insert entry into hashtable
            if (name != null) {
                if (_entriesTable[name] == null)
                    _entriesTable.Add(name, entry);
            }
            else { // null key -- special case -- hashtable doesn't like null keys
                if (_nullKeyEntry == null)
                    _nullKeyEntry = entry;
            }

            // add entry to the list
            _entriesArray.Add(entry);

            _version++;
        }

        /// <devdoc>
        ///    <para>Removes the entries with the specified key from the
        ///    <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected void BaseRemove(String name) {
            if (_readOnly)
                throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));

            if (name != null) {
                // remove from hashtable
                _entriesTable.Remove(name);

                // remove from array
                for (int i = _entriesArray.Count-1; i >= 0; i--) {
                    if (_keyComparer.Equals(name, BaseGetKey(i)))
                        _entriesArray.RemoveAt(i);
                }
            }
            else { // null key -- special case
                // null out special 'null key' entry
                _nullKeyEntry = null;

                // remove from array
                for (int i = _entriesArray.Count-1; i >= 0; i--) {
                    if (BaseGetKey(i) == null)
                        _entriesArray.RemoveAt(i);
                }
            }

            _version++;
        }

        /// <devdoc>
        ///    <para> Removes the entry at the specified index of the
        ///    <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected void BaseRemoveAt(int index) {
            if (_readOnly)
                throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));

            String key = BaseGetKey(index);

            if (key != null) {
                // remove from hashtable
                _entriesTable.Remove(key);
            }
            else { // null key -- special case
                // null out special 'null key' entry
                _nullKeyEntry = null;
            }

            // remove from array
            _entriesArray.RemoveAt(index);

            _version++;
        }

        /// <devdoc>
        /// <para>Removes all entries from the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected void BaseClear() {
            if (_readOnly)
                throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));

            Reset();
        }

        //
        // Access by name
        //

        /// <devdoc>
        ///    <para>Gets the value of the first entry with the specified key from
        ///       the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected Object BaseGet(String name) {
            NameObjectEntry e = FindEntry(name);
            return (e != null) ? e.Value : null;
        }

        /// <devdoc>
        /// <para>Sets the value of the first entry with the specified key in the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/>
        /// instance, if found; otherwise, adds an entry with the specified key and value
        /// into the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/>
        /// instance.</para>
        /// </devdoc>
        protected void BaseSet(String name, Object value) {
            if (_readOnly)
                throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));

            NameObjectEntry entry = FindEntry(name);
            if (entry != null) {
                entry.Value = value;
                _version++;
            }
            else {
                BaseAdd(name, value);
            }
        }

        //
        // Access by index
        //

        /// <devdoc>
        ///    <para>Gets the value of the entry at the specified index of
        ///       the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected Object BaseGet(int index) {
            NameObjectEntry entry = (NameObjectEntry)_entriesArray[index];
            return entry.Value;
        }

        /// <devdoc>
        ///    <para>Gets the key of the entry at the specified index of the
        ///    <see cref='System.Collections.Specialized.NameObjectCollectionBase'/>
        ///    instance.</para>
        /// </devdoc>
        protected String BaseGetKey(int index) {
            NameObjectEntry entry = (NameObjectEntry)_entriesArray[index];
            return entry.Key;
        }

        /// <devdoc>
        ///    <para>Sets the value of the entry at the specified index of
        ///       the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected void BaseSet(int index, Object value) {
            if (_readOnly)
                throw new NotSupportedException(SR.GetString(SR.CollectionReadOnly));

            NameObjectEntry entry = (NameObjectEntry)_entriesArray[index];
            entry.Value = value;
            _version++;
        }

        //
        // ICollection implementation
        //

        /// <devdoc>
        /// <para>Returns an enumerator that can iterate through the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/>.</para>
        /// </devdoc>
        public virtual IEnumerator GetEnumerator() {
            return new NameObjectKeysEnumerator(this);
        }

        /// <devdoc>
        /// <para>Gets the number of key-and-value pairs in the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        public virtual int Count {
            get {
                return _entriesArray.Count;
            }
        }

        void ICollection.CopyTo(Array array, int index) {
            if (array==null) {
                throw new ArgumentNullException("array");
            }

            if (array.Rank != 1) {
                throw new ArgumentException(SR.GetString(SR.Arg_MultiRank));
            }

            if (index < 0) {
                throw new ArgumentOutOfRangeException("index",SR.GetString(SR.IndexOutOfRange, index.ToString(CultureInfo.CurrentCulture)) );
            }

            if (array.Length - index < _entriesArray.Count) {
                throw new ArgumentException(SR.GetString(SR.Arg_InsufficientSpace));
            }

            for (IEnumerator e = this.GetEnumerator(); e.MoveNext();)
                array.SetValue(e.Current, index++);
        }

        Object ICollection.SyncRoot {
            get {
                if( _syncRoot == null) {
                    System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null);
                }
                return _syncRoot;
            }
        }

        bool ICollection.IsSynchronized {
            get { return false; }
        }

        //
        //  Helper methods to get arrays of keys and values
        //

        /// <devdoc>
        /// <para>Returns a <see cref='System.String' qualify='true'/> array containing all the keys in the
        /// <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected String[] BaseGetAllKeys() {
            int n = _entriesArray.Count;
            String[] allKeys = new String[n];

            for (int i = 0; i < n; i++)
                allKeys[i] = BaseGetKey(i);

            return allKeys;
        }

        /// <devdoc>
        /// <para>Returns an <see cref='System.Object' qualify='true'/> array containing all the values in the
        /// <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected Object[] BaseGetAllValues() {
            int n = _entriesArray.Count;
            Object[] allValues = new Object[n];

            for (int i = 0; i < n; i++)
                allValues[i] = BaseGet(i);

            return allValues;
        }

        /// <devdoc>
        ///    <para>Returns an array of the specified type containing
        ///       all the values in the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        protected object[] BaseGetAllValues(Type type) {
            int n = _entriesArray.Count;
            if (type == null) {
                throw new ArgumentNullException("type");
            }
            object[] allValues = (object[]) SecurityUtils.ArrayCreateInstance(type, n);

            for (int i = 0; i < n; i++) {
                allValues[i] = BaseGet(i);
            }

            return allValues;
        }

        //
        // Keys propetry
        //

        /// <devdoc>
        /// <para>Returns a <see cref='System.Collections.Specialized.NameObjectCollectionBase.KeysCollection'/> instance containing
        ///    all the keys in the <see cref='System.Collections.Specialized.NameObjectCollectionBase'/> instance.</para>
        /// </devdoc>
        public virtual KeysCollection Keys {
            get {
                if (_keys == null)
                    _keys = new KeysCollection(this);
                return _keys;
            }
        }

        //
        // Simple entry class to allow substitution of values and indexed access to keys
        //

        internal class NameObjectEntry {

            internal NameObjectEntry(String name, Object value) {
                Key = name;
                Value = value;
            }

            internal String Key;
            internal Object Value;
        }

        //
        // Enumerator over keys of NameObjectCollection
        //

        [Serializable()]
        internal class NameObjectKeysEnumerator : IEnumerator {
            private int _pos;
            private NameObjectCollectionBase _coll;
            private int _version;

            internal NameObjectKeysEnumerator(NameObjectCollectionBase coll) {
                _coll = coll;
                _version = _coll._version;
                _pos = -1;
            }

            public bool MoveNext() {
                if ( _version != _coll._version)
                    throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));

                if( _pos < _coll.Count - 1) {
                    _pos++;
                    return true;
                }
                else {
                    _pos = _coll.Count;
                    return false;
                }

            }

            public void Reset() {
                if (_version != _coll._version)
                    throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumFailedVersion));
                _pos = -1;
            }

            public Object Current {
                get {
                    if(_pos >= 0 && _pos < _coll.Count) {
                        return _coll.BaseGetKey(_pos);
                    }
                    else {
                        throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_EnumOpCantHappen));
                    }
                }
            }
        }

        //
        // Keys collection
        //

        /// <devdoc>
        /// <para>Represents a collection of the <see cref='System.String' qualify='true'/> keys of a collection.</para>
        /// </devdoc>
        [Serializable()]
        public class KeysCollection : ICollection {

            private NameObjectCollectionBase _coll;

            internal KeysCollection(NameObjectCollectionBase coll) {
                _coll = coll;
            }

            // Indexed access

            /// <devdoc>
            ///    <para> Gets the key at the specified index of the collection.</para>
            /// </devdoc>
            public virtual String Get(int index) {
                return _coll.BaseGetKey(index);
            }

            /// <devdoc>
            ///    <para>Represents the entry at the specified index of the collection.</para>
            /// </devdoc>
            public String this[int index] {
                get {
                    return Get(index);
                }
            }

            // ICollection implementation

            /// <devdoc>
            ///    <para>Returns an enumerator that can iterate through the
            ///    <see cref='System.Collections.Specialized.NameObjectCollectionBase.KeysCollection'/>.</para>
            /// </devdoc>
            public IEnumerator GetEnumerator() {
                return new NameObjectKeysEnumerator(_coll);
            }

            /// <devdoc>
            /// <para>Gets the number of keys in the <see cref='System.Collections.Specialized.NameObjectCollectionBase.KeysCollection'/>.</para>
            /// </devdoc>
            public int Count {
                get {
                    return _coll.Count;
                }
            }

            void ICollection.CopyTo(Array array, int index) {
                if (array==null) {
                    throw new ArgumentNullException("array");
                }

                if (array.Rank != 1) {
                    throw new ArgumentException(SR.GetString(SR.Arg_MultiRank));
                }

                if (index < 0) {
                    throw new ArgumentOutOfRangeException("index",SR.GetString(SR.IndexOutOfRange, index.ToString(CultureInfo.CurrentCulture)) );
                }

                if (array.Length - index < _coll.Count) {
                    throw new ArgumentException(SR.GetString(SR.Arg_InsufficientSpace));
                }

                for (IEnumerator e = this.GetEnumerator(); e.MoveNext();)
                    array.SetValue(e.Current, index++);
            }

            Object ICollection.SyncRoot {
                get { return ((ICollection)_coll).SyncRoot; }
            }


            bool ICollection.IsSynchronized {
                get { return false; }
            }
        }
    }

    [Serializable()]
    internal class CompatibleComparer: IEqualityComparer  {
        IComparer _comparer;
        static volatile IComparer defaultComparer;
        // Needed for compatability
#pragma warning disable 618
        IHashCodeProvider _hcp;

        static volatile IHashCodeProvider defaultHashProvider;

        internal CompatibleComparer(IComparer comparer, IHashCodeProvider hashCodeProvider) {
            _comparer = comparer;
            _hcp = hashCodeProvider;
        }
#pragma warning restore 618

        public new bool Equals(Object a, Object b) {
            if (a == b) return true;
            if (a == null || b == null) return false;

            // We must call Compare or CompareTo method
            // to make sure everything is fine, but the
            // guideline is that Equals should never throw.
            // So we need to ignore ArgumentException (note this
            // is the exception we should get if two objects are not
            // comparable.)

            try {
                if (_comparer != null)
                    return (_comparer.Compare(a,b) == 0);

                IComparable ia = a as IComparable;
                if (ia != null)
                    return (ia.CompareTo(b) ==0);
            }
            catch(ArgumentException) {
                return false;
            }

            return a.Equals(b);
        }

        public int GetHashCode(Object obj) {
            if( obj == null) {
                throw new ArgumentNullException("obj");
            }

            if (_hcp != null)
                return _hcp.GetHashCode(obj);
            return obj.GetHashCode();
        }

        public IComparer Comparer {
            get {
                return _comparer;
            }
        }

#pragma warning disable 618
        public IHashCodeProvider HashCodeProvider {
            get {
                return _hcp;
            }
        }
#pragma warning restore 618

        public static IComparer DefaultComparer {
            get {
                if( defaultComparer == null) {
                    defaultComparer = new CaseInsensitiveComparer(CultureInfo.InvariantCulture);
                }
                return defaultComparer;
            }
        }

#pragma warning disable 618
        public static IHashCodeProvider DefaultHashCodeProvider {
            get {
                if( defaultHashProvider == null) {
                    defaultHashProvider = new CaseInsensitiveHashCodeProvider(CultureInfo.InvariantCulture);
                }
                return defaultHashProvider;
            }
        }
#pragma warning restore 618
    }
}