ObjectViewEntityCollectionData.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 / DataEntity / System / Data / Objects / ObjectViewEntityCollectionData.cs / 1305376 / ObjectViewEntityCollectionData.cs
                        

                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
// @owner       [....]
// @backupOwner [....] 
//--------------------------------------------------------------------- 
using System;
using System.Collections.Generic; 
using System.ComponentModel;
using System.Data.Objects.DataClasses;
using System.Data.Objects.Internal;
using System.Diagnostics; 
using System.Data.Common;
 
namespace System.Data.Objects 
{
    ///  
    /// Manages a binding list constructed from an EntityCollection.
    /// 
    /// 
    /// Type of the elements in the binding list. 
    /// 
    ///  
    /// Type of element in the underlying EntityCollection. 
    /// 
    ///  
    /// The binding list is initialized from the EntityCollection,
    /// and is synchronized with changes made to the EntityCollection membership.
    /// This class always allows additions and removals from the binding list.
    ///  
    internal sealed class ObjectViewEntityCollectionData : IObjectViewData
        where TItemElement : class 
        where TViewElement : TItemElement 
    {
        private List _bindingList; 

        private EntityCollection _entityCollection;

        private readonly bool _canEditItems; 

        ///  
        /// True if item that was added to binding list but not underlying entity collection 
        /// is now being committed to the collection.
        /// Otherwise false. 
        /// Used by CommitItemAt and OnCollectionChanged methods to coordinate addition
        /// of new item to underlying entity collection.
        /// 
        private bool _itemCommitPending; 

        ///  
        /// Construct a new instance of the ObjectViewEntityCollectionData class using the supplied entityCollection. 
        /// 
        ///  
        /// EntityCollection used to populate the binding list.
        /// 
        internal ObjectViewEntityCollectionData(EntityCollection entityCollection)
        { 
            _entityCollection = entityCollection;
 
            _canEditItems = true; 

            // Allow deferred loading to occur when initially populating the collection 
            _bindingList = new List(entityCollection.Count);
            foreach (TViewElement entity in entityCollection)
            {
                _bindingList.Add(entity); 
            }
        } 
 
        #region IObjectViewData Members
 
        public IList List
        {
            get { return _bindingList; }
        } 

        public bool AllowNew 
        { 
            get { return !_entityCollection.IsReadOnly; }
        } 

        public bool AllowEdit
        {
            get { return _canEditItems; } 
        }
 
        public bool AllowRemove 
        {
            get { return !_entityCollection.IsReadOnly; } 
        }

        public bool FiresEventOnAdd
        { 
            get { return true; }
        } 
 
        public bool FiresEventOnRemove
        { 
            get { return true; }
        }

        public bool FiresEventOnClear 
        {
            get { return true; } 
        } 

        public void EnsureCanAddNew() 
        {
            // nop
        }
 
        public int Add(TViewElement item, bool isAddNew)
        { 
            if (isAddNew) 
            {
                // Item is added to bindingList, but pending addition to entity collection. 
                _bindingList.Add(item);
            }
            else
            { 
                _entityCollection.Add(item);
                // OnCollectionChanged will be fired, where the binding list will be updated. 
            } 

            return _bindingList.Count - 1; 
        }

        public void CommitItemAt(int index)
        { 
            TViewElement item = _bindingList[index];
 
            try 
            {
                _itemCommitPending = true; 

                _entityCollection.Add(item);
                // OnCollectionChanged will be fired, where the binding list will be updated.
            } 
            finally
            { 
                _itemCommitPending = false; 
            }
 
        }

        public void Clear()
        { 
            if (0 < _bindingList.Count)
            { 
                List _deletionList = new List(); 

                foreach (object item in _bindingList) 
                {
                    _deletionList.Add(item);
                }
 
                _entityCollection.BulkDeleteAll(_deletionList);
                // EntityCollection will fire change event which this instance will use to clean up the binding list. 
            } 
        }
 
        public bool Remove(TViewElement item, bool isCancelNew)
        {
            bool removed;
 
            if (isCancelNew)
            { 
                // Item was previously added to binding list, but not entity collection. 
                removed = _bindingList.Remove(item);
            } 
            else
            {
                removed = _entityCollection.RemoveInternal(item);
                // OnCollectionChanged will be fired, where the binding list will be updated. 
            }
 
            return removed; 
        }
 
        public ListChangedEventArgs OnCollectionChanged(object sender, CollectionChangeEventArgs e, ObjectViewListener listener)
        {
            ListChangedEventArgs changeArgs = null;
 
            switch (e.Action)
            { 
                case CollectionChangeAction.Remove: 
                    // An Entity is being removed from entity collection, remove it from list.
                    if (e.Element is TViewElement) 
                    {
                        TViewElement removedItem = (TViewElement)e.Element;

                        int oldIndex = _bindingList.IndexOf(removedItem); 
                        if (oldIndex != -1)
                        { 
                            _bindingList.Remove(removedItem); 

                            // Unhook from events of removed entity. 
                            listener.UnregisterEntityEvents(removedItem);

                            changeArgs = new ListChangedEventArgs(ListChangedType.ItemDeleted, oldIndex /* newIndex*/, -1 /* oldIndex*/);
                        } 
                    }
                    break; 
 
                case CollectionChangeAction.Add:
                    // Add the entity to our list. 
                    if (e.Element is TViewElement)
                    {
                        // Do not process Add events that fire as a result of committing an item to the entity collection.
                        if (!_itemCommitPending) 
                        {
                            TViewElement addedItem = (TViewElement)e.Element; 
 
                            _bindingList.Add(addedItem);
 
                            // Register to its events.
                            listener.RegisterEntityEvents(addedItem);

                            changeArgs = new ListChangedEventArgs(ListChangedType.ItemAdded, _bindingList.Count - 1 /* newIndex*/, -1 /* oldIndex*/); 
                        }
                    } 
                    break; 

                case CollectionChangeAction.Refresh: 
                    foreach (TViewElement entity in _bindingList)
                    {
                        listener.UnregisterEntityEvents(entity);
                    } 

                    _bindingList.Clear(); 
 
                    foreach(TViewElement entity in _entityCollection.GetInternalEnumerable())
                    { 
                        _bindingList.Add(entity);

                        listener.RegisterEntityEvents(entity);
                    } 

                    changeArgs = new ListChangedEventArgs(ListChangedType.Reset, -1 /*newIndex*/, -1/*oldIndex*/); 
                    break; 
            }
 
            return changeArgs;
        }

        #endregion 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

                        

                        
                        
                    
                    

                        
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