Compensate.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.Activities / System / Activities / Statements / Compensate.cs / 1305376 / Compensate.cs
                        
                        
                            //---------------------------------------------------------------- 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//---------------------------------------------------------------
namespace System.Activities.Statements
{ 
    using System;
    using System.Collections.Generic; 
    using System.Collections.ObjectModel; 
    using System.ComponentModel;
    using System.Runtime; 
    using System.Activities.Validation;
    using System.Linq;
    using System.Activities.Expressions;
 
    public sealed class Compensate : NativeActivity
    { 
        static Constraint compensateWithNoTarget = Compensate.CompensateWithNoTarget(); 

        InternalCompensate internalCompensate; 
        DefaultCompensation defaultCompensation;

        Variable currentCompensationToken;
 
        public Compensate()
            : base() 
        { 
            this.currentCompensationToken = new Variable();
        } 

        [DefaultValue(null)]
        public InArgument Target
        { 
            get;
            set; 
        } 

        DefaultCompensation DefaultCompensation 
        {
            get
            {
                if (this.defaultCompensation == null) 
                {
                    this.defaultCompensation = new DefaultCompensation() 
                        { 
                            Target = new InArgument(this.currentCompensationToken),
                        }; 
                }

                return this.defaultCompensation;
            } 
        }
 
        InternalCompensate InternalCompensate 
        {
            get 
            {
                if (this.internalCompensate == null)
                {
                    this.internalCompensate = new InternalCompensate() 
                        {
                            Target = new InArgument(new ArgumentValue { ArgumentName = "Target" }), 
                        }; 
                }
 
                return this.internalCompensate;
            }
        }
 
        protected override void CacheMetadata(NativeActivityMetadata metadata)
        { 
            RuntimeArgument targetArgument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In); 
            metadata.Bind(this.Target, targetArgument);
            metadata.SetArgumentsCollection(new Collection { targetArgument }); 

            metadata.SetImplementationVariablesCollection(new Collection { this.currentCompensationToken });

            Fx.Assert(DefaultCompensation != null, "DefaultCompensation must be valid"); 
            Fx.Assert(InternalCompensate != null, "InternalCompensate must be valid");
            metadata.SetImplementationChildrenCollection( 
                new Collection 
                {
                    DefaultCompensation, 
                    InternalCompensate
                });
        }
 
        internal override IList InternalGetConstraints()
        { 
            return new List(1) { compensateWithNoTarget }; 
        }
 
        static Constraint CompensateWithNoTarget()
        {
            DelegateInArgument element = new DelegateInArgument { Name = "element" };
            DelegateInArgument validationContext = new DelegateInArgument { Name = "validationContext" }; 
            Variable assertFlag = new Variable { Name = "assertFlag" };
            Variable> elements = new Variable>() { Name = "elements" }; 
            Variable index = new Variable() { Name = "index" }; 

            return new Constraint 
            {
                Body = new ActivityAction
                {
                    Argument1 = element, 
                    Argument2 = validationContext,
                    Handler = new Sequence 
                    { 
                        Variables =
                        { 
                            assertFlag,
                            elements,
                            index
                        }, 
                        Activities =
                        { 
                            new If 
                            {
                                Condition = new InArgument((env)=>element.Get(env).Target != null), 
                                Then = new Assign
                                {
                                    To = assertFlag,
                                    Value = true 
                                },
                                Else = new Sequence 
                                { 
                                    Activities =
                                    { 
                                        new Assign>
                                        {
                                            To = elements,
                                            Value = new GetParentChain 
                                            {
                                                ValidationContext = validationContext, 
                                            }, 
                                        },
                                        new While(env => (assertFlag.Get(env)!=true) && index.Get(env) < elements.Get(env).Count()) 
                                        {
                                            Body = new Sequence
                                            {
                                                Activities = 
                                                {
                                                    new If(env => (elements.Get(env).ElementAt(index.Get(env))).GetType() == typeof(CompensationParticipant)) 
                                                    { 
                                                        Then = new Assign
                                                        { 
                                                            To = assertFlag,
                                                            Value = true
                                                        },
                                                    }, 
                                                    new Assign
                                                    { 
                                                        To=index, 
                                                        Value=new InArgument(env => index.Get(env)+1)
                                                    }, 
                                                }
                                            }
                                        }
                                    } 
                                }
                            }, 
                            new AssertValidation 
                            {
                                Assertion = new InArgument(assertFlag), 
                                Message = new InArgument(SR.CompensateWithNoTargetConstraint)
                            }
                        }
                    } 
                }
            }; 
        } 

        protected override void Execute(NativeActivityContext context) 
        {
            CompensationExtension compensationExtension = context.GetExtension();
            if (compensationExtension == null)
            { 
                throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CompensateWithoutCompensableActivity(this.DisplayName)));
            } 
 
            if (Target.IsEmpty)
            { 
                CompensationToken ambientCompensationToken = (CompensationToken)context.Properties.Find(CompensationToken.PropertyName);
                CompensationTokenData ambientTokenData = ambientCompensationToken == null ? null : compensationExtension.Get(ambientCompensationToken.CompensationId);

                if (ambientTokenData != null && ambientTokenData.IsTokenValidInSecondaryRoot) 
                {
                    this.currentCompensationToken.Set(context, ambientCompensationToken); 
                    if (ambientTokenData.ExecutionTracker.Count > 0) 
                    {
                        context.ScheduleActivity(DefaultCompensation); 
                    }
                }
                else
                { 
                    throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InvalidCompensateActivityUsage(this.DisplayName)));
                } 
            } 
            else
            { 
                CompensationToken compensationToken = Target.Get(context);
                CompensationTokenData tokenData = compensationToken == null ? null : compensationExtension.Get(compensationToken.CompensationId);

                if (compensationToken == null) 
                {
                    throw FxTrace.Exception.Argument("Target", SR.InvalidCompensationToken(this.DisplayName)); 
                } 

                if (compensationToken.CompensateCalled) 
                {
                    // No-Op
                    return;
                } 

                if (tokenData == null || tokenData.CompensationState != CompensationState.Completed) 
                { 
                    throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CompensableActivityAlreadyConfirmedOrCompensated));
                } 

                // A valid in-arg was passed...
                tokenData.CompensationState = CompensationState.Compensating;
                compensationToken.CompensateCalled = true; 
                context.ScheduleActivity(InternalCompensate);
            } 
        } 

        protected override void Cancel(NativeActivityContext context) 
        {
            // Suppress Cancel
        }
    } 
}

// 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
Compensate.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
