CacheDict.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Core / Microsoft / Scripting / Utils / CacheDict.cs / 1305376 / CacheDict.cs
                        

                        
                            /* **************************************************************************** 
 *
 * Copyright (c) Microsoft Corporation.
 *
 * This source code is subject to terms and conditions of the Microsoft Public License. A 
 * copy of the license can be found in the License.html file at the root of this distribution. If
 * you cannot locate the  Microsoft Public License, please send an email to 
 * dlr@microsoft.com. By using this source code in any fashion, you are agreeing to be bound 
 * by the terms of the Microsoft Public License.
 * 
 * You must not remove this notice, or any other, from this software.
 *
 *
 * ***************************************************************************/ 

using System; 
using System.Collections.Generic; 
using System.Text;
using System.Diagnostics; 

namespace System.Dynamic.Utils {
    /// 
    /// Provides a dictionary-like object used for caches which holds onto a maximum 
    /// number of elements specified at construction time.
    /// 
    /// This class is not thread safe. 
    /// 
    internal class CacheDict { 
        private readonly Dictionary _dict = new Dictionary();
        private readonly LinkedList _list = new LinkedList();
        private readonly int _maxSize;
 
        /// 
        /// Creates a dictionary-like object used for caches. 
        ///  
        /// The maximum number of elements to store.
        internal CacheDict(int maxSize) { 
            _maxSize = maxSize;
        }

        ///  
        /// Tries to get the value associated with 'key', returning true if it's found and
        /// false if it's not present. 
        ///  
        internal bool TryGetValue(TKey key, out TValue value) {
            KeyInfo storedValue; 
            if (_dict.TryGetValue(key, out storedValue)) {
                LinkedListNode node = storedValue.List;
                if (node.Previous != null) {
                    // move us to the head of the list... 
                    _list.Remove(node);
                    _list.AddFirst(node); 
                } 

                value = storedValue.Value; 
                return true;
            }

            value = default(TValue); 
            return false;
        } 
 
        /// 
        /// Adds a new element to the cache, replacing and moving it to the front if the 
        /// element is already present.
        /// 
        internal void Add(TKey key, TValue value) {
            KeyInfo keyInfo; 
            if (_dict.TryGetValue(key, out keyInfo)) {
                // remove original entry from the linked list 
                _list.Remove(keyInfo.List); 
            } else if (_list.Count == _maxSize) {
                // we've reached capacity, remove the last used element... 
                LinkedListNode node = _list.Last;
                _list.RemoveLast();
                bool res = _dict.Remove(node.Value);
                Debug.Assert(res); 
            }
 
            // add the new entry to the head of the list and into the dictionary 
            LinkedListNode listNode = new LinkedListNode(key);
            _list.AddFirst(listNode); 
            _dict[key] = new CacheDict.KeyInfo(value, listNode);
        }

        ///  
        /// Returns the value associated with the given key, or throws KeyNotFoundException
        /// if the key is not present. 
        ///  
        internal TValue this[TKey key] {
            get { 
                TValue res;
                if (TryGetValue(key, out res)) {
                    return res;
                } 
                throw new KeyNotFoundException();
            } 
            set { 
                Add(key, value);
            } 
        }

        private struct KeyInfo {
            internal readonly TValue Value; 
            internal readonly LinkedListNode List;
 
            internal KeyInfo(TValue value, LinkedListNode list) { 
                Value = value;
                List = list; 
            }
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

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