Code:
/ 4.0 / 4.0 / 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.
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
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- UIHelper.cs
- Repeater.cs
- XamlParser.cs
- HtmlInputPassword.cs
- UnsafeNativeMethods.cs
- TreeViewCancelEvent.cs
- ServerIdentity.cs
- XmlSchemaComplexContentRestriction.cs
- UIElementAutomationPeer.cs
- GeneralTransform3DTo2D.cs
- WrappedIUnknown.cs
- MediaCommands.cs
- LiteralLink.cs
- DataPager.cs
- XmlWhitespace.cs
- TextBoxLine.cs
- ControlBuilderAttribute.cs
- DockAndAnchorLayout.cs
- CodeCastExpression.cs
- ColorConvertedBitmapExtension.cs
- FileStream.cs
- OdbcError.cs
- ObjectParameter.cs
- ReferentialConstraint.cs
- StatusBarDrawItemEvent.cs
- RawAppCommandInputReport.cs
- BitStack.cs
- ProcessRequestAsyncResult.cs
- DataGridViewCellStateChangedEventArgs.cs
- StandardBindingImporter.cs
- GeneralTransformCollection.cs
- PersonalizationProviderCollection.cs
- VisualStyleInformation.cs
- QilName.cs
- DbCommandTree.cs
- FontFamilyIdentifier.cs
- DataGrid.cs
- MenuAutomationPeer.cs
- FontStyle.cs
- Bitmap.cs
- Visual.cs
- TransformerInfo.cs
- NonParentingControl.cs
- DynamicArgumentDesigner.xaml.cs
- GatewayDefinition.cs
- HttpListener.cs
- _SslStream.cs
- ContextInformation.cs
- TextElementEnumerator.cs
- httpstaticobjectscollection.cs
- PointCollection.cs
- DBSqlParser.cs
- SerialReceived.cs
- CoreSwitches.cs
- HWStack.cs
- CompModHelpers.cs
- HttpDictionary.cs
- SqlServices.cs
- DataColumnPropertyDescriptor.cs
- SlipBehavior.cs
- FileEnumerator.cs
- ConstructorBuilder.cs
- WebControlParameterProxy.cs
- TypeGeneratedEventArgs.cs
- ComNativeDescriptor.cs
- BitmapEffectInputConnector.cs
- ResourcePart.cs
- srgsitem.cs
- PointUtil.cs
- MSAAWinEventWrap.cs
- MarginsConverter.cs
- WebPartVerb.cs
- InputLanguageManager.cs
- AddInProcess.cs
- Perspective.cs
- SqlRewriteScalarSubqueries.cs
- ParallelTimeline.cs
- RelationshipManager.cs
- Rectangle.cs
- Binding.cs
- LineSegment.cs
- SourceFileInfo.cs
- VisualTarget.cs
- AQNBuilder.cs
- PersonalizationStateQuery.cs
- AsyncPostBackErrorEventArgs.cs
- SubclassTypeValidator.cs
- UrlRoutingHandler.cs
- FragmentQueryProcessor.cs
- XsdBuilder.cs
- XmlSerializationReader.cs
- ChooseAction.cs
- ShapingEngine.cs
- ResourceAttributes.cs
- PreviewPrintController.cs
- UTF8Encoding.cs
- TextWriter.cs
- SystemTcpConnection.cs
- MemberDomainMap.cs
- IndexingContentUnit.cs