Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Shared / MS / Internal / WeakReferenceList.cs / 1305600 / WeakReferenceList.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 Cached ThreadSafe ArrayList of WeakReferences. /// - 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 WeakReferenceList : CopyOnWriteList, IEnumerable { public WeakReferenceList():base(null) { } public WeakReferenceList(object syncRoot):base(syncRoot) { } public WeakReferenceListEnumerator GetEnumerator() { return new WeakReferenceListEnumerator(List); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public bool Contains(object item) { Debug.Assert(null != item, "WeakReferenceList.Contains() should not be passed null."); lock (base.SyncRoot) { int index = FindWeakReference(item); // If the object is already on the list then // return true if (index >= 0) return true; return false; } } public int Count { get { int count = 0; lock (base.SyncRoot) { count = base.LiveList.Count; } return count; } } ////// Add a weak reference to the List. /// Returns true if successfully added. /// Returns false if object is already on the list. /// public override bool Add(object obj) { Debug.Assert(null!=obj, "WeakReferenceList.Add() should not be passed null."); return Add(obj, false /*skipFind*/); } //Will insert a new WeakREference into the list. //The object bein inserted MUST be unique as there is no check for it. public bool Add(object obj, bool skipFind) { Debug.Assert(null!=obj, "WeakReferenceList.Add() should not be passed null."); lock(base.SyncRoot) { if (!skipFind && FindWeakReference(obj) >= 0) { return false; } return base.Internal_Add(new WeakReference(obj)); } } ////// Remove a weak reference to the List. /// Returns true if successfully added. /// Returns false if object is already on the list. /// public override bool Remove(object obj) { Debug.Assert(null!=obj, "WeakReferenceList.Remove() should not be passed null."); lock(base.SyncRoot) { int index = FindWeakReference(obj); // If the object is not on the list then // we are done. (return false) if(index < 0) return false; return base.RemoveAt(index); } } ////// Insert a weak reference into the List. /// Returns true if successfully inserted. /// Returns false if object is already on the list. /// public bool Insert(int index, object obj) { Debug.Assert(null!=obj, "WeakReferenceList.Add() should not be passed null."); lock(base.SyncRoot) { int existingIndex = FindWeakReference(obj); // If the object is already on the list then // we are done. (return false) if(existingIndex >= 0) return false; return base.Internal_Insert(index, new WeakReference(obj)); } } ////// Find an object on the List. /// Also cleans up dead weakreferences. /// private int FindWeakReference(object obj) { // syncRoot Lock MUST be held by the caller. // Search the LiveList looking for the object, also remove any // dead references.we find. These two operations are combinded // to prevent having to walk the list twice. // // We use the "LiveList" to avoid snapping a Clone everytime we // Change something. // To do this correctly you need to understand how the base class // virtualizes the Copy On Write. ArrayList list = base.LiveList; int foundItem = -1; for(int i = 0; i < list.Count; i++) { WeakReference weakRef = (WeakReference) list[i]; if(weakRef.IsAlive) { if(obj == weakRef.Target) foundItem = i; } else { // Removing dead refs should not invalidate "foundItem" above. // Call the base RemoveAt to preserve the Copy on Write // virtualization. ie. list.RemoveAt(i) would be WRONG! // The RemoveAt call might Clone the LiveList (the first // time only) so we should get a new reference to it. base.RemoveAt(i); list = base.LiveList; // Also the ArrayList will copy-up to fill the Removed element // so back up and do the same index again. i -= 1; } } return foundItem; } } } // 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 Cached ThreadSafe ArrayList of WeakReferences. /// - 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 WeakReferenceList : CopyOnWriteList, IEnumerable { public WeakReferenceList():base(null) { } public WeakReferenceList(object syncRoot):base(syncRoot) { } public WeakReferenceListEnumerator GetEnumerator() { return new WeakReferenceListEnumerator(List); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public bool Contains(object item) { Debug.Assert(null != item, "WeakReferenceList.Contains() should not be passed null."); lock (base.SyncRoot) { int index = FindWeakReference(item); // If the object is already on the list then // return true if (index >= 0) return true; return false; } } public int Count { get { int count = 0; lock (base.SyncRoot) { count = base.LiveList.Count; } return count; } } ////// Add a weak reference to the List. /// Returns true if successfully added. /// Returns false if object is already on the list. /// public override bool Add(object obj) { Debug.Assert(null!=obj, "WeakReferenceList.Add() should not be passed null."); return Add(obj, false /*skipFind*/); } //Will insert a new WeakREference into the list. //The object bein inserted MUST be unique as there is no check for it. public bool Add(object obj, bool skipFind) { Debug.Assert(null!=obj, "WeakReferenceList.Add() should not be passed null."); lock(base.SyncRoot) { if (!skipFind && FindWeakReference(obj) >= 0) { return false; } return base.Internal_Add(new WeakReference(obj)); } } ////// Remove a weak reference to the List. /// Returns true if successfully added. /// Returns false if object is already on the list. /// public override bool Remove(object obj) { Debug.Assert(null!=obj, "WeakReferenceList.Remove() should not be passed null."); lock(base.SyncRoot) { int index = FindWeakReference(obj); // If the object is not on the list then // we are done. (return false) if(index < 0) return false; return base.RemoveAt(index); } } ////// Insert a weak reference into the List. /// Returns true if successfully inserted. /// Returns false if object is already on the list. /// public bool Insert(int index, object obj) { Debug.Assert(null!=obj, "WeakReferenceList.Add() should not be passed null."); lock(base.SyncRoot) { int existingIndex = FindWeakReference(obj); // If the object is already on the list then // we are done. (return false) if(existingIndex >= 0) return false; return base.Internal_Insert(index, new WeakReference(obj)); } } ////// Find an object on the List. /// Also cleans up dead weakreferences. /// private int FindWeakReference(object obj) { // syncRoot Lock MUST be held by the caller. // Search the LiveList looking for the object, also remove any // dead references.we find. These two operations are combinded // to prevent having to walk the list twice. // // We use the "LiveList" to avoid snapping a Clone everytime we // Change something. // To do this correctly you need to understand how the base class // virtualizes the Copy On Write. ArrayList list = base.LiveList; int foundItem = -1; for(int i = 0; i < list.Count; i++) { WeakReference weakRef = (WeakReference) list[i]; if(weakRef.IsAlive) { if(obj == weakRef.Target) foundItem = i; } else { // Removing dead refs should not invalidate "foundItem" above. // Call the base RemoveAt to preserve the Copy on Write // virtualization. ie. list.RemoveAt(i) would be WRONG! // The RemoveAt call might Clone the LiveList (the first // time only) so we should get a new reference to it. base.RemoveAt(i); list = base.LiveList; // Also the ArrayList will copy-up to fill the Removed element // so back up and do the same index again. i -= 1; } } return foundItem; } } } // 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
- GridViewPageEventArgs.cs
- DragEvent.cs
- ImageDrawing.cs
- PageThemeBuildProvider.cs
- DefaultClaimSet.cs
- DynamicValidatorEventArgs.cs
- RegexStringValidatorAttribute.cs
- MultiDataTrigger.cs
- ZipIOExtraFieldZip64Element.cs
- UnsafePeerToPeerMethods.cs
- Win32Exception.cs
- SecureUICommand.cs
- Win32Exception.cs
- LayeredChannelFactory.cs
- Vector3DValueSerializer.cs
- VisualStyleInformation.cs
- DataStreams.cs
- XmlnsDictionary.cs
- DBConcurrencyException.cs
- LinkGrep.cs
- PathData.cs
- BaseHashHelper.cs
- TextBox.cs
- XmlReaderSettings.cs
- GroupBox.cs
- InstanceCreationEditor.cs
- SortExpressionBuilder.cs
- BadImageFormatException.cs
- SynchronizedRandom.cs
- CompositeCollection.cs
- AutomationProperties.cs
- PageContent.cs
- FieldDescriptor.cs
- SQLMembershipProvider.cs
- ExpandCollapsePattern.cs
- MappingModelBuildProvider.cs
- InvalidProgramException.cs
- DataControlPagerLinkButton.cs
- WindowsGraphics.cs
- XslCompiledTransform.cs
- DataGridViewAutoSizeModeEventArgs.cs
- AuthenticationModuleElementCollection.cs
- TargetFrameworkUtil.cs
- GetWinFXPath.cs
- AsmxEndpointPickerExtension.cs
- XmlNode.cs
- DesignDataSource.cs
- ListViewItem.cs
- AncestorChangedEventArgs.cs
- FileIOPermission.cs
- SqlParameterCollection.cs
- ResourcePermissionBaseEntry.cs
- XmlExtensionFunction.cs
- BaseTemplateCodeDomTreeGenerator.cs
- WebPartVerbsEventArgs.cs
- Trace.cs
- XamlPoint3DCollectionSerializer.cs
- MemoryPressure.cs
- TableCellCollection.cs
- DataSourceCacheDurationConverter.cs
- DaylightTime.cs
- Brush.cs
- Compress.cs
- PointConverter.cs
- ControlPaint.cs
- InteropAutomationProvider.cs
- ExpressionBuilder.cs
- __FastResourceComparer.cs
- PersonalizationStateInfo.cs
- ProtectedConfigurationSection.cs
- SamlSecurityToken.cs
- xsdvalidator.cs
- QilReference.cs
- odbcmetadatacollectionnames.cs
- Grant.cs
- DesignerAdapterUtil.cs
- NullRuntimeConfig.cs
- WindowsScrollBar.cs
- CollectionBuilder.cs
- ObjectTypeMapping.cs
- SelectedDatesCollection.cs
- PropertyGridCommands.cs
- DataContext.cs
- EntityUtil.cs
- SmtpReplyReader.cs
- TypeCollectionPropertyEditor.cs
- WebEvents.cs
- ActivationWorker.cs
- OdbcException.cs
- AbstractExpressions.cs
- DBDataPermission.cs
- CompatibleIComparer.cs
- RuleSettings.cs
- OSFeature.cs
- PolygonHotSpot.cs
- OutputChannelBinder.cs
- ImageList.cs
- SchemaImporter.cs
- CommandLibraryHelper.cs
- ButtonStandardAdapter.cs