UpdateTracker.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWeb / Server / System / Data / Services / UpdateTracker.cs / 1305376 / UpdateTracker.cs
                        

                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// 
 
//      Provides a class used to track updates for callbacks.
// 
 
// 
// @owner  [....]
//--------------------------------------------------------------------- 

namespace System.Data.Services
{
    using System.Collections.Generic; 
    using System.Data.Services.Providers;
    using System.Diagnostics; 
    using System.Reflection; 

    /// 
Provides a class used to track updates for callbacks.
 
    internal class UpdateTracker
    {
        #region Private fields.
 
        /// 

        /// A dictionary of containers mapping to the changes on those 
        /// containers, each of which consists of an element and the 
        /// action taken on it.
        /// 
 
        private Dictionary> items;

        /// 
Underlying data service instance.
        private IDataService service; 

        #endregion Private fields. 
 
        /// 
Initializes a new  instance.
        /// underlying data source instance. 
        private UpdateTracker(IDataService service)
        {
            this.service = service;
            this.items = new Dictionary>(ReferenceEqualityComparer.Instance); 
        }
 
        /// 
Fires the notification for a single action.
 
        /// Service on which methods should be invoked.
        /// Object to be tracked. 
        /// Container in which object is changed.
        /// Action affecting target.
        internal static void FireNotification(IDataService service, object target, ResourceSetWrapper container, UpdateOperations action)
        { 
            Debug.Assert(service != null, "service != null");
            AssertActionValues(target, container); 
 
            MethodInfo[] methods = container.ChangeInterceptors;
            if (methods != null) 
            {
                object[] parameters = new object[2];
                parameters[0] = target;
                parameters[1] = action; 
                for (int i = 0; i < methods.Length; i++)
                { 
                    try 
                    {
                        methods[i].Invoke(service.Instance, parameters); 
                    }
                    catch (TargetInvocationException exception)
                    {
                        ErrorHandler.HandleTargetInvocationException(exception); 
                        throw;
                    } 
                } 
            }
        } 

        /// 

        /// Create a new instance of update tracker
        /// 
 
        /// underlying data service.
        ///  
        /// Returns a new instance of UpdateTracker. 
        /// 
        internal static UpdateTracker CreateUpdateTracker(IDataService service) 
        {
            return new UpdateTracker(service);
        }
 
        /// 
Fires all notifications
        internal void FireNotifications() 
        { 
            object[] parameters = new object[2];
            foreach (var item in this.items) 
            {
                MethodInfo[] methods = item.Key.ChangeInterceptors;
                Debug.Assert(methods != null, "methods != null - should not have been tracking changes to the container otherwise.");
                foreach (var element in item.Value) 
                {
                    parameters[0] = this.service.Updatable.ResolveResource(element.Key); 
                    parameters[1] = element.Value; 
                    for (int i = 0; i < methods.Length; i++)
                    { 
                        try
                        {
                            methods[i].Invoke(this.service.Instance, parameters);
                        } 
                        catch (TargetInvocationException exception)
                        { 
                            ErrorHandler.HandleTargetInvocationException(exception); 
                            throw;
                        } 
                    }
                }

                // Make elements elegible for garbage collection. 
                item.Value.Clear();
            } 
 
            // Make dictionary elegible for garbage collection.
            this.items = null; 
        }

        /// 

        /// Tracks the specified  for a 
        /// given  on the .
        /// 
 
        /// Object to be tracked. 
        /// Container in which object is changed.
        /// Action affecting target. 
        /// 
        /// If  was already being tracked, the actions are OR'ed together.
        /// 
        internal void TrackAction(object target, ResourceSetWrapper container, UpdateOperations action) 
        {
            AssertActionValues(target, container); 
            Debug.Assert(this.items != null, "this.items != null - otherwise FireNotification has already been called"); 

            // If it won't be necessary for us to fire authorizatio methods, 
            // skip tracking altogether.
            if (container.ChangeInterceptors == null)
            {
                return; 
            }
 
            // Get the container for which the change has taken place. 
            Dictionary changedItems;
            if (!this.items.TryGetValue(container, out changedItems)) 
            {
                // In order to mantain backwards compatibility, we are going to use default comparer for V1
                // providers. However, for V2 providers we are going to do reference equality comparisons.
                if (this.service.Provider.IsV1Provider) 
                {
                    changedItems = new Dictionary(EqualityComparer