ProtocolImporter FindImporterByName(string protocolName) { for (int i = 0; i < importers.Length; i++) { ProtocolImporter importer = importers[i]; if (string.Compare(ProtocolName, importer.ProtocolName, StringComparison.OrdinalIgnoreCase) == 0) { return(importer); } } throw new ArgumentException(Res.GetString(Res.ProtocolWithNameIsNotRecognized1, protocolName), "protocolName"); }
private ProtocolImporter FindImporterByName(string protocolName) { for (int i = 0; i < this.importers.Length; i++) { ProtocolImporter importer = this.importers[i]; if (string.Compare(this.ProtocolName, importer.ProtocolName, StringComparison.OrdinalIgnoreCase) == 0) { return(importer); } } throw new ArgumentException(System.Web.Services.Res.GetString("ProtocolWithNameIsNotRecognized1", new object[] { protocolName }), "protocolName"); }
ProtocolImporter FindImporterByName(string protocolName) { for (int i = 0; i < importers.Length; i++) { ProtocolImporter importer = importers[i]; if (string.Compare(ProtocolName, importer.ProtocolName, true, CultureInfo.InvariantCulture) == 0) { return(importer); } } // SOAP12: disable soap 1.2 proxy generation if (string.Compare(ProtocolName, "Soap12", true, CultureInfo.InvariantCulture) == 0) { throw new InvalidOperationException(Res.GetString(Res.WebSoap12NotSupported)); } throw new ArgumentException(Res.GetString(Res.ProtocolWithNameIsNotRecognized1, protocolName), "protocolName"); }
void GenerateCode(string typeName, MimeTextMatchCollection matches, CodeGenerationOptions options) { CodeIdentifiers members = new CodeIdentifiers(); CodeTypeDeclaration codeClass = WebCodeGenerator.AddClass(ImportContext.CodeNamespace, typeName, string.Empty, new string[0], null, CodeFlags.IsPublic, ImportContext.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.PartialTypes)); string[] fieldTypeNames = new string[matches.Count]; for (int i = 0; i < matches.Count; i++) { MimeTextMatch match = matches[i]; string name = members.AddUnique(CodeIdentifier.MakeValid(match.Name.Length == 0 ? methodName + "Match" : match.Name), match); CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection(); if (match.Pattern.Length == 0) { throw new ArgumentException(Res.GetString(Res.WebTextMatchMissingPattern)); } CodeExpression pattern = new CodePrimitiveExpression(match.Pattern); int numPropValues = 0; if (match.Group != 1) { numPropValues++; } if (match.Capture != 0) { numPropValues++; } if (match.IgnoreCase) { numPropValues++; } if (match.Repeats != 1 && match.Repeats != int.MaxValue) { numPropValues++; } CodeExpression[] propertyValues = new CodeExpression[numPropValues]; string[] propertyNames = new string[propertyValues.Length]; numPropValues = 0; if (match.Group != 1) { propertyValues[numPropValues] = new CodePrimitiveExpression(match.Group); propertyNames[numPropValues] = "Group"; numPropValues++; } if (match.Capture != 0) { propertyValues[numPropValues] = new CodePrimitiveExpression(match.Capture); propertyNames[numPropValues] = "Capture"; numPropValues++; } if (match.IgnoreCase) { propertyValues[numPropValues] = new CodePrimitiveExpression(match.IgnoreCase); propertyNames[numPropValues] = "IgnoreCase"; numPropValues++; } if (match.Repeats != 1 && match.Repeats != int.MaxValue) { propertyValues[numPropValues] = new CodePrimitiveExpression(match.Repeats); propertyNames[numPropValues] = "MaxRepeats"; numPropValues++; } WebCodeGenerator.AddCustomAttribute(metadata, typeof(MatchAttribute), new CodeExpression[] { pattern }, propertyNames, propertyValues); string fieldTypeName; if (match.Matches.Count > 0) { fieldTypeName = ImportContext.ClassNames.AddUnique(CodeIdentifier.MakeValid(match.Type.Length == 0 ? name : match.Type), match); fieldTypeNames[i] = fieldTypeName; } else { fieldTypeName = typeof(string).FullName; } if (match.Repeats != 1) { fieldTypeName += "[]"; } CodeTypeMember member = WebCodeGenerator.AddMember(codeClass, fieldTypeName, name, null, metadata, CodeFlags.IsPublic, options); if (match.Matches.Count == 0 && match.Type.Length > 0) { ImportContext.Warnings |= ServiceDescriptionImportWarnings.OptionalExtensionsIgnored; ProtocolImporter.AddWarningComment(member.Comments, Res.GetString(Res.WebTextMatchIgnoredTypeWarning)); } } for (int i = 0; i < fieldTypeNames.Length; i++) { string fieldTypeName = fieldTypeNames[i]; if (fieldTypeName != null) { GenerateCode(fieldTypeName, matches[i].Matches, options); } } }
private ServiceDescriptionImportWarnings Import(CodeNamespace codeNamespace, System.Xml.Serialization.ImportContext importContext, Hashtable exportContext, StringCollection warnings) { Hashtable hashtable2; this.allSchemas = new XmlSchemas(); foreach (XmlSchema schema in this.schemas) { this.allSchemas.Add(schema); } foreach (ServiceDescription description in this.serviceDescriptions) { foreach (XmlSchema schema2 in description.Types.Schemas) { this.allSchemas.Add(schema2); } } Hashtable references = new Hashtable(); if (!this.allSchemas.Contains("http://schemas.xmlsoap.org/wsdl/")) { this.allSchemas.AddReference(ServiceDescription.Schema); references[ServiceDescription.Schema] = ServiceDescription.Schema; } if (!this.allSchemas.Contains("http://schemas.xmlsoap.org/soap/encoding/")) { this.allSchemas.AddReference(ServiceDescription.SoapEncodingSchema); references[ServiceDescription.SoapEncodingSchema] = ServiceDescription.SoapEncodingSchema; } this.allSchemas.Compile(null, false); foreach (ServiceDescription description2 in this.serviceDescriptions) { foreach (Message message in description2.Messages) { foreach (MessagePart part in message.Parts) { bool flag; bool flag2; this.FindUse(part, out flag, out flag2); if ((part.Element != null) && !part.Element.IsEmpty) { if (flag) { throw new InvalidOperationException(System.Web.Services.Res.GetString("CanTSpecifyElementOnEncodedMessagePartsPart", new object[] { part.Name, message.Name })); } XmlSchemaElement element = (XmlSchemaElement)this.allSchemas.Find(part.Element, typeof(XmlSchemaElement)); if (element != null) { AddSchema(element.Parent as XmlSchema, flag, flag2, this.abstractSchemas, this.concreteSchemas, references); if ((element.SchemaTypeName != null) && !element.SchemaTypeName.IsEmpty) { XmlSchemaType type = (XmlSchemaType)this.allSchemas.Find(element.SchemaTypeName, typeof(XmlSchemaType)); if (type != null) { AddSchema(type.Parent as XmlSchema, flag, flag2, this.abstractSchemas, this.concreteSchemas, references); } } } } if ((part.Type != null) && !part.Type.IsEmpty) { XmlSchemaType type2 = (XmlSchemaType)this.allSchemas.Find(part.Type, typeof(XmlSchemaType)); if (type2 != null) { AddSchema(type2.Parent as XmlSchema, flag, flag2, this.abstractSchemas, this.concreteSchemas, references); } } } } } foreach (XmlSchemas schemas in new XmlSchemas[] { this.abstractSchemas, this.concreteSchemas }) { hashtable2 = new Hashtable(); foreach (XmlSchema schema3 in schemas) { this.AddImport(schema3, hashtable2); } foreach (XmlSchema schema4 in hashtable2.Keys) { if ((references[schema4] == null) && !schemas.Contains(schema4)) { schemas.Add(schema4); } } } hashtable2 = new Hashtable(); foreach (XmlSchema schema5 in this.allSchemas) { if (!this.abstractSchemas.Contains(schema5) && !this.concreteSchemas.Contains(schema5)) { this.AddImport(schema5, hashtable2); } } foreach (XmlSchema schema6 in hashtable2.Keys) { if (references[schema6] == null) { if (!this.abstractSchemas.Contains(schema6)) { this.abstractSchemas.Add(schema6); } if (!this.concreteSchemas.Contains(schema6)) { this.concreteSchemas.Add(schema6); } } } if (this.abstractSchemas.Count > 0) { foreach (XmlSchema schema7 in references.Values) { this.abstractSchemas.AddReference(schema7); } foreach (string str in SchemaCompiler.Compile(this.abstractSchemas)) { warnings.Add(str); } } if (this.concreteSchemas.Count > 0) { foreach (XmlSchema schema8 in references.Values) { this.concreteSchemas.AddReference(schema8); } foreach (string str2 in SchemaCompiler.Compile(this.concreteSchemas)) { warnings.Add(str2); } } if (this.ProtocolName.Length > 0) { ProtocolImporter importer = this.FindImporterByName(this.ProtocolName); if (importer.GenerateCode(codeNamespace, importContext, exportContext)) { return(importer.Warnings); } } else { for (int i = 0; i < this.importers.Length; i++) { ProtocolImporter importer2 = this.importers[i]; if (importer2.GenerateCode(codeNamespace, importContext, exportContext)) { return(importer2.Warnings); } } } return(ServiceDescriptionImportWarnings.NoCodeGenerated); }
private void GenerateCode(string typeName, MimeTextMatchCollection matches, CodeGenerationOptions options) { CodeIdentifiers identifiers = new CodeIdentifiers(); CodeTypeDeclaration codeClass = WebCodeGenerator.AddClass(base.ImportContext.CodeNamespace, typeName, string.Empty, new string[0], null, CodeFlags.IsPublic, base.ImportContext.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.PartialTypes)); string[] strArray = new string[matches.Count]; for (int i = 0; i < matches.Count; i++) { string fullName; MimeTextMatch match = matches[i]; string memberName = identifiers.AddUnique(CodeIdentifier.MakeValid((match.Name.Length == 0) ? (this.methodName + "Match") : match.Name), match); CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection(); if (match.Pattern.Length == 0) { throw new ArgumentException(Res.GetString("WebTextMatchMissingPattern")); } CodeExpression expression = new CodePrimitiveExpression(match.Pattern); int index = 0; if (match.Group != 1) { index++; } if (match.Capture != 0) { index++; } if (match.IgnoreCase) { index++; } if ((match.Repeats != 1) && (match.Repeats != 0x7fffffff)) { index++; } CodeExpression[] propValues = new CodeExpression[index]; string[] propNames = new string[propValues.Length]; index = 0; if (match.Group != 1) { propValues[index] = new CodePrimitiveExpression(match.Group); propNames[index] = "Group"; index++; } if (match.Capture != 0) { propValues[index] = new CodePrimitiveExpression(match.Capture); propNames[index] = "Capture"; index++; } if (match.IgnoreCase) { propValues[index] = new CodePrimitiveExpression(match.IgnoreCase); propNames[index] = "IgnoreCase"; index++; } if ((match.Repeats != 1) && (match.Repeats != 0x7fffffff)) { propValues[index] = new CodePrimitiveExpression(match.Repeats); propNames[index] = "MaxRepeats"; index++; } WebCodeGenerator.AddCustomAttribute(metadata, typeof(MatchAttribute), new CodeExpression[] { expression }, propNames, propValues); if (match.Matches.Count > 0) { fullName = base.ImportContext.ClassNames.AddUnique(CodeIdentifier.MakeValid((match.Type.Length == 0) ? memberName : match.Type), match); strArray[i] = fullName; } else { fullName = typeof(string).FullName; } if (match.Repeats != 1) { fullName = fullName + "[]"; } CodeTypeMember member = WebCodeGenerator.AddMember(codeClass, fullName, memberName, null, metadata, CodeFlags.IsPublic, options); if ((match.Matches.Count == 0) && (match.Type.Length > 0)) { HttpProtocolImporter importContext = base.ImportContext; importContext.Warnings |= ServiceDescriptionImportWarnings.OptionalExtensionsIgnored; ProtocolImporter.AddWarningComment(member.Comments, Res.GetString("WebTextMatchIgnoredTypeWarning")); } } for (int j = 0; j < strArray.Length; j++) { string str3 = strArray[j]; if (str3 != null) { this.GenerateCode(str3, matches[j].Matches, options); } } }
private ServiceDescriptionImportWarnings Import(CodeNamespace codeNamespace, ImportContext importContext, Hashtable exportContext, StringCollection warnings) { allSchemas = new XmlSchemas(); foreach (XmlSchema schema in schemas) { allSchemas.Add(schema); } foreach (ServiceDescription description in serviceDescriptions) { foreach (XmlSchema schema in description.Types.Schemas) { allSchemas.Add(schema); } } Hashtable references = new Hashtable(); if (!allSchemas.Contains(ServiceDescription.Namespace)) { allSchemas.AddReference(ServiceDescription.Schema); references[ServiceDescription.Schema] = ServiceDescription.Schema; } if (!allSchemas.Contains(Soap.Encoding)) { allSchemas.AddReference(ServiceDescription.SoapEncodingSchema); references[ServiceDescription.SoapEncodingSchema] = ServiceDescription.SoapEncodingSchema; } allSchemas.Compile(null, false); // Segregate the schemas containing abstract types from those // containing regular XML definitions. This is important because // when you import something returning the ur-type (object), then // you need to import ALL types/elements within ALL schemas. We // don't want the RPC-based types leaking over into the XML-based // element definitions. This also occurs when you have derivation: // we need to search the schemas for derived types: but WHICH schemas // should we search. foreach (ServiceDescription description in serviceDescriptions) { foreach (Message message in description.Messages) { foreach (MessagePart part in message.Parts) { bool isEncoded; bool isLiteral; FindUse(part, out isEncoded, out isLiteral); if (part.Element != null && !part.Element.IsEmpty) { if (isEncoded) { throw new InvalidOperationException(Res.GetString(Res.CanTSpecifyElementOnEncodedMessagePartsPart, part.Name, message.Name)); } XmlSchemaElement element = (XmlSchemaElement)allSchemas.Find(part.Element, typeof(XmlSchemaElement)); if (element != null) { AddSchema(element.Parent as XmlSchema, isEncoded, isLiteral, abstractSchemas, concreteSchemas, references); if (element.SchemaTypeName != null && !element.SchemaTypeName.IsEmpty) { XmlSchemaType type = (XmlSchemaType)allSchemas.Find(element.SchemaTypeName, typeof(XmlSchemaType)); if (type != null) { AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, abstractSchemas, concreteSchemas, references); } } } } if (part.Type != null && !part.Type.IsEmpty) { XmlSchemaType type = (XmlSchemaType)allSchemas.Find(part.Type, typeof(XmlSchemaType)); if (type != null) { AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, abstractSchemas, concreteSchemas, references); } } } } } Hashtable imports; foreach (XmlSchemas xmlschemas in new XmlSchemas[] { abstractSchemas, concreteSchemas }) { // collect all imports imports = new Hashtable(); foreach (XmlSchema schema in xmlschemas) { AddImport(schema, imports); } // make sure we add them to the corresponding schema collections foreach (XmlSchema schema in imports.Keys) { if (references[schema] == null && !xmlschemas.Contains(schema)) { xmlschemas.Add(schema); } } } // If a schema was not referenced by either a literal or an encoded message part, // add it to both collections. There's no way to tell which it should be. imports = new Hashtable(); foreach (XmlSchema schema in allSchemas) { if (!abstractSchemas.Contains(schema) && !concreteSchemas.Contains(schema)) { AddImport(schema, imports); } } // make sure we add them to the corresponding schema collections foreach (XmlSchema schema in imports.Keys) { if (references[schema] != null) { continue; } if (!abstractSchemas.Contains(schema)) { abstractSchemas.Add(schema); } if (!concreteSchemas.Contains(schema)) { concreteSchemas.Add(schema); } } if (abstractSchemas.Count > 0) { foreach (XmlSchema schema in references.Values) { abstractSchemas.AddReference(schema); } StringCollection schemaWarnings = SchemaCompiler.Compile(abstractSchemas); foreach (string warning in schemaWarnings) { warnings.Add(warning); } } if (concreteSchemas.Count > 0) { foreach (XmlSchema schema in references.Values) { concreteSchemas.AddReference(schema); } StringCollection schemaWarnings = SchemaCompiler.Compile(concreteSchemas); foreach (string warning in schemaWarnings) { warnings.Add(warning); } } if (ProtocolName.Length > 0) { // If a protocol was specified, only try that one ProtocolImporter importer = FindImporterByName(ProtocolName); if (importer.GenerateCode(codeNamespace, importContext, exportContext)) { return(importer.Warnings); } } else { // Otherwise, do "best" protocol (first one that generates something) for (int i = 0; i < importers.Length; i++) { ProtocolImporter importer = importers[i]; if (importer.GenerateCode(codeNamespace, importContext, exportContext)) { return(importer.Warnings); } } } return(ServiceDescriptionImportWarnings.NoCodeGenerated); }
private CodeMemberMethod GenerateMethod(HttpMethodInfo method) { MimeParameterCollection parameters = (method.MimeParameters != null) ? method.MimeParameters : method.UrlParameters; string[] parameterTypeNames = new string[parameters.Count]; string[] parameterNames = new string[parameters.Count]; for (int i = 0; i < parameters.Count; i++) { MimeParameter parameter = parameters[i]; parameterNames[i] = parameter.Name; parameterTypeNames[i] = parameter.TypeName; } CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection(); CodeExpression[] expressionArray = new CodeExpression[2]; if (method.MimeReturn.ReaderType == null) { expressionArray[0] = new CodeTypeOfExpression(typeof(NopReturnReader).FullName); } else { expressionArray[0] = new CodeTypeOfExpression(method.MimeReturn.ReaderType.FullName); } if (method.MimeParameters != null) { expressionArray[1] = new CodeTypeOfExpression(method.MimeParameters.WriterType.FullName); } else { expressionArray[1] = new CodeTypeOfExpression(typeof(UrlParameterWriter).FullName); } WebCodeGenerator.AddCustomAttribute(metadata, typeof(HttpMethodAttribute), expressionArray, new string[0], new CodeExpression[0]); CodeMemberMethod method2 = WebCodeGenerator.AddMethod(base.CodeTypeDeclaration, method.Name, new CodeFlags[parameterTypeNames.Length], parameterTypeNames, parameterNames, method.MimeReturn.TypeName, metadata, CodeFlags.IsPublic | ((base.Style == ServiceDescriptionImportStyle.Client) ? ((CodeFlags)0) : CodeFlags.IsAbstract)); AppendMetadata(method.MimeReturn.Attributes, method2.ReturnTypeCustomAttributes); method2.Comments.Add(new CodeCommentStatement(System.Web.Services.Res.GetString("CodeRemarks"), true)); for (int j = 0; j < parameters.Count; j++) { AppendMetadata(parameters[j].Attributes, method2.Parameters[j].CustomAttributes); } if (base.Style == ServiceDescriptionImportStyle.Client) { bool flag = (base.ServiceImporter.CodeGenerationOptions & CodeGenerationOptions.GenerateOldAsync) != CodeGenerationOptions.None; bool flag2 = (((base.ServiceImporter.CodeGenerationOptions & CodeGenerationOptions.GenerateNewAsync) != CodeGenerationOptions.None) && base.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareEvents)) && base.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.DeclareDelegates); CodeExpression[] invokeParams = new CodeExpression[3]; this.CreateInvokeParams(invokeParams, method, parameterNames); CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "Invoke", invokeParams); if (method.MimeReturn.ReaderType != null) { method2.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(method.MimeReturn.TypeName, expression))); } else { method2.Statements.Add(new CodeExpressionStatement(expression)); } metadata = new CodeAttributeDeclarationCollection(); string[] array = new string[parameterTypeNames.Length + 2]; parameterTypeNames.CopyTo(array, 0); array[parameterTypeNames.Length] = typeof(AsyncCallback).FullName; array[parameterTypeNames.Length + 1] = typeof(object).FullName; string[] strArray4 = new string[parameterNames.Length + 2]; parameterNames.CopyTo(strArray4, 0); strArray4[parameterNames.Length] = "callback"; strArray4[parameterNames.Length + 1] = "asyncState"; if (flag) { CodeMemberMethod method3 = WebCodeGenerator.AddMethod(base.CodeTypeDeclaration, "Begin" + method.Name, new CodeFlags[array.Length], array, strArray4, typeof(IAsyncResult).FullName, metadata, CodeFlags.IsPublic); method3.Comments.Add(new CodeCommentStatement(System.Web.Services.Res.GetString("CodeRemarks"), true)); invokeParams = new CodeExpression[5]; this.CreateInvokeParams(invokeParams, method, parameterNames); invokeParams[3] = new CodeArgumentReferenceExpression("callback"); invokeParams[4] = new CodeArgumentReferenceExpression("asyncState"); expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "BeginInvoke", invokeParams); method3.Statements.Add(new CodeMethodReturnStatement(expression)); CodeMemberMethod method4 = WebCodeGenerator.AddMethod(base.CodeTypeDeclaration, "End" + method.Name, new CodeFlags[1], new string[] { typeof(IAsyncResult).FullName }, new string[] { "asyncResult" }, method.MimeReturn.TypeName, metadata, CodeFlags.IsPublic); method4.Comments.Add(new CodeCommentStatement(System.Web.Services.Res.GetString("CodeRemarks"), true)); CodeExpression expression2 = new CodeArgumentReferenceExpression("asyncResult"); expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "EndInvoke", new CodeExpression[] { expression2 }); if (method.MimeReturn.ReaderType != null) { method4.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(method.MimeReturn.TypeName, expression))); } else { method4.Statements.Add(new CodeExpressionStatement(expression)); } } if (!flag2) { return(method2); } metadata = new CodeAttributeDeclarationCollection(); string name = method.Name; string str2 = ProtocolImporter.MethodSignature(name, method.MimeReturn.TypeName, new CodeFlags[parameterTypeNames.Length], parameterTypeNames); DelegateInfo info = (DelegateInfo)base.ExportContext[str2]; if (info == null) { string handlerType = base.ClassNames.AddUnique(name + "CompletedEventHandler", name); string handlerArgs = base.ClassNames.AddUnique(name + "CompletedEventArgs", name); info = new DelegateInfo(handlerType, handlerArgs); } string handlerName = base.MethodNames.AddUnique(name + "Completed", name); string methodName = base.MethodNames.AddUnique(name + "Async", name); string callbackMember = base.MethodNames.AddUnique(name + "OperationCompleted", name); string callbackName = base.MethodNames.AddUnique("On" + name + "OperationCompleted", name); WebCodeGenerator.AddEvent(base.CodeTypeDeclaration.Members, info.handlerType, handlerName); WebCodeGenerator.AddCallbackDeclaration(base.CodeTypeDeclaration.Members, callbackMember); string userState = ProtocolImporter.UniqueName("userState", parameterNames); CodeMemberMethod method5 = WebCodeGenerator.AddAsyncMethod(base.CodeTypeDeclaration, methodName, parameterTypeNames, parameterNames, callbackMember, callbackName, userState); invokeParams = new CodeExpression[5]; this.CreateInvokeParams(invokeParams, method, parameterNames); invokeParams[3] = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), callbackMember); invokeParams[4] = new CodeArgumentReferenceExpression(userState); expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "InvokeAsync", invokeParams); method5.Statements.Add(expression); bool methodHasOutParameters = method.MimeReturn.ReaderType != null; WebCodeGenerator.AddCallbackImplementation(base.CodeTypeDeclaration, callbackName, handlerName, info.handlerArgs, methodHasOutParameters); if (base.ExportContext[str2] != null) { return(method2); } WebCodeGenerator.AddDelegate(base.ExtraCodeClasses, info.handlerType, methodHasOutParameters ? info.handlerArgs : typeof(AsyncCompletedEventArgs).FullName); if (methodHasOutParameters) { base.ExtraCodeClasses.Add(WebCodeGenerator.CreateArgsClass(info.handlerArgs, new string[] { method.MimeReturn.TypeName }, new string[] { "Result" }, base.ServiceImporter.CodeGenerator.Supports(GeneratorSupport.PartialTypes))); } base.ExportContext[str2] = info; } return(method2); }
private ServiceDescriptionImportWarnings Import(CodeNamespace codeNamespace) { allSchemas = new XmlSchemas(); foreach (XmlSchema schema in schemas) { allSchemas.Add(schema); } foreach (ServiceDescription description in serviceDescriptions) { foreach (XmlSchema schema in description.Types.Schemas) { allSchemas.Add(schema); } } // Segregate the schemas containing abstract types from those // containing regular XML definitions. This is important because // when you import something returning the ur-type (object), then // you need to import ALL types/elements within ALL schemas. We // don't want the RPC-based types leaking over into the XML-based // element definitions. This also occurs when you have derivation: // we need to search the schemas for derived types: but WHICH schemas // should we search. foreach (ServiceDescription description in serviceDescriptions) { foreach (Message message in description.Messages) { foreach (MessagePart part in message.Parts) { bool isEncoded; bool isLiteral; FindUse(part, out isEncoded, out isLiteral); if (part.Element != null && !part.Element.IsEmpty) { if (isEncoded) { throw new Exception(Res.GetString(Res.CanTSpecifyElementOnEncodedMessagePartsPart, part.Name, message.Name)); } string ns = part.Element.Namespace; XmlSchema schema = allSchemas[ns]; if (schema != null) { if (isEncoded && abstractSchemas[ns] == null) { abstractSchemas.Add(schema); } if (isLiteral && concreteSchemas[ns] == null) { concreteSchemas.Add(schema); } } } if (part.Type != null && !part.Type.IsEmpty) { string ns = part.Type.Namespace; XmlSchema schema = allSchemas[ns]; if (schema != null) { if (isEncoded && abstractSchemas[ns] == null) { abstractSchemas.Add(schema); } if (isLiteral && concreteSchemas[ns] == null) { concreteSchemas.Add(schema); } } } } } } foreach (XmlSchemas schemas in new XmlSchemas[] { abstractSchemas, concreteSchemas }) { XmlSchemas additionalSchemas = new XmlSchemas(); foreach (XmlSchema schema in schemas) { foreach (object include in schema.Includes) { if (include is XmlSchemaImport) { XmlSchemaImport import = (XmlSchemaImport)include; if (import.Schema != null && !schemas.Contains(import.Schema) && !additionalSchemas.Contains(import.Schema)) { additionalSchemas.Add(import.Schema); } else if (import.Namespace != null && allSchemas[import.Namespace] != null && schemas[import.Namespace] == null && additionalSchemas[import.Namespace] == null) { additionalSchemas.Add(allSchemas[import.Namespace]); } } } } foreach (XmlSchema schema in additionalSchemas) { schemas.Add(schema); } } // If a schema was not referenced by either a literal or an encoded message part, // add it to both collections. There's no way to tell which it should be. foreach (XmlSchema schema in allSchemas) { if (!abstractSchemas.Contains(schema) && !concreteSchemas.Contains(schema)) { abstractSchemas.Add(schema); concreteSchemas.Add(schema); } } if (ProtocolName.Length > 0) { // If a protocol was specified, only try that one ProtocolImporter importer = FindImporterByName(ProtocolName); if (importer.GenerateCode(codeNamespace)) { return(importer.Warnings); } } else { // Otherwise, do "best" protocol (first one that generates something) for (int i = 0; i < importers.Length; i++) { ProtocolImporter importer = importers[i]; if (importer.GenerateCode(codeNamespace)) { return(importer.Warnings); } } } return(ServiceDescriptionImportWarnings.NoCodeGenerated); }