PersonalizationStateInfoCollection.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / UI / WebParts / PersonalizationStateInfoCollection.cs / 2 / PersonalizationStateInfoCollection.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.UI.WebControls.WebParts { 
    using System; 
    using System.Collections;
    using System.Collections.Generic; 
    using System.Security.Permissions;
    using System.Web.Util;

    [Serializable] 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public sealed class PersonalizationStateInfoCollection : ICollection { 
 
        private Dictionary _indices;
        private bool _readOnly; 

        // Tried to use the generic type List instead, but it's readonly
        // implementation returns a different type that is not assignable to List.
        // That would require to maintain two different fields, one for the readonly 
        // collection when set and one for the modifiable collection version.
        // 
        // So, the cleaner solution is to use ArrayList, though it might have a 
        // slightly slower perf because of explicit casting.
        private ArrayList _values; 

        public PersonalizationStateInfoCollection() {
            _indices = new Dictionary(KeyComparer.Default);
            _values = new ArrayList(); 
        }
 
        public int Count { 
            get {
                return _values.Count; 
            }
        }

        public PersonalizationStateInfo this[string path, string username] { 
            get {
                if (path == null) { 
                    throw new ArgumentNullException("path"); 
                }
 
                Key key = new Key(path, username);
                int index;
                if (!_indices.TryGetValue(key, out index)) {
                    return null; 
                }
                return (PersonalizationStateInfo) _values[index]; 
            } 
        }
 
        public PersonalizationStateInfo this[int index] {
            get {
                return (PersonalizationStateInfo) _values[index];
            } 
        }
 
        public void Add(PersonalizationStateInfo data) { 
            if (data == null) {
                throw new ArgumentNullException("data"); 
            }

            Key key;
            UserPersonalizationStateInfo userData = data as UserPersonalizationStateInfo; 
            if (userData != null) {
                key = new Key(userData.Path, userData.Username); 
            } 
            else {
                key = new Key(data.Path, null); 
            }

            // VSWhidbey 376063: avoid key duplicate, we check here first before we add.
            if (_indices.ContainsKey(key)) { 
                if (userData != null) {
                    throw new ArgumentException(SR.GetString( 
                            SR.PersonalizationStateInfoCollection_CouldNotAddUserStateInfo, 
                            key.Path, key.Username));
                } 
                else {
                    throw new ArgumentException(SR.GetString(
                            SR.PersonalizationStateInfoCollection_CouldNotAddSharedStateInfo,
                            key.Path)); 
                }
            } 
 
            int pos = _values.Add(data);
            try { 
                _indices.Add(key, pos);
            }
            catch {
                // Roll back the first addition to make the whole addition atomic 
                _values.RemoveAt(pos);
                throw; 
            } 
        }
 
        public void Clear() {
            _values.Clear();
            _indices.Clear();
        } 

        public void CopyTo(PersonalizationStateInfo[] array, int index) { 
            _values.CopyTo(array, index); 
        }
 
        public IEnumerator GetEnumerator() {
            return _values.GetEnumerator();
        }
 
        public bool IsSynchronized {
            get { 
                return false; 
            }
        } 

        public void Remove(string path, string username) {
            if (path == null) {
                throw new ArgumentNullException("path"); 
            }
 
            Key key = new Key(path, username); 
            int ipos;
            if (!_indices.TryGetValue(key, out ipos)) { 
                return;
            }
            Debug.Assert(ipos >= 0 && ipos < _values.Count);
 
            _indices.Remove(key);
            try { 
                _values.RemoveAt(ipos); 
            }
            catch { 
                // Roll back the first addition to make the whole addition atomic
                _indices.Add(key, ipos);
                throw;
            } 

            // Readjust the values' indices by -1 where the indices are greater than the removed index 
            ArrayList al = new ArrayList(); 
            foreach(KeyValuePair de in _indices) {
                if (de.Value > ipos) { 
                    al.Add(de.Key);
                }
            }
            foreach (Key k in al) { 
                _indices[k] = ((int) _indices[k]) - 1;
            } 
        } 

        public void SetReadOnly() { 
            if (_readOnly) {
                return;
            }
            _readOnly = true; 
            _values = ArrayList.ReadOnly(_values);
        } 
 
        public object SyncRoot {
            get { 
                return this;
            }
        }
 
        void ICollection.CopyTo(Array array, int index) {
            _values.CopyTo(array, index); 
        } 

        [Serializable] 
        private sealed class Key {
            public string Path;
            public string Username;
 
            internal Key(string path, string username) {
                Debug.Assert(path != null); 
                Path = path; 
                Username = username;
            } 
        }

        [Serializable]
        private sealed class KeyComparer : IEqualityComparer { 
            internal static readonly IEqualityComparer Default = new KeyComparer();
 
            bool IEqualityComparer.Equals(Key x, Key y) { 
                return (Compare(x, y) == 0);
            } 

            int IEqualityComparer.GetHashCode(Key key) {
                if (key == null) {
                    return 0; 
                }
 
                Debug.Assert(key.Path != null); 
                int pathHashCode = key.Path.ToLowerInvariant().GetHashCode();
                int usernameHashCode = 0; 
                if (key.Username != null) {
                    usernameHashCode = key.Username.ToLowerInvariant().GetHashCode();
                }
                return HashCodeCombiner.CombineHashCodes(pathHashCode, usernameHashCode); 
            }
 
            private int Compare(Key x, Key y) { 
                if (x == null && y == null) {
                    return 0; 
                }
                if (x == null) {
                    return -1;
                } 
                if (y == null) {
                    return 1; 
                } 

                int pathDiff = String.Compare(x.Path, y.Path, 
                                              StringComparison.OrdinalIgnoreCase);
                if (pathDiff != 0) {
                    return pathDiff;
                } 
                else {
                    return String.Compare(x.Username, y.Username, 
                                          StringComparison.OrdinalIgnoreCase); 
                }
            } 
        }
    }
}

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK