public ContractDescription(string name, string ns) { // the property setter validates given value this.Name = name; if (!string.IsNullOrEmpty(ns)) { NamingHelper.CheckUriParameter(ns, "ns"); } _operations = new OperationDescriptionCollection(); _ns = ns ?? NamingHelper.DefaultNamespace; // ns can be "" }
public MessagePartDescription(string name, string ns) { if (name == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name", System.ServiceModel.SR.GetString("SFxParameterNameCannotBeNull")); } this.name = new System.ServiceModel.Description.XmlName(name, true); if (!string.IsNullOrEmpty(ns)) { NamingHelper.CheckUriParameter(ns, "ns"); } this.ns = ns; }
private static CodeTypeDeclaration CreateOperationCompletedEventArgsType(ServiceContractGenerationContext context, string syncMethodName, CodeMemberMethod endMethod) { if ((endMethod.Parameters.Count == 1) && (endMethod.ReturnType.BaseType == voidTypeRef.BaseType)) { return(null); } CodeTypeDeclaration ownerTypeDecl = context.TypeFactory.CreateClassType(); ownerTypeDecl.BaseTypes.Add(new CodeTypeReference(asyncCompletedEventArgsType)); CodeMemberField field = new CodeMemberField { Type = new CodeTypeReference(objectArrayType) }; CodeFieldReferenceExpression left = new CodeFieldReferenceExpression { TargetObject = new CodeThisReferenceExpression() }; CodeConstructor constructor = new CodeConstructor { Attributes = MemberAttributes.Public }; for (int i = 0; i < EventArgsCtorParamTypes.Length; i++) { constructor.Parameters.Add(new CodeParameterDeclarationExpression(EventArgsCtorParamTypes[i], EventArgsCtorParamNames[i])); if (i > 0) { constructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(EventArgsCtorParamNames[i])); } } ownerTypeDecl.Members.Add(constructor); constructor.Statements.Add(new CodeAssignStatement(left, new CodeVariableReferenceExpression(EventArgsCtorParamNames[0]))); int asyncResultParamIndex = GetAsyncResultParamIndex(endMethod); int num3 = 0; for (int j = 0; j < endMethod.Parameters.Count; j++) { if (j != asyncResultParamIndex) { CreateEventAsyncCompletedArgsTypeProperty(ownerTypeDecl, endMethod.Parameters[j].Type, endMethod.Parameters[j].Name, new CodeArrayIndexerExpression(left, new CodeExpression[] { new CodePrimitiveExpression(num3++) })); } } if (endMethod.ReturnType.BaseType != voidTypeRef.BaseType) { CreateEventAsyncCompletedArgsTypeProperty(ownerTypeDecl, endMethod.ReturnType, NamingHelper.GetUniqueName("Result", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMemberNameExist), ownerTypeDecl), new CodeArrayIndexerExpression(left, new CodeExpression[] { new CodePrimitiveExpression(num3) })); } field.Name = NamingHelper.GetUniqueName("results", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMemberNameExist), ownerTypeDecl); left.FieldName = field.Name; ownerTypeDecl.Members.Add(field); ownerTypeDecl.Name = NamingHelper.GetUniqueName(GetOperationCompletedEventArgsTypeName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesTypeAndMemberNameExist), new object[] { context.Namespace.Types, ownerTypeDecl }); context.Namespace.Types.Add(ownerTypeDecl); return(ownerTypeDecl); }
internal ChannelEndpointElement WriteChannelDescription(ServiceEndpoint endpoint, string typeName) { ChannelEndpointElement element = null; BindingDictionaryValue value2 = this.CreateBindingConfig(endpoint.Binding); element = new ChannelEndpointElement(endpoint.Address, typeName) { Name = NamingHelper.GetUniqueName(NamingHelper.CodeName(endpoint.Name), new NamingHelper.DoesNameExist(this.CheckIfChannelNameInUse), null), BindingConfiguration = value2.BindingName, Binding = value2.BindingSectionName }; this.channels.Add(element); return(element); }
private static OperationFormatter GetOperationFormatter(System.Type t, Attribute formatAttribute, string defaultNS, string action) { bool flag = formatAttribute is XmlSerializerFormatAttribute; MessageDescription description = new TypeLoader().CreateTypedMessageDescription(t, null, null, defaultNS, action, MessageDirection.Output); ContractDescription declaringContract = new ContractDescription("dummy_contract", defaultNS); OperationDescription operation = new OperationDescription(NamingHelper.XmlName(t.Name), declaringContract, false) { Messages = { description } }; if (flag) { return(XmlSerializerOperationBehavior.CreateOperationFormatter(operation, (XmlSerializerFormatAttribute)formatAttribute)); } return(new DataContractSerializerOperationFormatter(operation, (DataContractFormatAttribute)formatAttribute, null)); }
public MessagePartDescription(string name, string ns) { if (name == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name", SR.SFxParameterNameCannotBeNull); } _name = new XmlName(name, true /*isEncoded*/); if (!string.IsNullOrEmpty(ns)) { NamingHelper.CheckUriParameter(ns, "ns"); } _ns = ns; }
private BindingDictionaryValue CreateBindingConfig(Binding binding) { BindingDictionaryValue value2; if (!this.bindingTable.TryGetValue(binding, out value2)) { string str2; string name = NamingHelper.GetUniqueName(NamingHelper.CodeName(binding.Name), new NamingHelper.DoesNameExist(this.CheckIfBindingNameInUse), null); if (!BindingsSection.TryAdd(name, binding, this.config, out str2)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("ConfigBindingCannotBeConfigured"), "endpoint.Binding")); } value2 = new BindingDictionaryValue(name, str2); this.bindingTable.Add(binding, value2); } return(value2); }
private static CodeMemberEvent CreateOperationCompletedEvent(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeTypeDeclaration operationCompletedEventArgsType) { CodeMemberEvent event2 = new CodeMemberEvent { Attributes = MemberAttributes.Public, Type = new CodeTypeReference(eventHandlerType) }; if (operationCompletedEventArgsType == null) { event2.Type.TypeArguments.Add(asyncCompletedEventArgsType); } else { event2.Type.TypeArguments.Add(operationCompletedEventArgsType.Name); } event2.Name = NamingHelper.GetUniqueName(GetOperationCompletedEventName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations); clientType.Members.Add(event2); return(event2); }
private static CodeMemberMethod CreateEventAsyncMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod beginMethod, CodeMemberField beginOperationDelegate, CodeMemberMethod beginOperationMethod, CodeMemberField endOperationDelegate, CodeMemberMethod endOperationMethod, CodeMemberField operationCompletedDelegate, CodeMemberMethod operationCompletedMethod) { CodeMemberMethod nameCollection = new CodeMemberMethod { Name = NamingHelper.GetUniqueName(GetEventAsyncMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations), Attributes = MemberAttributes.Public | MemberAttributes.Final, ReturnType = new CodeTypeReference(voidType) }; CodeArrayCreateExpression expression = new CodeArrayCreateExpression(new CodeTypeReference(objectArrayType), new CodeExpression[0]); for (int i = 0; i < (beginMethod.Parameters.Count - 2); i++) { CodeParameterDeclarationExpression expression2 = beginMethod.Parameters[i]; CodeParameterDeclarationExpression expression3 = new CodeParameterDeclarationExpression(expression2.Type, expression2.Name) { Direction = FieldDirection.In }; nameCollection.Parameters.Add(expression3); expression.Initializers.Add(new CodeVariableReferenceExpression(expression3.Name)); } string name = NamingHelper.GetUniqueName("userState", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), nameCollection); nameCollection.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(objectType), name)); nameCollection.Statements.Add(CreateDelegateIfNotNull(beginOperationDelegate, beginOperationMethod)); nameCollection.Statements.Add(CreateDelegateIfNotNull(endOperationDelegate, endOperationMethod)); nameCollection.Statements.Add(CreateDelegateIfNotNull(operationCompletedDelegate, operationCompletedMethod)); CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), invokeAsyncMethodName, new CodeExpression[0]); expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), beginOperationDelegate.Name)); if (expression.Initializers.Count > 0) { expression4.Parameters.Add(expression); } else { expression4.Parameters.Add(new CodePrimitiveExpression(null)); } expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), endOperationDelegate.Name)); expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), operationCompletedDelegate.Name)); expression4.Parameters.Add(new CodeVariableReferenceExpression(name)); nameCollection.Statements.Add(new CodeExpressionStatement(expression4)); clientType.Members.Add(nameCollection); return(nameCollection); }
private void ExportMembersMapping(XmlMembersMapping membersMapping, Message message, bool skipSchemaExport, bool isEncoded, bool isRpc, bool isDocWrapped, bool isHeader) { if (!skipSchemaExport) { if (isEncoded) { this.SoapExporter.ExportMembersMapping(membersMapping); } else { this.XmlExporter.ExportMembersMapping(membersMapping, !isRpc); } } if (isDocWrapped) { if (isHeader) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Header cannot be Document Wrapped", new object[0]))); } MessageContractExporter.AddMessagePart(message, "parameters", new XmlQualifiedName(membersMapping.XsdElementName, membersMapping.Namespace), XmlQualifiedName.Empty); } else { bool flag = !isRpc && !isEncoded; for (int i = 0; i < membersMapping.Count; i++) { XmlMemberMapping mapping = membersMapping[i]; string partName = (isHeader || flag) ? NamingHelper.XmlName(mapping.MemberName) : mapping.XsdElementName; if (flag) { MessageContractExporter.AddMessagePart(message, partName, new XmlQualifiedName(mapping.XsdElementName, mapping.Namespace), XmlQualifiedName.Empty); } else { if (string.IsNullOrEmpty(mapping.TypeName)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxAnonymousTypeNotSupported", new object[] { message.Name, partName }))); } MessageContractExporter.AddMessagePart(message, partName, XmlQualifiedName.Empty, new XmlQualifiedName(mapping.TypeName, mapping.TypeNamespace)); } } } }
static OperationFormatter GetOperationFormatter(Type t, Attribute formatAttribute, string defaultNS, string action) { bool isXmlSerializer = (formatAttribute is XmlSerializerFormatAttribute); TypeLoader typeLoader = new TypeLoader(); MessageDescription message = typeLoader.CreateTypedMessageDescription(t, null, null, defaultNS, action, MessageDirection.Output); ContractDescription contract = new ContractDescription("dummy_contract", defaultNS); OperationDescription operation = new OperationDescription(NamingHelper.XmlName(t.Name), contract, false); operation.Messages.Add(message); if (isXmlSerializer) { return(XmlSerializerOperationBehavior.CreateOperationFormatter(operation, (XmlSerializerFormatAttribute)formatAttribute)); } else { return(new DataContractSerializerOperationFormatter(operation, (DataContractFormatAttribute)formatAttribute, null)); } }
private static void MergeWsdl(WsdlNS.ServiceDescription singleWsdl, WsdlNS.ServiceDescription wsdl, Dictionary <XmlQualifiedName, XmlQualifiedName> bindingReferenceChanges) { if (wsdl.Services.Count > 0) { singleWsdl.Name = wsdl.Name; } foreach (WsdlNS.Binding binding in wsdl.Bindings) { string uniqueBindingName = NamingHelper.GetUniqueName(binding.Name, WsdlHelper.IsBindingNameUsed, singleWsdl.Bindings); if (binding.Name != uniqueBindingName) { bindingReferenceChanges.Add( new XmlQualifiedName(binding.Name, binding.ServiceDescription.TargetNamespace), new XmlQualifiedName(uniqueBindingName, singleWsdl.TargetNamespace)); UpdatePolicyKeys(binding, uniqueBindingName, wsdl); binding.Name = uniqueBindingName; } singleWsdl.Bindings.Add(binding); } foreach (object extension in wsdl.Extensions) { singleWsdl.Extensions.Add(extension); } foreach (WsdlNS.Message message in wsdl.Messages) { singleWsdl.Messages.Add(message); } foreach (WsdlNS.Service service in wsdl.Services) { singleWsdl.Services.Add(service); } foreach (string warning in wsdl.ValidationWarnings) { singleWsdl.ValidationWarnings.Add(warning); } }
internal ChannelEndpointElement WriteChannelDescription(ServiceEndpoint endpoint, string typeName) { ChannelEndpointElement channelElement = null; // Create Binding BindingDictionaryValue bindingDV = CreateBindingConfig(endpoint.Binding); channelElement = new ChannelEndpointElement(endpoint.Address, typeName); // [....]: review: Use decoded form to preserve the user-given friendly name, however, beacuse our Encoding algorithm // does not touch ASCII names, a name that looks like encoded name will not roundtrip(Example: "_x002C_" will turned into ",") channelElement.Name = NamingHelper.GetUniqueName(NamingHelper.CodeName(endpoint.Name), this.CheckIfChannelNameInUse, null); channelElement.BindingConfiguration = bindingDV.BindingName; channelElement.Binding = bindingDV.BindingSectionName; channels.Add(channelElement); return(channelElement); }
BindingDictionaryValue CreateBindingConfig(Binding binding) { BindingDictionaryValue bindingDV; if (!bindingTable.TryGetValue(binding, out bindingDV)) { // [....]: review: Use decoded form to preserve the user-given friendly name, however, beacuse our Encoding algorithm // does not touch ASCII names, a name that looks like encoded name will not roundtrip(Example: "_x002C_" will turned into ",") string bindingName = NamingHelper.GetUniqueName(NamingHelper.CodeName(binding.Name), this.CheckIfBindingNameInUse, null); string bindingSectionName; if (!BindingsSection.TryAdd(bindingName, binding, config, out bindingSectionName)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.ConfigBindingCannotBeConfigured), "endpoint.Binding")); } bindingDV = new BindingDictionaryValue(bindingName, bindingSectionName); bindingTable.Add(binding, bindingDV); } return(bindingDV); }
void AddServiceContractAttribute(ServiceContractGenerationContext context) { CodeAttributeDeclaration serviceContractAttr = new CodeAttributeDeclaration(context.ServiceContractGenerator.GetCodeTypeReference(typeof(ServiceContractAttribute))); if (context.ContractType.Name != context.Contract.CodeName) { // make sure that decoded Contract name can be used, if not, then override name with encoded value // specified in wsdl; this only works beacuse our Encoding algorithm will leave alredy encoded names untouched string friendlyName = NamingHelper.XmlName(context.Contract.CodeName) == context.Contract.Name ? context.Contract.CodeName : context.Contract.Name; serviceContractAttr.Arguments.Add(new CodeAttributeArgument("Name", new CodePrimitiveExpression(friendlyName))); } if (NamingHelper.DefaultNamespace != context.Contract.Namespace) { serviceContractAttr.Arguments.Add(new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(context.Contract.Namespace))); } serviceContractAttr.Arguments.Add(new CodeAttributeArgument("ConfigurationName", new CodePrimitiveExpression(NamespaceHelper.GetCodeTypeReference(context.Namespace, context.ContractType).BaseType))); if (context.Contract.HasProtectionLevel) { serviceContractAttr.Arguments.Add(new CodeAttributeArgument("ProtectionLevel", new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(typeof(ProtectionLevel)), context.Contract.ProtectionLevel.ToString()))); } if (context.DuplexCallbackType != null) { serviceContractAttr.Arguments.Add(new CodeAttributeArgument("CallbackContract", new CodeTypeOfExpression(context.DuplexCallbackTypeReference))); } if (context.Contract.SessionMode != SessionMode.Allowed) { serviceContractAttr.Arguments.Add(new CodeAttributeArgument("SessionMode", new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(typeof(SessionMode)), context.Contract.SessionMode.ToString()))); } context.ContractType.CustomAttributes.Add(serviceContractAttr); }
private static CodeMemberMethod CreateBeginOperationMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod beginMethod) { CodeMemberMethod method = new CodeMemberMethod { Attributes = MemberAttributes.Private, ReturnType = new CodeTypeReference(asyncResultType), Name = NamingHelper.GetUniqueName(GetBeginOperationMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations) }; CodeParameterDeclarationExpression expression = new CodeParameterDeclarationExpression { Type = new CodeTypeReference(objectArrayType), Name = NamingHelper.GetUniqueName("inValues", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), beginMethod) }; method.Parameters.Add(expression); CodeMethodInvokeExpression expression2 = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), beginMethod.Name, new CodeExpression[0]); CodeExpression targetObject = new CodeVariableReferenceExpression(expression.Name); for (int i = 0; i < (beginMethod.Parameters.Count - 2); i++) { CodeVariableDeclarationStatement statement; statement = new CodeVariableDeclarationStatement { Type = beginMethod.Parameters[i].Type, Name = beginMethod.Parameters[i].Name, InitExpression = new CodeCastExpression(statement.Type, new CodeArrayIndexerExpression(targetObject, new CodeExpression[] { new CodePrimitiveExpression(i) })) }; method.Statements.Add(statement); expression2.Parameters.Add(new CodeDirectionExpression(beginMethod.Parameters[i].Direction, new CodeVariableReferenceExpression(statement.Name))); } for (int j = beginMethod.Parameters.Count - 2; j < beginMethod.Parameters.Count; j++) { method.Parameters.Add(new CodeParameterDeclarationExpression(beginMethod.Parameters[j].Type, beginMethod.Parameters[j].Name)); expression2.Parameters.Add(new CodeVariableReferenceExpression(beginMethod.Parameters[j].Name)); } method.Statements.Add(new CodeMethodReturnStatement(expression2)); clientType.Members.Add(method); return(method); }
static internal XmlName GetOperationName(MethodInfo method) { OperationContractAttribute operationAttribute = GetOperationContractAttribute(method); return(NamingHelper.GetOperationName(GetLogicalName(method), operationAttribute.Name)); }
private static CodeMethodReturnStatement GenerateParameters(CodeMemberMethod helperMethod, CodeTypeDeclaration codeTypeDeclaration, CodeExpression target, FieldDirection dir) { CodeMethodReturnStatement statement = null; foreach (CodeTypeMember member in codeTypeDeclaration.Members) { CodeMemberField field = member as CodeMemberField; if (field != null) { CodeFieldReferenceExpression left = new CodeFieldReferenceExpression(target, field.Name); CodeTypeDeclaration codeType = ServiceContractGenerator.NamespaceHelper.GetCodeType(field.Type); if (codeType != null) { if (dir == FieldDirection.In) { helperMethod.Statements.Add(new CodeAssignStatement(left, new CodeObjectCreateExpression(field.Type, new CodeExpression[0]))); } statement = GenerateParameters(helperMethod, codeType, left, dir); } else { CodeParameterDeclarationExpression expression2 = GetRefParameter(helperMethod.Parameters, dir, field); if (((expression2 == null) && (dir == FieldDirection.Out)) && (helperMethod.ReturnType.BaseType == voidTypeRef.BaseType)) { helperMethod.ReturnType = field.Type; statement = new CodeMethodReturnStatement(left); } else { if (expression2 == null) { expression2 = new CodeParameterDeclarationExpression(field.Type, NamingHelper.GetUniqueName(field.Name, new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), helperMethod)) { Direction = dir }; helperMethod.Parameters.Add(expression2); } if (dir == FieldDirection.Out) { helperMethod.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression(expression2.Name), left)); } else { helperMethod.Statements.Add(new CodeAssignStatement(left, new CodeArgumentReferenceExpression(expression2.Name))); } } } } } return(statement); }
void IServiceContractGenerationExtension.GenerateContract(ServiceContractGenerationContext context) { CodeTypeDeclaration clientType = context.TypeFactory.CreateClassType(); clientType.Name = NamingHelper.GetUniqueName(GetClientClassName(context.ContractType.Name), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations); CodeTypeReference contractTypeReference = context.ContractTypeReference; if (context.DuplexCallbackType == null) { clientType.BaseTypes.Add(new CodeTypeReference(context.ServiceContractGenerator.GetCodeTypeReference(typeof(ClientBase <>)).BaseType, new CodeTypeReference[] { context.ContractTypeReference })); } else { clientType.BaseTypes.Add(new CodeTypeReference(context.ServiceContractGenerator.GetCodeTypeReference(typeof(DuplexClientBase <>)).BaseType, new CodeTypeReference[] { context.ContractTypeReference })); } clientType.BaseTypes.Add(context.ContractTypeReference); if (ClientCtorParamNames.Length != ClientCtorParamTypes.Length) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Invalid client generation constructor table initialization", new object[0]))); } for (int i = 0; i < ClientCtorParamNames.Length; i++) { if (ClientCtorParamNames[i].Length != ClientCtorParamTypes[i].Length) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Invalid client generation constructor table initialization", new object[0]))); } CodeConstructor constructor = new CodeConstructor { Attributes = MemberAttributes.Public }; if (context.DuplexCallbackType != null) { constructor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(InstanceContext), inputInstanceName)); constructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(inputInstanceName)); } for (int j = 0; j < ClientCtorParamNames[i].Length; j++) { constructor.Parameters.Add(new CodeParameterDeclarationExpression(ClientCtorParamTypes[i][j], ClientCtorParamNames[i][j])); constructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(ClientCtorParamNames[i][j])); } clientType.Members.Add(constructor); } foreach (OperationContractGenerationContext context2 in context.Operations) { if (!context2.Operation.IsServerInitiated()) { CodeTypeReference declaringTypeReference = context2.DeclaringTypeReference; GenerateClientClassMethod(clientType, contractTypeReference, context2.SyncMethod, this.tryAddHelperMethod, declaringTypeReference); if (context2.IsAsync) { CodeMemberMethod beginMethod = GenerateClientClassMethod(clientType, contractTypeReference, context2.BeginMethod, this.tryAddHelperMethod, declaringTypeReference); CodeMemberMethod endMethod = GenerateClientClassMethod(clientType, contractTypeReference, context2.EndMethod, this.tryAddHelperMethod, declaringTypeReference); if (this.generateEventAsyncMethods) { GenerateEventAsyncMethods(context, clientType, context2.SyncMethod.Name, beginMethod, endMethod); } } } } context.Namespace.Types.Add(clientType); context.ClientType = clientType; context.ClientTypeReference = ServiceContractGenerator.NamespaceHelper.GetCodeTypeReference(context.Namespace, clientType); }
private string GetUniqueMessageName(System.Web.Services.Description.ServiceDescription wsdl, string messageNameBase) { return(NamingHelper.GetUniqueName(messageNameBase, new NamingHelper.DoesNameExist(MessageContractExporter.DoesMessageNameExist), wsdl)); }