mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Description/ClientClassGenerator.cs

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

namespace System.ServiceModel.Description
{
    using System;
    using System.CodeDom;
    using System.Collections.ObjectModel;
    using System.ComponentModel;
    using System.Globalization;
    using System.Reflection;
    using System.Runtime;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.Threading;

    class ClientClassGenerator : IServiceContractGenerationExtension
    {
        bool tryAddHelperMethod = false;
        bool generateEventAsyncMethods = false;

        internal ClientClassGenerator(bool tryAddHelperMethod)
            : this(tryAddHelperMethod, false)
        {
        }

        internal ClientClassGenerator(bool tryAddHelperMethod, bool generateEventAsyncMethods)
        {
            this.tryAddHelperMethod = tryAddHelperMethod;
            this.generateEventAsyncMethods = generateEventAsyncMethods;
        }

        static Type clientBaseType = typeof(ClientBase<>);
        static Type duplexClientBaseType = typeof(DuplexClientBase<>);
        static Type instanceContextType = typeof(InstanceContext);
        static Type objectType = typeof(object);
        static Type objectArrayType = typeof(object[]);
        static Type exceptionType = typeof(Exception);
        static Type boolType = typeof(bool);
        static Type stringType = typeof(string);
        static Type endpointAddressType = typeof(EndpointAddress);
        static Type uriType = typeof(Uri);
        static Type bindingType = typeof(Binding);
        static Type sendOrPostCallbackType = typeof(SendOrPostCallback);
        static Type asyncCompletedEventArgsType = typeof(AsyncCompletedEventArgs);
        static Type eventHandlerType = typeof(EventHandler<>);
        static Type voidType = typeof(void);
        static Type asyncResultType = typeof(IAsyncResult);
        static Type asyncCallbackType = typeof(AsyncCallback);
        
        static CodeTypeReference voidTypeRef = new CodeTypeReference(typeof(void));
        static CodeTypeReference asyncResultTypeRef = new CodeTypeReference(typeof(IAsyncResult));

        static string inputInstanceName = "callbackInstance";
        static string invokeAsyncCompletedEventArgsTypeName = "InvokeAsyncCompletedEventArgs";
        static string invokeAsyncMethodName = "InvokeAsync";
        static string raiseExceptionIfNecessaryMethodName = "RaiseExceptionIfNecessary";
        static string beginOperationDelegateTypeName = "BeginOperationDelegate";
        static string endOperationDelegateTypeName = "EndOperationDelegate";
        static string getDefaultValueForInitializationMethodName = "GetDefaultValueForInitialization";

        // IMPORTANT: this table tracks the set of .ctors in ClientBase and DuplexClientBase. 
        // This table must be kept in [....]
        // for DuplexClientBase, the initial InstanceContext param is assumed; ctor overloads must match between ClientBase and DuplexClientBase
        static Type[][] ClientCtorParamTypes = new Type[][]
            {
                new Type[] { },
                new Type[] { stringType, },
                new Type[] { stringType, stringType, },
                new Type[] { stringType, endpointAddressType, },
                new Type[] { bindingType, endpointAddressType, },
            };

        static string[][] ClientCtorParamNames = new string[][]
            {
                new string[] { },
                new string[] { "endpointConfigurationName", },
                new string[] { "endpointConfigurationName", "remoteAddress", },
                new string[] { "endpointConfigurationName", "remoteAddress", },
                new string[] { "binding", "remoteAddress", },
            };

        static Type[] EventArgsCtorParamTypes = new Type[] 
        { 
            objectArrayType, 
            exceptionType, 
            boolType, 
            objectType 
        };

        static string[] EventArgsCtorParamNames = new string[] 
        {
            "results",
            "exception",
            "cancelled",
            "userState"
        };

        static string[] EventArgsPropertyNames = new string[]
        {
            "Results",
            "Error",
            "Cancelled",
            "UserState"
        };

#if DEBUG
        static BindingFlags ctorBindingFlags = BindingFlags.Instance | BindingFlags.NonPublic;
        static string DebugCheckTable_errorString = "Client code generation table out of [....] with ClientBase and DuplexClientBase ctors. Please investigate.";

        // check the table against what we would get from reflection
        static void DebugCheckTable()
        {
            Fx.Assert(ClientCtorParamNames.Length == ClientCtorParamTypes.Length, DebugCheckTable_errorString);

            for (int i = 0; i < ClientCtorParamTypes.Length; i++)
            {
                DebugCheckTable_ValidateCtor(clientBaseType.GetConstructor(ctorBindingFlags, null, ClientCtorParamTypes[i], null), ClientCtorParamNames[i]);

                Type[] duplexCtorTypes1 = DebugCheckTable_InsertAtStart(ClientCtorParamTypes[i], objectType);
                Type[] duplexCtorTypes2 = DebugCheckTable_InsertAtStart(ClientCtorParamTypes[i], instanceContextType);
                string[] duplexCtorNames = DebugCheckTable_InsertAtStart(ClientCtorParamNames[i], inputInstanceName);

                DebugCheckTable_ValidateCtor(duplexClientBaseType.GetConstructor(ctorBindingFlags, null, duplexCtorTypes1, null), duplexCtorNames);
                DebugCheckTable_ValidateCtor(duplexClientBaseType.GetConstructor(ctorBindingFlags, null, duplexCtorTypes2, null), duplexCtorNames);
            }

            // ClientBase<> has extra InstanceContext overloads that we do not call directly from the generated code, but which we 
            // need to account for in this assert
            Fx.Assert(clientBaseType.GetConstructors(ctorBindingFlags).Length == ClientCtorParamTypes.Length * 2, DebugCheckTable_errorString);

            // DuplexClientBase<> also has extra object/InstanceContext overloads (but we call these)
            Fx.Assert(duplexClientBaseType.GetConstructors(ctorBindingFlags).Length == ClientCtorParamTypes.Length * 2, DebugCheckTable_errorString);
        }

