InvokeBase.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 / WF / Activities / Executors / InvokeBase.cs / 1305376 / InvokeBase.cs
                        

                        
                            using System; 
using System.Reflection;
using System.Collections;
using System.Diagnostics;
using System.Workflow.ComponentModel; 
using System.Workflow.Runtime;
using System.Runtime.Serialization; 
using System.Runtime.Serialization.Formatters.Binary; 

 
namespace System.Workflow.Activities
{
    internal static class InvokeHelper
    { 
        internal static void InitializeParameters(MethodInfo methodBase, WorkflowParameterBindingCollection parameterBindings)
        { 
            ParameterInfo[] parameters = methodBase.GetParameters(); 
            foreach (ParameterInfo parameter in parameters)
            { 
                if (!parameterBindings.Contains(parameter.Name))
                    parameterBindings.Add(new WorkflowParameterBinding(parameter.Name));
            }
 
            if (methodBase.ReturnType != typeof(void))
            { 
                if (!parameterBindings.Contains("(ReturnValue)")) 
                    parameterBindings.Add(new WorkflowParameterBinding("(ReturnValue)"));
            } 
        }

        internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
        { 
            ParameterInfo[] formalParameters = methodBase.GetParameters();
            object[] actualParameters = new object[formalParameters.Length]; 
            int index = 0; 

            foreach (ParameterInfo formalParameter in formalParameters) 
            {
                if (parameterBindings.Contains(formalParameter.Name))
                {
                    WorkflowParameterBinding binding = parameterBindings[formalParameter.Name]; 
                    actualParameters[index] = binding.Value;
                } 
                index++; 
 			}
            return actualParameters; 
        }

        internal static object[] GetParameters(MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings, out ParameterModifier[] parameterModifiers)
        { 
            ParameterInfo[] formalParameters = methodBase.GetParameters();
            object[] actualParameters = new object[formalParameters.Length]; 
            if (actualParameters.Length == 0) 
            {
                parameterModifiers = new ParameterModifier[0]; 
                return actualParameters;
            }

            int index = 0; 
            BinaryFormatter formatter = null;
            ParameterModifier parameterModifier = new ParameterModifier(actualParameters.Length); 
            foreach (ParameterInfo formalParameter in formalParameters) 
            {
                if (formalParameter.ParameterType.IsByRef) 
                {
                    parameterModifier[index] = true;
                }
                else 
                {
                    parameterModifier[index] = false; 
                } 
                if (parameterBindings.Contains(formalParameter.Name))
                { 
                    WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];

                    if(formatter == null)
                       formatter = new BinaryFormatter(); 
                   actualParameters[index] = CloneOutboundValue(binding.Value, formatter, formalParameter.Name);
                } 
                index++; 
            }
 
            parameterModifiers = new ParameterModifier[1] { parameterModifier };
            return actualParameters;
        }
 
        internal static object CloneOutboundValue(object source, BinaryFormatter formatter, string name)
        { 
            if (source == null || source.GetType().IsValueType) 
                return source;
 
            ICloneable clone = source as ICloneable;
            if (clone != null)
                return clone.Clone();
 
            System.IO.MemoryStream stream = new System.IO.MemoryStream(1024);
            try 
            { 
                formatter.Serialize(stream, source);
            } 
            catch (SerializationException e)
            {
                throw new InvalidOperationException(SR.GetString(SR.Error_CallExternalMethodArgsSerializationException, name), e);
            } 
            stream.Position = 0;
            object cloned = formatter.Deserialize(stream); 
            return cloned; 
        }
 
        internal static void SaveOutRefParameters(object[] actualParameters, MethodBase methodBase, WorkflowParameterBindingCollection parameterBindings)
        {
            int index = 0;
            BinaryFormatter formatter = null; 
            foreach(ParameterInfo formalParameter in methodBase.GetParameters())
            { 
                if (parameterBindings.Contains(formalParameter.Name)) 
                {
                    if (formalParameter.ParameterType.IsByRef || (formalParameter.IsIn && formalParameter.IsOut)) 
                    {
                        WorkflowParameterBinding binding = parameterBindings[formalParameter.Name];

                        if (formatter == null) 
                            formatter = new BinaryFormatter();
                        binding.Value = CloneOutboundValue(actualParameters[index], formatter, formalParameter.Name); ; 
                    } 
                }
                index++; 
            }
        }
    }
} 

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