CopyOnWriteList.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 / wpf / src / Shared / MS / Internal / CopyOnWriteList.cs / 1305600 / CopyOnWriteList.cs
                        

                        
                            using System; 
using System.Collections;
using System.Diagnostics;

#if WINDOWS_BASE 
    using MS.Internal.WindowsBase;
#elif PRESENTATION_CORE 
    using MS.Internal.PresentationCore; 
#elif PRESENTATIONFRAMEWORK
    using MS.Internal.PresentationFramework; 
#elif DRT
    using MS.Internal.Drt;
#else
#error Attempt to use FriendAccessAllowedAttribute from an unknown assembly. 
using MS.Internal.YourAssemblyName;
#endif 
 
namespace MS.Internal
{ 
    /// 
    ///   This is a ThreadSafe ArrayList that uses Copy On Write to support consistency.
    ///   - When the "List" property is requested a readonly reference to the
    ///   list is returned and a reference to the readonly list is cached. 
    ///   - If the "List" is requested again, the same cached reference is returned.
    ///   - When the list is modified, if a readonly reference is present in the 
    ///   cache then the list is copied before it is modified and the readonly list is 
    ///   released from the cache.
    ///  
    [FriendAccessAllowed]
    internal class CopyOnWriteList
    {
        public CopyOnWriteList() : this(null) 
        {
        } 
 
        public CopyOnWriteList(object syncRoot)
        { 
            if(syncRoot == null)
            {
                syncRoot = new Object();
            } 
            _syncRoot = syncRoot;
        } 
 
        /// 
        ///   Return a readonly wrapper of the list.  Note: this is NOT a copy. 
        ///   A non-null _readonlyWrapper  is a "Copy on Write" flag.
        ///   Methods that change the list (eg. Add() and Remove()) are
        ///   responsible for:
        ///    1) Checking _readonlyWrapper and copying the list before modifing it. 
        ///    2) Clearing _readonlyWrapper.
        ///  
        public ArrayList List 
        {
            get 
            {
                ArrayList tempList;

                lock(_syncRoot) 
                {
                    if(null == _readonlyWrapper) 
                        _readonlyWrapper = ArrayList.ReadOnly(_LiveList); 
                    tempList = _readonlyWrapper;
                } 
                return tempList;
            }
        }
 
        /// 
        ///   Add an object to the List. 
        ///   Returns true if successfully added. 
        ///   Returns false if object is already on the list.
        ///  
        public virtual bool Add(object obj)
        {
            Debug.Assert(null!=obj, "CopyOnWriteList.Add() should not be passed null.");
            lock(_syncRoot) 
            {
                int index = Find(obj); 
 
                if(index >= 0)
                    return false; 

                return Internal_Add(obj);
            }
        } 

        ///  
        ///   Remove an object from the List. 
        ///   Returns true if successfully removed.
        ///   Returns false if object was not on the list. 
        /// 
        public virtual bool Remove(object obj)
        {
            Debug.Assert(null!=obj, "CopyOnWriteList.Remove() should not be passed null."); 
            lock(_syncRoot)
            { 
                int index = Find(obj); 

                // If the object is not on the list then 
                // we are done.  (return false)
                if(index < 0)
                    return false;
 
                return RemoveAt(index);
            } 
        } 

        ///  
        ///   This allows derived classes to take the lock.  This is mostly used
        ///   to extend Add() and Remove() etc.
        /// 
        protected object SyncRoot 
        {
            get{ return _syncRoot; } 
        } 

        ///  
        ///  This is protected and the caller can get into real serious trouble
        ///  using this.  Because this points at the real current list without
        ///  any copy on write protection.  So the caller must really know what
        ///  they are doing. 
        /// 
        protected ArrayList LiveList 
        { 
            get{ return _LiveList; }
        } 

        /// 
        ///   Add an object to the List.
        ///   Without any error checks. 
        ///   For use by derived classes that implement there own error checks.
        ///  
        protected bool Internal_Add(object obj) 
        {
            DoCopyOnWriteCheck(); 
            _LiveList.Add(obj);
            return true;
        }
 
        /// 
        ///   Insert an object into the List at the given index. 
        ///   Without any error checks. 
        ///   For use by derived classes that implement there own error checks.
        ///  
        protected bool Internal_Insert(int index, object obj)
        {
            DoCopyOnWriteCheck();
            _LiveList.Insert(index, obj); 
            return true;
        } 
 
        /// 
        ///   Find an object on the List. 
        /// 
        private int Find(object obj)
        {
            // syncRoot Lock MUST be held by the caller. 
            for(int i = 0; i < _LiveList.Count; i++)
            { 
                if(obj == _LiveList[i]) 
                {
                    return i; 
                }
            }
            return -1;
        } 

        ///  
        ///   Remove the object at a given index from the List. 
        ///   Returns true if successfully removed.
        ///   Returns false if index is outside the range of the list. 
        ///
        ///  This is protected because it operates on the LiveList
        /// 
        protected bool RemoveAt(int index) 
        {
            // syncRoot Lock MUST be held by the caller. 
            if(index <0 || index >= _LiveList.Count ) 
                return false;
 
            DoCopyOnWriteCheck();
            _LiveList.RemoveAt(index);
            return true;
        } 

        private void DoCopyOnWriteCheck() 
        { 
            // syncRoot Lock MUST be held by the caller.
            // If we have exposed (given out) a readonly reference to this 
            // version of the list, then clone a new internal copy and cut
            // the old version free.
            if(null != _readonlyWrapper)
            { 
                _LiveList = (ArrayList)_LiveList.Clone();
                _readonlyWrapper = null; 
            } 
        }
 
        private object _syncRoot;
        private ArrayList _LiveList = new ArrayList();
        private ArrayList _readonlyWrapper;
    } 
}

// 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