ObservableCollection.cs

Go to the documentation of this file.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
 
namespace System.Collections.ObjectModel;
 
[Serializable]
[DebuggerTypeProxy(typeof(CollectionDebugView<>))]
[DebuggerDisplay("Count = {Count}")]
[TypeForwardedFrom("WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged
{
    [Serializable]
    [TypeForwardedFrom("WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    private sealed class SimpleMonitor : IDisposable
    {
        internal int _busyCount;
 
        [NonSerialized]
        internal ObservableCollection<T> _collection;
 
        public SimpleMonitor(ObservableCollection<T> collection)
        {
            _collection = collection;
        }
        public SimpleMonitor(ObservableCollection<T> collection) {…}
 
        public void Dispose()
        {
            _collection._blockReentrancyCount--;
        }
        public void Dispose() {…}
    }
    private sealed class SimpleMonitor : IDisposable {…};
 
    private SimpleMonitor _monitor;
 
    [NonSerialized]
    private int _blockReentrancyCount;
 
    event PropertyChangedEventHandler? INotifyPropertyChanged.PropertyChanged
    {
        add
        {
            PropertyChanged += value;
        }
        remove
        {
            PropertyChanged -= value;
        }
    }
    event PropertyChangedEventHandler? INotifyPropertyChanged.PropertyChanged {…};
 
    public virtual event NotifyCollectionChangedEventHandler? CollectionChanged;
 
    protected virtual event PropertyChangedEventHandler? PropertyChanged;
 
    public ObservableCollection()
    {
    }
    public ObservableCollection() {…}
 
    public ObservableCollection(IEnumerable<T> collection)
        : base((IList<T>)CreateCopy(collection, "collection"))
    {
    }
    public ObservableCollection(IEnumerable<T> collection) {…}
 
    public ObservableCollection(List<T> list)
        : base((IList<T>)CreateCopy(list, "list"))
    {
    }
    public ObservableCollection(List<T> list) {…}
 
    private static List<T> CreateCopy(IEnumerable<T> collection, string paramName)
    {
        if (collection == null)
        {
            throw new ArgumentNullException(paramName);
        }
        return new List<T>(collection);
    }
    private static List<T> CreateCopy(IEnumerable<T> collection, string paramName) {…}
 
    public void Move(int oldIndex, int newIndex)
    {
        MoveItem(oldIndex, newIndex);
    }
    public void Move(int oldIndex, int newIndex) {…}
 
    protected override void ClearItems()
    {
        CheckReentrancy();
        base.ClearItems();
        OnCountPropertyChanged();
        OnIndexerPropertyChanged();
        OnCollectionReset();
    }
    protected override void ClearItems() {…}
 
    protected override void RemoveItem(int index)
    {
        CheckReentrancy();
        T val = base[index];
        base.RemoveItem(index);
        OnCountPropertyChanged();
        OnIndexerPropertyChanged();
        OnCollectionChanged(NotifyCollectionChangedAction.Remove, val, index);
    }
    protected override void RemoveItem(int index) {…}
 
    protected override void InsertItem(int index, T item)
    {
        CheckReentrancy();
        base.InsertItem(index, item);
        OnCountPropertyChanged();
        OnIndexerPropertyChanged();
        OnCollectionChanged(NotifyCollectionChangedAction.Add, item, index);
    }
    protected override void InsertItem(int index, T item) {…}
 
    protected override void SetItem(int index, T item)
    {
        CheckReentrancy();
        T val = base[index];
        base.SetItem(index, item);
        OnIndexerPropertyChanged();
        OnCollectionChanged(NotifyCollectionChangedAction.Replace, val, item, index);
    }
    protected override void SetItem(int index, T item) {…}
 
    protected virtual void MoveItem(int oldIndex, int newIndex)
    {
        CheckReentrancy();
        T val = base[oldIndex];
        base.RemoveItem(oldIndex);
        base.InsertItem(newIndex, val);
        OnIndexerPropertyChanged();
        OnCollectionChanged(NotifyCollectionChangedAction.Move, val, newIndex, oldIndex);
    }
    protected virtual void MoveItem(int oldIndex, int newIndex) {…}
 
    protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        this.PropertyChanged?.Invoke(this, e);
    }
    protected virtual void OnPropertyChanged(PropertyChangedEventArgs e) {…}
 
    protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        NotifyCollectionChangedEventHandler collectionChanged = this.CollectionChanged;
        if (collectionChanged != null)
        {
            _blockReentrancyCount++;
            try
            {
                collectionChanged(this, e);
            }
            finally
            {
                _blockReentrancyCount--;
            }
        }
    }
    protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e) {…}
 
    protected IDisposable BlockReentrancy()
    {
        _blockReentrancyCount++;
        return EnsureMonitorInitialized();
    }
    protected IDisposable BlockReentrancy() {…}
 
    protected void CheckReentrancy()
    {
        if (_blockReentrancyCount > 0)
        {
            NotifyCollectionChangedEventHandler collectionChanged = this.CollectionChanged;
            if (collectionChanged != null && collectionChanged.GetInvocationList().Length > 1)
            {
                throw new InvalidOperationException(System.SR.ObservableCollectionReentrancyNotAllowed);
            }
        }
    }
    protected void CheckReentrancy() {…}
 
    private void OnCountPropertyChanged()
    {
        OnPropertyChanged(EventArgsCache.CountPropertyChanged);
    }
    private void OnCountPropertyChanged() {…}
 
    private void OnIndexerPropertyChanged()
    {
        OnPropertyChanged(EventArgsCache.IndexerPropertyChanged);
    }
    private void OnIndexerPropertyChanged() {…}
 
    private void OnCollectionChanged(NotifyCollectionChangedAction action, object item, int index)
    {
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item, index));
    }
    private void OnCollectionChanged(NotifyCollectionChangedAction action, object item, int index) {…}
 
    private void OnCollectionChanged(NotifyCollectionChangedAction action, object item, int index, int oldIndex)
    {
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item, index, oldIndex));
    }
    private void OnCollectionChanged(NotifyCollectionChangedAction action, object item, int index, int oldIndex) {…}
 
    private void OnCollectionChanged(NotifyCollectionChangedAction action, object oldItem, object newItem, int index)
    {
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index));
    }
    private void OnCollectionChanged(NotifyCollectionChangedAction action, object oldItem, object newItem, int index) {…}
 
    private void OnCollectionReset()
    {
        OnCollectionChanged(EventArgsCache.ResetCollectionChanged);
    }
    private void OnCollectionReset() {…}
 
    private SimpleMonitor EnsureMonitorInitialized()
    {
        return _monitor ?? (_monitor = new SimpleMonitor(this));
    }
    private SimpleMonitor EnsureMonitorInitialized() {…}
 
    [OnSerializing]
    private void OnSerializing(StreamingContext context)
    {
        EnsureMonitorInitialized();
        _monitor._busyCount = _blockReentrancyCount;
    }
    private void OnSerializing(StreamingContext context) {…}
 
    [OnDeserialized]
    private void OnDeserialized(StreamingContext context)
    {
        if (_monitor != null)
        {
            _blockReentrancyCount = _monitor._busyCount;
            _monitor._collection = this;
        }
    }
    private void OnDeserialized(StreamingContext context) {…}
}
public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged {…};