CompletionCallbackWrapper.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 / cdf / src / NetFx40 / System.Activities / System / Activities / Runtime / CompletionCallbackWrapper.cs / 1305376 / CompletionCallbackWrapper.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

namespace System.Activities.Runtime 
{
    using System; 
    using System.Collections.ObjectModel; 
    using System.Runtime;
    using System.Runtime.Serialization; 

    // can't add FuncCompletionCallbackWrapper since we don't know what to close the generic with
    [KnownType(typeof(ActivityCompletionCallbackWrapper))]
    [KnownType(typeof(DelegateCompletionCallbackWrapper))] 
    [DataContract]
    abstract class CompletionCallbackWrapper : CallbackWrapper 
    { 
        static Type completionCallbackType = typeof(CompletionCallback);
        static Type[] completionCallbackParameters = new Type[] { typeof(NativeActivityContext), typeof(ActivityInstance) }; 

        [DataMember(EmitDefaultValue = false)]
        bool checkForCancelation;
 
        [DataMember(EmitDefaultValue = false)]
        bool needsToGatherOutputs; 
 
        protected CompletionCallbackWrapper(Delegate callback, ActivityInstance owningInstance)
            : base(callback, owningInstance) 
        {
        }

        protected bool NeedsToGatherOutputs 
        {
            get 
            { 
                return this.needsToGatherOutputs;
            } 

            set
            {
                this.needsToGatherOutputs = value; 
            }
        } 
 
        public void CheckForCancelation()
        { 
            this.checkForCancelation = true;
        }

        protected virtual void GatherOutputs(ActivityInstance completedInstance) 
        {
            // No-op in the base class 
        } 

        internal WorkItem CreateWorkItem(ActivityInstance completedInstance, ActivityExecutor executor) 
        {
            // We use the property to guard against the virtual method call
            // since we don't need it in the common case
            if (this.NeedsToGatherOutputs) 
            {
                this.GatherOutputs(completedInstance); 
            } 

            CompletionWorkItem workItem; 

            if (this.checkForCancelation)
            {
                workItem = new CompletionWithCancelationCheckWorkItem(this, completedInstance); 
            }
            else 
            { 
                workItem = executor.CompletionWorkItemPool.Acquire();
                workItem.Initialize(this, completedInstance); 
            }

            if (completedInstance.InstanceMap != null)
            { 
                completedInstance.InstanceMap.AddEntry(workItem);
            } 
 
            return workItem;
        } 

        protected internal abstract void Invoke(NativeActivityContext context, ActivityInstance completedInstance);

        [DataContract] 
        public class CompletionWorkItem : ActivityExecutionWorkItem, ActivityInstanceMap.IActivityReference
        { 
            [DataMember] 
            CompletionCallbackWrapper callbackWrapper;
            [DataMember] 
            ActivityInstance completedInstance;

            // Called by the Pool.
            public CompletionWorkItem() 
            {
                this.IsPooled = true; 
            } 

            // Only used by non-pooled base classes. 
            protected CompletionWorkItem(CompletionCallbackWrapper callbackWrapper, ActivityInstance completedInstance)
                : base(callbackWrapper.ActivityInstance)
            {
                this.callbackWrapper = callbackWrapper; 
                this.completedInstance = completedInstance;
            } 
 
            protected ActivityInstance CompletedInstance
            { 
                get
                {
                    return this.completedInstance;
                } 
            }
 
            public void Initialize(CompletionCallbackWrapper callbackWrapper, ActivityInstance completedInstance) 
            {
                base.Reinitialize(callbackWrapper.ActivityInstance); 
                this.callbackWrapper = callbackWrapper;
                this.completedInstance = completedInstance;
            }
 
            protected override void ReleaseToPool(ActivityExecutor executor)
            { 
                base.ClearForReuse(); 
                this.callbackWrapper = null;
                this.completedInstance = null; 

                executor.CompletionWorkItemPool.Release(this);
            }
 
            public override void TraceCompleted()
            { 
                if (TD.CompleteCompletionWorkItemIsEnabled()) 
                {
                    TD.CompleteCompletionWorkItem(this.ActivityInstance.Activity.GetType().ToString(), this.ActivityInstance.Activity.DisplayName, this.ActivityInstance.Id, this.completedInstance.Activity.GetType().ToString(), this.completedInstance.Activity.DisplayName, this.completedInstance.Id); 
                }
            }

            public override void TraceScheduled() 
            {
                if (TD.ScheduleCompletionWorkItemIsEnabled()) 
                { 
                    TD.ScheduleCompletionWorkItem(this.ActivityInstance.Activity.GetType().ToString(), this.ActivityInstance.Activity.DisplayName, this.ActivityInstance.Id, this.completedInstance.Activity.GetType().ToString(), this.completedInstance.Activity.DisplayName, this.completedInstance.Id);
                } 
            }

            public override void TraceStarting()
            { 
                if (TD.StartCompletionWorkItemIsEnabled())
                { 
                    TD.StartCompletionWorkItem(this.ActivityInstance.Activity.GetType().ToString(), this.ActivityInstance.Activity.DisplayName, this.ActivityInstance.Id, this.completedInstance.Activity.GetType().ToString(), this.completedInstance.Activity.DisplayName, this.completedInstance.Id); 
                }
            } 

            public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager)
            {
                NativeActivityContext context = executor.NativeActivityContextPool.Acquire(); 

                Fx.Assert(this.completedInstance.Activity != null, "Activity definition should always be associated with an activity instance."); 
 
                try
                { 
                    context.Initialize(this.ActivityInstance, executor, bookmarkManager);
                    this.callbackWrapper.Invoke(context, this.completedInstance);
                }
                catch (Exception e) 
                {
                    if (Fx.IsFatal(e)) 
                    { 
                        throw;
                    } 

                    this.ExceptionToPropagate = e;
                }
                finally 
                {
                    context.Dispose(); 
                    executor.NativeActivityContextPool.Release(context); 

                    if (this.ActivityInstance.InstanceMap != null) 
                    {
                        this.ActivityInstance.InstanceMap.RemoveEntry(this);
                    }
                } 

                return true; 
            } 

            Activity ActivityInstanceMap.IActivityReference.Activity 
            {
                get
                {
                    return this.completedInstance.Activity; 
                }
            } 
 
            void ActivityInstanceMap.IActivityReference.Load(Activity activity, ActivityInstanceMap instanceMap)
            { 
                if (this.completedInstance.Activity == null)
                {
                    ((ActivityInstanceMap.IActivityReference)this.completedInstance).Load(activity, instanceMap);
                } 
            }
        } 
 
        [DataContract]
        class CompletionWithCancelationCheckWorkItem : CompletionWorkItem 
        {
            public CompletionWithCancelationCheckWorkItem(CompletionCallbackWrapper callbackWrapper, ActivityInstance completedInstance)
                : base(callbackWrapper, completedInstance)
            { 
            }
 
            public override bool Execute(ActivityExecutor executor, BookmarkManager bookmarkManager) 
            {
                if (this.CompletedInstance.State != ActivityInstanceState.Closed && this.ActivityInstance.IsPerformingDefaultCancelation) 
                {
                    this.ActivityInstance.MarkCanceled();
                }
 
                return base.Execute(executor, bookmarkManager);
            } 
        } 
    }
} 

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