NotifyCollectionChangedEventArgs.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 / CompMod / System / Collections / Specialized / NotifyCollectionChangedEventArgs.cs / 1305376 / NotifyCollectionChangedEventArgs.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: NotifyCollectionChanged event arguments 
// 
// Specs:       http://avalon/connecteddata/Specs/INotifyCollectionChanged.mht
// 
//---------------------------------------------------------------------------

using System;
using System.Collections; 
using System.Diagnostics.Contracts;
using System.Runtime.CompilerServices; 
 
namespace System.Collections.Specialized
{ 
    /// 
    /// This enum describes the action that caused a CollectionChanged event.
    /// 
    [TypeForwardedFrom("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")] 
    public enum NotifyCollectionChangedAction
    { 
        ///  One or more items were added to the collection.  
        Add,
        ///  One or more items were removed from the collection.  
        Remove,
        ///  One or more items were replaced in the collection. 
        Replace,
        ///  One or more items were moved within the collection.  
        Move,
        ///  The contents of the collection changed dramatically.  
        Reset, 
    }
 
    /// 
    /// Arguments for the CollectionChanged event.
    /// A collection that supports INotifyCollectionChangedThis raises this event
    /// whenever an item is added or removed, or when the contents of the collection 
    /// changes dramatically.
    ///  
    [TypeForwardedFrom("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")] 
    public class NotifyCollectionChangedEventArgs : EventArgs
    { 
        //-----------------------------------------------------
        //
        //  Constructors
        // 
        //-----------------------------------------------------
 
        ///  
        /// Construct a NotifyCollectionChangedEventArgs that describes a reset change.
        ///  
        /// The action that caused the event (must be Reset).
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action)
        {
            if (action != NotifyCollectionChangedAction.Reset) 
                throw new ArgumentException(SR.GetString(SR.WrongActionForCtor, NotifyCollectionChangedAction.Reset), "action");
 
            InitializeAdd(action, null, -1); 
        }
 
        /// 
        /// Construct a NotifyCollectionChangedEventArgs that describes a one-item change.
        /// 
        /// The action that caused the event; can only be Reset, Add or Remove action. 
        /// The item affected by the change.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem) 
        { 
            if ((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove)
                    && (action != NotifyCollectionChangedAction.Reset)) 
                throw new ArgumentException(SR.GetString(SR.MustBeResetAddOrRemoveActionForCtor), "action");

            if (action == NotifyCollectionChangedAction.Reset)
            { 
                if (changedItem != null)
                    throw new ArgumentException(SR.GetString(SR.ResetActionRequiresNullItem), "action"); 
 
                InitializeAdd(action, null, -1);
            } 
            else
            {
                InitializeAddOrRemove(action, new object[]{changedItem}, -1);
            } 
        }
 
        ///  
        /// Construct a NotifyCollectionChangedEventArgs that describes a one-item change.
        ///  
        /// The action that caused the event.
        /// The item affected by the change.
        /// The index where the change occurred.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index) 
        {
            if ((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove) 
                    && (action != NotifyCollectionChangedAction.Reset)) 
                throw new ArgumentException(SR.GetString(SR.MustBeResetAddOrRemoveActionForCtor), "action");
 
            if (action == NotifyCollectionChangedAction.Reset)
            {
                if (changedItem != null)
                    throw new ArgumentException(SR.GetString(SR.ResetActionRequiresNullItem), "action"); 
                if (index != -1)
                    throw new ArgumentException(SR.GetString(SR.ResetActionRequiresIndexMinus1), "action"); 
 
                InitializeAdd(action, null, -1);
            } 
            else
            {
                InitializeAddOrRemove(action, new object[]{changedItem}, index);
            } 
        }
 
        ///  
        /// Construct a NotifyCollectionChangedEventArgs that describes a multi-item change.
        ///  
        /// The action that caused the event.
        /// The items affected by the change.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems)
        { 
            if ((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove)
                    && (action != NotifyCollectionChangedAction.Reset)) 
                throw new ArgumentException(SR.GetString(SR.MustBeResetAddOrRemoveActionForCtor), "action"); 

            if (action == NotifyCollectionChangedAction.Reset) 
            {
                if (changedItems != null)
                    throw new ArgumentException(SR.GetString(SR.ResetActionRequiresNullItem), "action");
 
                InitializeAdd(action, null, -1);
            } 
            else 
            {
                if (changedItems == null) 
                    throw new ArgumentNullException("changedItems");

                InitializeAddOrRemove(action, changedItems, -1);
            } 
        }
 
        ///  
        /// Construct a NotifyCollectionChangedEventArgs that describes a multi-item change (or a reset).
        ///  
        /// The action that caused the event.
        /// The items affected by the change.
        /// The index where the change occurred.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems, int startingIndex) 
        {
            if ((action != NotifyCollectionChangedAction.Add) && (action != NotifyCollectionChangedAction.Remove) 
                    && (action != NotifyCollectionChangedAction.Reset)) 
                throw new ArgumentException(SR.GetString(SR.MustBeResetAddOrRemoveActionForCtor), "action");
 
            if (action == NotifyCollectionChangedAction.Reset)
            {
                if (changedItems != null)
                    throw new ArgumentException(SR.GetString(SR.ResetActionRequiresNullItem), "action"); 
                if (startingIndex != -1)
                    throw new ArgumentException(SR.GetString(SR.ResetActionRequiresIndexMinus1), "action"); 
 
                InitializeAdd(action, null, -1);
            } 
            else
            {
                if (changedItems == null)
                    throw new ArgumentNullException("changedItems"); 
                if (startingIndex < -1)
                    throw new ArgumentException(SR.GetString(SR.IndexCannotBeNegative), "startingIndex"); 
 
                InitializeAddOrRemove(action, changedItems, startingIndex);
            } 
        }

        /// 
        /// Construct a NotifyCollectionChangedEventArgs that describes a one-item Replace event. 
        /// 
        /// Can only be a Replace action. 
        /// The new item replacing the original item. 
        /// The original item that is replaced.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object newItem, object oldItem) 
        {
            if (action != NotifyCollectionChangedAction.Replace)
                throw new ArgumentException(SR.GetString(SR.WrongActionForCtor, NotifyCollectionChangedAction.Replace), "action");
 
            InitializeMoveOrReplace(action, new object[]{newItem}, new object[]{oldItem}, -1, -1);
        } 
 
        /// 
        /// Construct a NotifyCollectionChangedEventArgs that describes a one-item Replace event. 
        /// 
        /// Can only be a Replace action.
        /// The new item replacing the original item.
        /// The original item that is replaced. 
        /// The index of the item being replaced.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object newItem, object oldItem, int index) 
        { 
            if (action != NotifyCollectionChangedAction.Replace)
                throw new ArgumentException(SR.GetString(SR.WrongActionForCtor, NotifyCollectionChangedAction.Replace), "action"); 

            InitializeMoveOrReplace(action, new object[]{newItem}, new object[]{oldItem}, index, index);
        }
 
        /// 
        /// Construct a NotifyCollectionChangedEventArgs that describes a multi-item Replace event. 
        ///  
        /// Can only be a Replace action.
        /// The new items replacing the original items. 
        /// The original items that are replaced.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList newItems, IList oldItems)
        {
            if (action != NotifyCollectionChangedAction.Replace) 
                throw new ArgumentException(SR.GetString(SR.WrongActionForCtor, NotifyCollectionChangedAction.Replace), "action");
            if (newItems == null) 
                throw new ArgumentNullException("newItems"); 
            if (oldItems == null)
                throw new ArgumentNullException("oldItems"); 

            InitializeMoveOrReplace(action, newItems, oldItems, -1, -1);
        }
 
        /// 
        /// Construct a NotifyCollectionChangedEventArgs that describes a multi-item Replace event. 
        ///  
        /// Can only be a Replace action.
        /// The new items replacing the original items. 
        /// The original items that are replaced.
        /// The starting index of the items being replaced.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList newItems, IList oldItems, int startingIndex)
        { 
            if (action != NotifyCollectionChangedAction.Replace)
                throw new ArgumentException(SR.GetString(SR.WrongActionForCtor, NotifyCollectionChangedAction.Replace), "action"); 
            if (newItems == null) 
                throw new ArgumentNullException("newItems");
            if (oldItems == null) 
                throw new ArgumentNullException("oldItems");

            InitializeMoveOrReplace(action, newItems, oldItems, startingIndex, startingIndex);
        } 