        static T[] DebugCheckTable_InsertAtStart<T>(T[] arr, T item)
        {
            T[] newArr = new T[arr.Length + 1];
            newArr[0] = item;
            Array.Copy(arr, 0, newArr, 1, arr.Length);
            return newArr;
        }

        static void DebugCheckTable_ValidateCtor(ConstructorInfo ctor, string[] paramNames)
        {
            Fx.Assert(ctor != null, DebugCheckTable_errorString);

            ParameterInfo[] parameters = ctor.GetParameters();
            Fx.Assert(parameters.Length == paramNames.Length, DebugCheckTable_errorString);
            for (int i = 0; i < paramNames.Length; i++)
            {
                Fx.Assert(parameters[i].Name == paramNames[i], DebugCheckTable_errorString);
            }
        }
#endif

        void IServiceContractGenerationExtension.GenerateContract(ServiceContractGenerationContext context)
        {
#if DEBUG
            // DebugCheckTable();
#endif
            CodeTypeDeclaration clientType = context.TypeFactory.CreateClassType();
            // Have to make sure that client name does not match any methods: member names can not be the same as their enclosing type (CSharp only)
            clientType.Name = NamingHelper.GetUniqueName(GetClientClassName(context.ContractType.Name), DoesMethodNameExist, context.Operations);
            CodeTypeReference contractTypeRef = context.ContractTypeReference;
            if (context.DuplexCallbackType == null)
                clientType.BaseTypes.Add(new CodeTypeReference(context.ServiceContractGenerator.GetCodeTypeReference(typeof(ClientBase<>)).BaseType, context.ContractTypeReference));
            else
                clientType.BaseTypes.Add(new CodeTypeReference(context.ServiceContractGenerator.GetCodeTypeReference(typeof(DuplexClientBase<>)).BaseType, context.ContractTypeReference));

            clientType.BaseTypes.Add(context.ContractTypeReference);

            if (!(ClientCtorParamNames.Length == ClientCtorParamTypes.Length))
            {
                Fx.Assert("Invalid client generation constructor table initialization");
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Invalid client generation constructor table initialization")));
            }

            for (int i = 0; i < ClientCtorParamNames.Length; i++)
            {
                if (!(ClientCtorParamNames[i].Length == ClientCtorParamTypes[i].Length))
                {
                    Fx.Assert("Invalid client generation constructor table initialization");
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Invalid client generation constructor table initialization")));
                }

                CodeConstructor ctor = new CodeConstructor();
                ctor.Attributes = MemberAttributes.Public;
                if (context.DuplexCallbackType != null)
                {
                    ctor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(InstanceContext), inputInstanceName));
                    ctor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(inputInstanceName));
                }
                for (int j = 0; j < ClientCtorParamNames[i].Length; j++)
                {
                    ctor.Parameters.Add(new CodeParameterDeclarationExpression(ClientCtorParamTypes[i][j], ClientCtorParamNames[i][j]));
                    ctor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(ClientCtorParamNames[i][j]));
                }
                clientType.Members.Add(ctor);
            }

            foreach (OperationContractGenerationContext operationContext in context.Operations)
            {
                // Note that we generate all the client-side methods, even inherited ones.
                if (operationContext.Operation.IsServerInitiated()) continue;
                CodeTypeReference declaringContractTypeRef = operationContext.DeclaringTypeReference;
                GenerateClientClassMethod(clientType, contractTypeRef, operationContext.SyncMethod, this.tryAddHelperMethod, declaringContractTypeRef);

                if (operationContext.IsAsync)
                {
                    CodeMemberMethod beginMethod = GenerateClientClassMethod(clientType, contractTypeRef, operationContext.BeginMethod, this.tryAddHelperMethod, declaringContractTypeRef);
                    CodeMemberMethod endMethod = GenerateClientClassMethod(clientType, contractTypeRef, operationContext.EndMethod, this.tryAddHelperMethod, declaringContractTypeRef);

                    if (this.generateEventAsyncMethods)
                    {
                        GenerateEventAsyncMethods(context, clientType, operationContext.SyncMethod.Name, beginMethod, endMethod);
                    }
                }

                if (operationContext.IsTask)
                {
                    GenerateClientClassMethod(clientType, contractTypeRef, operationContext.TaskMethod, !operationContext.Operation.HasOutputParameters && this.tryAddHelperMethod, declaringContractTypeRef);
                }
            }

            context.Namespace.Types.Add(clientType);
            context.ClientType = clientType;
            context.ClientTypeReference = ServiceContractGenerator.NamespaceHelper.GetCodeTypeReference(context.Namespace, clientType);
        }

        static CodeMemberMethod GenerateClientClassMethod(CodeTypeDeclaration clientType, CodeTypeReference contractTypeRef, CodeMemberMethod method, bool addHelperMethod, CodeTypeReference declaringContractTypeRef)
        {
            CodeMemberMethod methodImpl = GetImplementationOfMethod(contractTypeRef, method);
            AddMethodImpl(methodImpl);
            int methodPosition = clientType.Members.Add(methodImpl);
            CodeMemberMethod helperMethod = null;

            if (addHelperMethod)
            {
                helperMethod = GenerateHelperMethod(declaringContractTypeRef, methodImpl);
                if (helperMethod != null)
                {
                    clientType.Members[methodPosition].CustomAttributes.Add(CreateEditorBrowsableAttribute(EditorBrowsableState.Advanced));
                    clientType.Members.Add(helperMethod);
                }
            }

            return (helperMethod != null) ? helperMethod : methodImpl;
        }

        internal static CodeAttributeDeclaration CreateEditorBrowsableAttribute(EditorBrowsableState editorBrowsableState)
        {
            CodeAttributeDeclaration browsableAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(EditorBrowsableAttribute)));
            CodeTypeReferenceExpression browsableAttributeState = new CodeTypeReferenceExpression(typeof(EditorBrowsableState));
            CodeAttributeArgument browsableAttributeValue = new CodeAttributeArgument(new CodeFieldReferenceExpression(browsableAttributeState, editorBrowsableState.ToString()));
            browsableAttribute.Arguments.Add(browsableAttributeValue);

            return browsableAttribute;
        }

        private static CodeMemberMethod GenerateHelperMethod(CodeTypeReference ifaceType, CodeMemberMethod method)
        {
            CodeMemberMethod helperMethod = new CodeMemberMethod();
            helperMethod.Name = method.Name;
            helperMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            CodeMethodInvokeExpression invokeMethod = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeCastExpression(ifaceType, new CodeThisReferenceExpression()), method.Name));
            bool hasTypedMessage = false;
            foreach (CodeParameterDeclarationExpression param in method.Parameters)
            {
                CodeTypeDeclaration paramTypeDecl = ServiceContractGenerator.NamespaceHelper.GetCodeType(param.Type);
                if (paramTypeDecl != null)
                {
                    hasTypedMessage = true;
                    CodeVariableReferenceExpression inValue = new CodeVariableReferenceExpression("inValue");
                    helperMethod.Statements.Add(new CodeVariableDeclarationStatement(param.Type, inValue.VariableName, new CodeObjectCreateExpression(param.Type)));
                    invokeMethod.Parameters.Add(inValue);
                    GenerateParameters(helperMethod, paramTypeDecl, inValue, FieldDirection.In);
                }
                else
                {
                    helperMethod.Parameters.Add(new CodeParameterDeclarationExpression(param.Type, param.Name));
                    invokeMethod.Parameters.Add(new CodeArgumentReferenceExpression(param.Name));
                }
            }
            if (method.ReturnType.BaseType == voidTypeRef.BaseType)
                helperMethod.Statements.Add(invokeMethod);
            else
            {
                CodeTypeDeclaration returnTypeDecl = ServiceContractGenerator.NamespaceHelper.GetCodeType(method.ReturnType);
                if (returnTypeDecl != null)
                {
                    hasTypedMessage = true;
                    CodeVariableReferenceExpression outVar = new CodeVariableReferenceExpression("retVal");

                    helperMethod.Statements.Add(new CodeVariableDeclarationStatement(method.ReturnType, outVar.VariableName, invokeMethod));
                    CodeMethodReturnStatement returnStatement = GenerateParameters(helperMethod, returnTypeDecl, outVar, FieldDirection.Out);
                    if (returnStatement != null)
                        helperMethod.Statements.Add(returnStatement);
                }
                else
                {
                    helperMethod.Statements.Add(new CodeMethodReturnStatement(invokeMethod));
                    helperMethod.ReturnType = method.ReturnType;
                }
            }
            if (hasTypedMessage)
                method.PrivateImplementationType = ifaceType;
            return hasTypedMessage ? helperMethod : null;
        }

        private static CodeMethodReturnStatement GenerateParameters(CodeMemberMethod helperMethod, CodeTypeDeclaration codeTypeDeclaration, CodeExpression target, FieldDirection dir)
        {
            CodeMethodReturnStatement returnStatement = null;
            foreach (CodeTypeMember member in codeTypeDeclaration.Members)
            {
                CodeMemberField field = member as CodeMemberField;
                if (field == null)
                    continue;
                CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(target, field.Name);
                CodeTypeDeclaration bodyTypeDecl = ServiceContractGenerator.NamespaceHelper.GetCodeType(field.Type);
                if (bodyTypeDecl != null)
                {
                    if (dir == FieldDirection.In)
                        helperMethod.Statements.Add(new CodeAssignStatement(fieldRef, new CodeObjectCreateExpression(field.Type)));
                    returnStatement = GenerateParameters(helperMethod, bodyTypeDecl, fieldRef, dir);
                    continue;
                }
                CodeParameterDeclarationExpression param = GetRefParameter(helperMethod.Parameters, dir, field);
                if (param == null && dir == FieldDirection.Out && helperMethod.ReturnType.BaseType == voidTypeRef.BaseType)
                {
                    helperMethod.ReturnType = field.Type;
                    returnStatement = new CodeMethodReturnStatement(fieldRef);
                }
                else
                {
                    if (param == null)
                    {
                        param = new CodeParameterDeclarationExpression(field.Type, NamingHelper.GetUniqueName(field.Name, DoesParameterNameExist, helperMethod));
                        param.Direction = dir;
                        helperMethod.Parameters.Add(param);
                    }
                    if (dir == FieldDirection.Out)
                        helperMethod.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression(param.Name), fieldRef));
                    else
                        helperMethod.Statements.Add(new CodeAssignStatement(fieldRef, new CodeArgumentReferenceExpression(param.Name)));
                }
            }
            return returnStatement;
        }

        private static CodeParameterDeclarationExpression GetRefParameter(CodeParameterDeclarationExpressionCollection parameters, FieldDirection dir, CodeMemberField field)
        {
            foreach (CodeParameterDeclarationExpression p in parameters)
            {
                if (p.Name == field.Name)
                {
                    if (p.Direction != dir && p.Type.BaseType == field.Type.BaseType)
                    {
                        p.Direction = FieldDirection.Ref;
                        return p;
                    }
                    return null;
                }
            }
            return null;
        }

        internal static bool DoesMemberNameExist(string name, object typeDeclarationObject)
        {
            CodeTypeDeclaration typeDeclaration = (CodeTypeDeclaration)typeDeclarationObject;

            if (string.Compare(typeDeclaration.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
            {
                return true;
            }

            foreach (CodeTypeMember member in typeDeclaration.Members)
            {
                if (string.Compare(member.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    return true;
                }
            }

            return false;
        }

        internal static bool DoesTypeNameExists(string name, object codeTypeDeclarationCollectionObject)
        {
            CodeTypeDeclarationCollection codeTypeDeclarations = (CodeTypeDeclarationCollection)codeTypeDeclarationCollectionObject;
            foreach (CodeTypeDeclaration codeTypeDeclaration in codeTypeDeclarations)
            {
                if (string.Compare(codeTypeDeclaration.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    return true;
                }
            }

            return false;
        }

        internal static bool DoesTypeAndMemberNameExist(string name, object nameCollection)
        {
            object[] nameCollections = (object[])nameCollection;

            if (DoesTypeNameExists(name, nameCollections[0]))
            {
                return true;
            }
            if (DoesMemberNameExist(name, nameCollections[1]))
            {
                return true;
            }

            return false;
        }

        internal static bool DoesMethodNameExist(string name, object operationsObject)
        {
            Collection<OperationContractGenerationContext> operations = (Collection<OperationContractGenerationContext>)operationsObject;
            foreach (OperationContractGenerationContext operationContext in operations)
            {
                if (String.Compare(operationContext.SyncMethod.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                    return true;
                if (operationContext.IsAsync)
                {
                    if (String.Compare(operationContext.BeginMethod.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                        return true;
                    if (String.Compare(operationContext.EndMethod.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                        return true;
                }
                if (operationContext.IsTask)
                {
                    if (String.Compare(operationContext.TaskMethod.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                        return true;
                }
            }
            return false;
        }

        internal static bool DoesParameterNameExist(string name, object methodObject)
        {
            CodeMemberMethod method = (CodeMemberMethod)methodObject;
            if (String.Compare(method.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                return true;
            CodeParameterDeclarationExpressionCollection parameters = method.Parameters;
            foreach (CodeParameterDeclarationExpression p in parameters)
            {
                if (String.Compare(p.Name, name, StringComparison.OrdinalIgnoreCase) == 0)
                    return true;
            }
            return false;
        }

        static void AddMethodImpl(CodeMemberMethod method)
        {
            CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(GetChannelReference(), method.Name);
            foreach (CodeParameterDeclarationExpression parameter in method.Parameters)
            {
                methodInvoke.Parameters.Add(new CodeDirectionExpression(parameter.Direction, new CodeVariableReferenceExpression(parameter.Name)));
            }
            if (IsVoid(method))
                method.Statements.Add(methodInvoke);
            else
                method.Statements.Add(new CodeMethodReturnStatement(methodInvoke));
        }

        static CodeMemberMethod GetImplementationOfMethod(CodeTypeReference ifaceType, CodeMemberMethod method)
        {
            CodeMemberMethod m = new CodeMemberMethod();
            m.Name = method.Name;
            m.ImplementationTypes.Add(ifaceType);
            m.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            foreach (CodeParameterDeclarationExpression parameter in method.Parameters)
            {
                CodeParameterDeclarationExpression newParam = new CodeParameterDeclarationExpression(parameter.Type, parameter.Name);
                newParam.Direction = parameter.Direction;
                m.Parameters.Add(newParam);
            }
            m.ReturnType = method.ReturnType;
            return m;
        }

        static void GenerateEventAsyncMethods(ServiceContractGenerationContext context, CodeTypeDeclaration clientType,
            string syncMethodName, CodeMemberMethod beginMethod, CodeMemberMethod endMethod)
        {
            CodeTypeDeclaration operationCompletedEventArgsType = CreateOperationCompletedEventArgsType(context, syncMethodName, endMethod);
            CodeMemberEvent operationCompletedEvent = CreateOperationCompletedEvent(context, clientType, syncMethodName, operationCompletedEventArgsType);

            CodeMemberField beginOperationDelegate = CreateBeginOperationDelegate(context, clientType, syncMethodName);
            CodeMemberMethod beginOperationMethod = CreateBeginOperationMethod(context, clientType, syncMethodName, beginMethod);

            CodeMemberField endOperationDelegate = CreateEndOperationDelegate(context, clientType, syncMethodName);
            CodeMemberMethod endOperationMethod = CreateEndOperationMethod(context, clientType, syncMethodName, endMethod);

            CodeMemberField operationCompletedDelegate = CreateOperationCompletedDelegate(context, clientType, syncMethodName);
            CodeMemberMethod operationCompletedMethod = CreateOperationCompletedMethod(context, clientType, syncMethodName, operationCompletedEventArgsType, operationCompletedEvent);

            CodeMemberMethod eventAsyncMethod = CreateEventAsyncMethod(context, clientType, syncMethodName, beginMethod, 
                beginOperationDelegate, beginOperationMethod, endOperationDelegate, endOperationMethod, operationCompletedDelegate, operationCompletedMethod);

            CreateEventAsyncMethodOverload(clientType, eventAsyncMethod);

            // hide the normal async methods from intellisense
            beginMethod.CustomAttributes.Add(CreateEditorBrowsableAttribute(EditorBrowsableState.Advanced));
            endMethod.CustomAttributes.Add(CreateEditorBrowsableAttribute(EditorBrowsableState.Advanced));            
        }

        static CodeTypeDeclaration CreateOperationCompletedEventArgsType(ServiceContractGenerationContext context, 
            string syncMethodName, CodeMemberMethod endMethod)
        {
            if ((endMethod.Parameters.Count == 1) && (endMethod.ReturnType.BaseType == voidTypeRef.BaseType))
            {
                // no need to create new event args type, use AsyncCompletedEventArgs
                return null;
            }

            CodeTypeDeclaration argsType = context.TypeFactory.CreateClassType();
            argsType.BaseTypes.Add(new CodeTypeReference(asyncCompletedEventArgsType));

            // define object[] results field.
            CodeMemberField resultsField = new CodeMemberField();
            resultsField.Type = new CodeTypeReference(objectArrayType);

            CodeFieldReferenceExpression resultsFieldReference = new CodeFieldReferenceExpression();
            resultsFieldReference.TargetObject = new CodeThisReferenceExpression();

            // create constructor, that assigns the results field.
            CodeConstructor ctor = new CodeConstructor();
            ctor.Attributes = MemberAttributes.Public;
            for (int i = 0; i < EventArgsCtorParamTypes.Length; i++)
            {
                ctor.Parameters.Add(new CodeParameterDeclarationExpression(EventArgsCtorParamTypes[i], EventArgsCtorParamNames[i]));
                if (i > 0)
                {
                    ctor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(EventArgsCtorParamNames[i]));
                }
            }
            argsType.Members.Add(ctor);
            ctor.Statements.Add(new CodeAssignStatement(resultsFieldReference, new CodeVariableReferenceExpression(EventArgsCtorParamNames[0])));
             
            // create properties for the out parameters
            int asyncResultParamIndex = GetAsyncResultParamIndex(endMethod);
            int count = 0;
            for (int i = 0; i < endMethod.Parameters.Count; i++)
            {
                if (i != asyncResultParamIndex)
                {
                    CreateEventAsyncCompletedArgsTypeProperty(argsType,
                        endMethod.Parameters[i].Type,
                        endMethod.Parameters[i].Name,
                        new CodeArrayIndexerExpression(resultsFieldReference, new CodePrimitiveExpression(count++)));
                }
            }

            // create the property for the return type
            if (endMethod.ReturnType.BaseType != voidTypeRef.BaseType)
            {
                CreateEventAsyncCompletedArgsTypeProperty(
                    argsType,
                    endMethod.ReturnType,
                    NamingHelper.GetUniqueName("Result", DoesMemberNameExist, argsType),
                    new CodeArrayIndexerExpression(resultsFieldReference, 
                        new CodePrimitiveExpression(count)));
               
            }

            // Name the "results" field after generating the properties to make sure it does 
            // not conflict with the property names.
            resultsField.Name = NamingHelper.GetUniqueName("results", DoesMemberNameExist, argsType);
            resultsFieldReference.FieldName = resultsField.Name;
            argsType.Members.Add(resultsField);

            // Name the type making sure that it does not conflict with its members and types already present in
            // the namespace. 
            argsType.Name = NamingHelper.GetUniqueName(GetOperationCompletedEventArgsTypeName(syncMethodName),
                DoesTypeAndMemberNameExist, new object[] { context.Namespace.Types, argsType });
            context.Namespace.Types.Add(argsType);

            return argsType;
        }

        static int GetAsyncResultParamIndex(CodeMemberMethod endMethod)
        {
            int index = endMethod.Parameters.Count - 1;
            if (endMethod.Parameters[index].Type.BaseType != asyncResultTypeRef.BaseType)
            {
                // workaround for CSD Dev Framework:10826, the unwrapped end method has IAsyncResult as first param. 
                index = 0;
            }

            return index;
        }
        
        static CodeMemberProperty CreateEventAsyncCompletedArgsTypeProperty(CodeTypeDeclaration ownerTypeDecl, 
            CodeTypeReference propertyType, string propertyName, CodeExpression propertyValueExpr)
        {
            CodeMemberProperty property = new CodeMemberProperty();
            property.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            property.Type = propertyType;
            property.Name = propertyName;
            property.HasSet = false;
            property.HasGet = true;

            CodeCastExpression castExpr = new CodeCastExpression(propertyType, propertyValueExpr);
            CodeMethodReturnStatement returnStmt = new CodeMethodReturnStatement(castExpr);

            property.GetStatements.Add(new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), raiseExceptionIfNecessaryMethodName));
            property.GetStatements.Add(returnStmt);
            ownerTypeDecl.Members.Add(property);

            return property;
        }

        static CodeMemberEvent CreateOperationCompletedEvent(ServiceContractGenerationContext context, 
            CodeTypeDeclaration clientType, string syncMethodName, CodeTypeDeclaration operationCompletedEventArgsType)
        {
            CodeMemberEvent operationCompletedEvent = new CodeMemberEvent();
            operationCompletedEvent.Attributes = MemberAttributes.Public;
            operationCompletedEvent.Type = new CodeTypeReference(eventHandlerType);
            
            if (operationCompletedEventArgsType == null)
            {
                operationCompletedEvent.Type.TypeArguments.Add(asyncCompletedEventArgsType);
            }
            else
            {
                operationCompletedEvent.Type.TypeArguments.Add(operationCompletedEventArgsType.Name);
            }

            operationCompletedEvent.Name = NamingHelper.GetUniqueName(GetOperationCompletedEventName(syncMethodName),
                DoesMethodNameExist, context.Operations);
            
            clientType.Members.Add(operationCompletedEvent);
            return operationCompletedEvent;
        }

        static CodeMemberField CreateBeginOperationDelegate(ServiceContractGenerationContext context,
            CodeTypeDeclaration clientType, string syncMethodName)
        {
            CodeMemberField beginOperationDelegate = new CodeMemberField();
            beginOperationDelegate.Attributes = MemberAttributes.Private;
            beginOperationDelegate.Type = new CodeTypeReference(beginOperationDelegateTypeName);
            beginOperationDelegate.Name = NamingHelper.GetUniqueName(GetBeginOperationDelegateName(syncMethodName),
                DoesMethodNameExist, context.Operations);

            clientType.Members.Add(beginOperationDelegate);
            return beginOperationDelegate;
        }

        static CodeMemberMethod CreateBeginOperationMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, 
            string syncMethodName, CodeMemberMethod beginMethod)
        {
            CodeMemberMethod onBeginOperationMethod = new CodeMemberMethod();
            onBeginOperationMethod.Attributes = MemberAttributes.Private;
            onBeginOperationMethod.ReturnType = new CodeTypeReference(asyncResultType);
            onBeginOperationMethod.Name = NamingHelper.GetUniqueName(GetBeginOperationMethodName(syncMethodName), 
                DoesMethodNameExist, context.Operations);

            CodeParameterDeclarationExpression inValuesParam = new CodeParameterDeclarationExpression();
            inValuesParam.Type = new CodeTypeReference(objectArrayType);
            inValuesParam.Name = NamingHelper.GetUniqueName("inValues", DoesParameterNameExist, beginMethod);
            onBeginOperationMethod.Parameters.Add(inValuesParam);

            CodeMethodInvokeExpression invokeBegin = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), beginMethod.Name);
            CodeExpression inValuesRef = new CodeVariableReferenceExpression(inValuesParam.Name);

            for (int i = 0; i < beginMethod.Parameters.Count - 2; i++)
            {
                CodeVariableDeclarationStatement variableDecl = new CodeVariableDeclarationStatement();
                variableDecl.Type = beginMethod.Parameters[i].Type;
                variableDecl.Name = beginMethod.Parameters[i].Name;
                variableDecl.InitExpression = new CodeCastExpression(variableDecl.Type,
                    new CodeArrayIndexerExpression(inValuesRef, new CodePrimitiveExpression(i)));

                onBeginOperationMethod.Statements.Add(variableDecl);
                invokeBegin.Parameters.Add(new CodeDirectionExpression(beginMethod.Parameters[i].Direction,
                    new CodeVariableReferenceExpression(variableDecl.Name)));
            }

            for (int i = beginMethod.Parameters.Count - 2; i < beginMethod.Parameters.Count; i++)
            {
                onBeginOperationMethod.Parameters.Add(new CodeParameterDeclarationExpression(
                    beginMethod.Parameters[i].Type, beginMethod.Parameters[i].Name));
                invokeBegin.Parameters.Add(new CodeVariableReferenceExpression(beginMethod.Parameters[i].Name));
            }

            onBeginOperationMethod.Statements.Add(new CodeMethodReturnStatement(invokeBegin));
            clientType.Members.Add(onBeginOperationMethod);
            return onBeginOperationMethod;
        }
       
        static CodeMemberField CreateEndOperationDelegate(ServiceContractGenerationContext context,
            CodeTypeDeclaration clientType, string syncMethodName)
        {
            CodeMemberField endOperationDelegate = new CodeMemberField();
            endOperationDelegate.Attributes = MemberAttributes.Private;
            endOperationDelegate.Type = new CodeTypeReference(endOperationDelegateTypeName);
            endOperationDelegate.Name = NamingHelper.GetUniqueName(GetEndOperationDelegateName(syncMethodName),
                DoesMethodNameExist, context.Operations);

            clientType.Members.Add(endOperationDelegate);
            return endOperationDelegate;
        }

        static CodeMemberMethod CreateEndOperationMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod endMethod)
        {
            CodeMemberMethod onEndOperationMethod = new CodeMemberMethod();
            onEndOperationMethod.Attributes = MemberAttributes.Private;
            onEndOperationMethod.ReturnType = new CodeTypeReference(objectArrayType);
            onEndOperationMethod.Name = NamingHelper.GetUniqueName(GetEndOperationMethodName(syncMethodName), DoesMethodNameExist, context.Operations);

            int asyncResultParamIndex = GetAsyncResultParamIndex(endMethod);
            CodeMethodInvokeExpression invokeEnd = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), endMethod.Name);
            CodeArrayCreateExpression retArray = new CodeArrayCreateExpression();
            retArray.CreateType = new CodeTypeReference(objectArrayType);
            for (int i = 0; i < endMethod.Parameters.Count; i++)
            {
                if (i == asyncResultParamIndex)
                {
                    onEndOperationMethod.Parameters.Add(new CodeParameterDeclarationExpression(
                        endMethod.Parameters[i].Type, endMethod.Parameters[i].Name));
                    invokeEnd.Parameters.Add(new CodeVariableReferenceExpression(endMethod.Parameters[i].Name));
                }
                else
                {
                    CodeVariableDeclarationStatement variableDecl = new CodeVariableDeclarationStatement(
                        endMethod.Parameters[i].Type, endMethod.Parameters[i].Name);
                    CodeMethodReferenceExpression getDefaultValueMethodRef = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), getDefaultValueForInitializationMethodName, endMethod.Parameters[i].Type);
                    variableDecl.InitExpression = new CodeMethodInvokeExpression(getDefaultValueMethodRef); 
                    onEndOperationMethod.Statements.Add(variableDecl);

                    invokeEnd.Parameters.Add(new CodeDirectionExpression(endMethod.Parameters[i].Direction,
                            new CodeVariableReferenceExpression(variableDecl.Name)));

                    retArray.Initializers.Add(new CodeVariableReferenceExpression(variableDecl.Name));
                }
            }

            if (endMethod.ReturnType.BaseType != voidTypeRef.BaseType)
            {
                CodeVariableDeclarationStatement retValDecl = new CodeVariableDeclarationStatement();
                retValDecl.Type = endMethod.ReturnType;
                retValDecl.Name = NamingHelper.GetUniqueName("retVal", DoesParameterNameExist, endMethod);
                retValDecl.InitExpression = invokeEnd;
                retArray.Initializers.Add(new CodeVariableReferenceExpression(retValDecl.Name));

                onEndOperationMethod.Statements.Add(retValDecl);
            }
            else
            {
                onEndOperationMethod.Statements.Add(invokeEnd);
            }

            if (retArray.Initializers.Count > 0)
            {
                onEndOperationMethod.Statements.Add(new CodeMethodReturnStatement(retArray));
            }
            else
            {
                onEndOperationMethod.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
            }

            clientType.Members.Add(onEndOperationMethod);
            return onEndOperationMethod;
        }

        static CodeMemberField CreateOperationCompletedDelegate(ServiceContractGenerationContext context, 
            CodeTypeDeclaration clientType, string syncMethodName)
        {
            CodeMemberField operationCompletedDelegate = new CodeMemberField();
            operationCompletedDelegate.Attributes = MemberAttributes.Private;
            operationCompletedDelegate.Type = new CodeTypeReference(sendOrPostCallbackType);
            operationCompletedDelegate.Name = NamingHelper.GetUniqueName(GetOperationCompletedDelegateName(syncMethodName),
                DoesMethodNameExist, context.Operations);

            clientType.Members.Add(operationCompletedDelegate);
            return operationCompletedDelegate;
        }

        static CodeMemberMethod CreateOperationCompletedMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, 
            string syncMethodName, CodeTypeDeclaration operationCompletedEventArgsType, CodeMemberEvent operationCompletedEvent)
        {
            CodeMemberMethod operationCompletedMethod = new CodeMemberMethod();
            operationCompletedMethod.Attributes = MemberAttributes.Private;
            operationCompletedMethod.Name = NamingHelper.GetUniqueName(GetOperationCompletedMethodName(syncMethodName), 
                DoesMethodNameExist, context.Operations);

            operationCompletedMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(objectType), "state"));
            operationCompletedMethod.ReturnType = new CodeTypeReference(voidType);

            CodeVariableDeclarationStatement eventArgsDecl =
                new CodeVariableDeclarationStatement(invokeAsyncCompletedEventArgsTypeName, "e");

            eventArgsDecl.InitExpression = new CodeCastExpression(invokeAsyncCompletedEventArgsTypeName,
                new CodeArgumentReferenceExpression(operationCompletedMethod.Parameters[0].Name));

            CodeObjectCreateExpression newEventArgsExpr;
            CodeVariableReferenceExpression eventArgsRef = new CodeVariableReferenceExpression(eventArgsDecl.Name);
            if (operationCompletedEventArgsType != null)
            {
                newEventArgsExpr = new CodeObjectCreateExpression(operationCompletedEventArgsType.Name,
                    new CodePropertyReferenceExpression(eventArgsRef, EventArgsPropertyNames[0]),
                    new CodePropertyReferenceExpression(eventArgsRef, EventArgsPropertyNames[1]),
                    new CodePropertyReferenceExpression(eventArgsRef, EventArgsPropertyNames[2]),
                    new CodePropertyReferenceExpression(eventArgsRef, EventArgsPropertyNames[3]));
            }
            else
            {
                newEventArgsExpr = new CodeObjectCreateExpression(asyncCompletedEventArgsType,
                    new CodePropertyReferenceExpression(eventArgsRef, EventArgsPropertyNames[1]),
                    new CodePropertyReferenceExpression(eventArgsRef, EventArgsPropertyNames[2]),
                    new CodePropertyReferenceExpression(eventArgsRef, EventArgsPropertyNames[3]));
            }

            CodeEventReferenceExpression completedEvent = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), operationCompletedEvent.Name);

            CodeDelegateInvokeExpression raiseEventExpr = new CodeDelegateInvokeExpression(
                completedEvent,
                new CodeThisReferenceExpression(),
                newEventArgsExpr);

            CodeConditionStatement ifEventHandlerNotNullBlock = new CodeConditionStatement(
                new CodeBinaryOperatorExpression(
                    completedEvent,
                    CodeBinaryOperatorType.IdentityInequality,
                    new CodePrimitiveExpression(null)),
                eventArgsDecl,
                new CodeExpressionStatement(raiseEventExpr));

            operationCompletedMethod.Statements.Add(ifEventHandlerNotNullBlock);

            clientType.Members.Add(operationCompletedMethod);
            return operationCompletedMethod;
        }
        
        static CodeMemberMethod CreateEventAsyncMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, 
            string syncMethodName, CodeMemberMethod beginMethod,
            CodeMemberField beginOperationDelegate, CodeMemberMethod beginOperationMethod, 
            CodeMemberField endOperationDelegate, CodeMemberMethod endOperationMethod, 
            CodeMemberField operationCompletedDelegate, CodeMemberMethod operationCompletedMethod)
        {
            CodeMemberMethod eventAsyncMethod = new CodeMemberMethod();
            eventAsyncMethod.Name = NamingHelper.GetUniqueName(GetEventAsyncMethodName(syncMethodName), 
                DoesMethodNameExist, context.Operations);
            eventAsyncMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            eventAsyncMethod.ReturnType = new CodeTypeReference(voidType);

            CodeArrayCreateExpression invokeAsyncInValues = new CodeArrayCreateExpression(new CodeTypeReference(objectArrayType));
            for (int i = 0; i < beginMethod.Parameters.Count - 2; i++)
            {
                CodeParameterDeclarationExpression beginMethodParameter = beginMethod.Parameters[i];
                CodeParameterDeclarationExpression eventAsyncMethodParameter = new CodeParameterDeclarationExpression(
                    beginMethodParameter.Type, beginMethodParameter.Name);

                eventAsyncMethodParameter.Direction = FieldDirection.In;
                eventAsyncMethod.Parameters.Add(eventAsyncMethodParameter);
                invokeAsyncInValues.Initializers.Add(new CodeVariableReferenceExpression(eventAsyncMethodParameter.Name));
            }

            string userStateParamName = NamingHelper.GetUniqueName("userState", DoesParameterNameExist, eventAsyncMethod);
            eventAsyncMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(objectType), userStateParamName));
            
            eventAsyncMethod.Statements.Add(CreateDelegateIfNotNull(beginOperationDelegate, beginOperationMethod));
            eventAsyncMethod.Statements.Add(CreateDelegateIfNotNull(endOperationDelegate, endOperationMethod));
            eventAsyncMethod.Statements.Add(CreateDelegateIfNotNull(operationCompletedDelegate, operationCompletedMethod));

            CodeMethodInvokeExpression invokeAsync = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), invokeAsyncMethodName);
            invokeAsync.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), beginOperationDelegate.Name));
            if (invokeAsyncInValues.Initializers.Count > 0)
            {
                invokeAsync.Parameters.Add(invokeAsyncInValues);
            }
            else
            {
                invokeAsync.Parameters.Add(new CodePrimitiveExpression(null));
            }
            invokeAsync.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), endOperationDelegate.Name));
            invokeAsync.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), operationCompletedDelegate.Name));
            invokeAsync.Parameters.Add(new CodeVariableReferenceExpression(userStateParamName));
        
            eventAsyncMethod.Statements.Add(new CodeExpressionStatement(invokeAsync));

            clientType.Members.Add(eventAsyncMethod);
            return eventAsyncMethod;
        }

        static CodeMemberMethod CreateEventAsyncMethodOverload(CodeTypeDeclaration clientType, CodeMemberMethod eventAsyncMethod)
        {
            CodeMemberMethod eventAsyncMethodOverload = new CodeMemberMethod();
            eventAsyncMethodOverload.Attributes = eventAsyncMethod.Attributes;
            eventAsyncMethodOverload.Name = eventAsyncMethod.Name;
            eventAsyncMethodOverload.ReturnType = eventAsyncMethod.ReturnType;

            CodeMethodInvokeExpression invokeEventAsyncMethod = new CodeMethodInvokeExpression(
                new CodeThisReferenceExpression(), eventAsyncMethod.Name);

            for (int i = 0; i < eventAsyncMethod.Parameters.Count - 1; i++)
            {
                eventAsyncMethodOverload.Parameters.Add(new CodeParameterDeclarationExpression(
                    eventAsyncMethod.Parameters[i].Type,
                    eventAsyncMethod.Parameters[i].Name));

                invokeEventAsyncMethod.Parameters.Add(new CodeVariableReferenceExpression(
                    eventAsyncMethod.Parameters[i].Name));
            }
            invokeEventAsyncMethod.Parameters.Add(new CodePrimitiveExpression(null));

            eventAsyncMethodOverload.Statements.Add(invokeEventAsyncMethod);

            int eventAsyncMethodPosition = clientType.Members.IndexOf(eventAsyncMethod);
            Fx.Assert(eventAsyncMethodPosition != -1,
                "The eventAsyncMethod must be added to the clientType before calling CreateEventAsyncMethodOverload");

            clientType.Members.Insert(eventAsyncMethodPosition, eventAsyncMethodOverload);
            return eventAsyncMethodOverload;
        }

        static CodeStatement CreateDelegateIfNotNull(CodeMemberField delegateField, CodeMemberMethod delegateMethod)
        {
            return new CodeConditionStatement(
                new CodeBinaryOperatorExpression(
                    new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), delegateField.Name),
                    CodeBinaryOperatorType.IdentityEquality,
                    new CodePrimitiveExpression(null)),
                new CodeAssignStatement(
                    new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), delegateField.Name),
                    new CodeDelegateCreateExpression(delegateField.Type, 
                        new CodeThisReferenceExpression(), delegateMethod.Name)));
        }

        static string GetClassName(string interfaceName)
        {
            // maybe strip a leading 'I'
            if (interfaceName.Length >= 2 &&
                String.Compare(interfaceName, 0, Strings.InterfaceTypePrefix, 0, Strings.InterfaceTypePrefix.Length, StringComparison.Ordinal) == 0 &&
                Char.IsUpper(interfaceName, 1))
                return interfaceName.Substring(1);
            else
                return interfaceName;
        }

        static string GetEventAsyncMethodName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "{0}Async", syncMethodName);
        }

        static string GetBeginOperationDelegateName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "onBegin{0}Delegate", syncMethodName);
        }

        static string GetBeginOperationMethodName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "OnBegin{0}", syncMethodName);
        }

        static string GetEndOperationDelegateName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "onEnd{0}Delegate", syncMethodName);
        }

        static string GetEndOperationMethodName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "OnEnd{0}", syncMethodName);
        }

        static string GetOperationCompletedDelegateName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "on{0}CompletedDelegate", syncMethodName);
        }

        static string GetOperationCompletedMethodName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "On{0}Completed", syncMethodName);
        }

        static string GetOperationCompletedEventName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "{0}Completed", syncMethodName);
        }

        static string GetOperationCompletedEventArgsTypeName(string syncMethodName)
        {
            return string.Format(CultureInfo.InvariantCulture, "{0}CompletedEventArgs", syncMethodName);
        }

        static internal string GetClientClassName(string interfaceName)
        {
            return GetClassName(interfaceName) + Strings.ClientTypeSuffix;
        }

        static bool IsVoid(CodeMemberMethod method)
        {
            return method.ReturnType == null || String.Compare(method.ReturnType.BaseType, typeof(void).FullName, StringComparison.Ordinal) == 0;
        }

        static CodeExpression GetChannelReference()
        {
            return new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), Strings.ClientBaseChannelProperty);
        }

        static class Strings
        {
            public const string ClientBaseChannelProperty = "Channel";
            public const string ClientTypeSuffix = "Client";
            public const string InterfaceTypePrefix = "I";
        }
    }
}