        ///  
        /// Construct a NotifyCollectionChangedEventArgs that describes a one-item Move event. 
        /// 
        /// Can only be a Move action. 
        /// The item affected by the change.
        /// The new index for the changed item.
        /// The old index for the changed item.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index, int oldIndex) 
        {
            if (action != NotifyCollectionChangedAction.Move) 
                throw new ArgumentException(SR.GetString(SR.WrongActionForCtor, NotifyCollectionChangedAction.Move), "action"); 
            if (index < 0)
                throw new ArgumentException(SR.GetString(SR.IndexCannotBeNegative), "index"); 

            object[] changedItems= new object[] {changedItem};
            InitializeMoveOrReplace(action, changedItems, changedItems, index, oldIndex);
        } 

        ///  
        /// Construct a NotifyCollectionChangedEventArgs that describes a multi-item Move event. 
        /// 
        /// The action that caused the event. 
        /// The items affected by the change.
        /// The new index for the changed items.
        /// The old index for the changed items.
        public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems, int index, int oldIndex) 
        {
            if (action != NotifyCollectionChangedAction.Move) 
                throw new ArgumentException(SR.GetString(SR.WrongActionForCtor, NotifyCollectionChangedAction.Move), "action"); 
            if (index < 0)
                throw new ArgumentException(SR.GetString(SR.IndexCannotBeNegative), "index"); 

            InitializeMoveOrReplace(action, changedItems, changedItems, index, oldIndex);
        }
 
        private void InitializeAddOrRemove(NotifyCollectionChangedAction action, IList changedItems, int startingIndex)
        { 
            if (action == NotifyCollectionChangedAction.Add) 
                InitializeAdd(action, changedItems, startingIndex);
            else if (action == NotifyCollectionChangedAction.Remove) 
                InitializeRemove(action, changedItems, startingIndex);
            else
                Contract.Assert(false, String.Format("Unsupported action: {0}", action.ToString()));
        } 

        private void InitializeAdd(NotifyCollectionChangedAction action, IList newItems, int newStartingIndex) 
        { 
            _action = action;
            _newItems = (newItems == null) ? null : ArrayList.ReadOnly(newItems); 
            _newStartingIndex = newStartingIndex;
        }

        private void InitializeRemove(NotifyCollectionChangedAction action, IList oldItems, int oldStartingIndex) 
        {
            _action = action; 
            _oldItems = (oldItems == null) ? null : ArrayList.ReadOnly(oldItems); 
            _oldStartingIndex= oldStartingIndex;
        } 

        private void InitializeMoveOrReplace(NotifyCollectionChangedAction action, IList newItems, IList oldItems, int startingIndex, int oldStartingIndex)
        {
            InitializeAdd(action, newItems, startingIndex); 
            InitializeRemove(action, oldItems, oldStartingIndex);
        } 
 
        //------------------------------------------------------
        // 
        //  Public Properties
        //
        //-----------------------------------------------------
 
        /// 
        /// The action that caused the event. 
        ///  
        public NotifyCollectionChangedAction Action
        { 
            get { return _action; }
        }

        ///  
        /// The items affected by the change.
        ///  
        public IList NewItems 
        {
            get { return _newItems; } 
        }

        /// 
        /// The old items affected by the change (for Replace events). 
        /// 
        public IList OldItems 
        { 
            get { return _oldItems; }
        } 

        /// 
        /// The index where the change occurred.
        ///  
        public int NewStartingIndex
        { 
            get { return _newStartingIndex; } 
        }
 
        /// 
        /// The old index where the change occurred (for Move events).
        /// 
        public int OldStartingIndex 
        {
            get { return _oldStartingIndex; } 
        } 

        //------------------------------------------------------ 
        //
        //  Private Fields
        //
        //------------------------------------------------------ 

        private NotifyCollectionChangedAction _action; 
        private IList _newItems, _oldItems; 
        private int _newStartingIndex = -1;
        private int _oldStartingIndex = -1; 
    }

    /// 
    ///     The delegate to use for handlers that receive the CollectionChanged event. 
    /// 
    [TypeForwardedFrom("WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35")] 
    public delegate void NotifyCollectionChangedEventHandler(object sender, NotifyCollectionChangedEventArgs e); 

} 



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