internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, CodeDomProvider codeProvider, System.Xml.Serialization.ImportContext context) { if (!schemas.Contains("http://www.w3.org/2001/XMLSchema")) { schemas.AddReference(XmlSchemas.XsdSchema); schemas.SchemaSet.Add(XmlSchemas.XsdSchema); } if (!schemas.Contains("http://www.w3.org/XML/1998/namespace")) { schemas.AddReference(XmlSchemas.XmlSchema); schemas.SchemaSet.Add(XmlSchemas.XmlSchema); } this.schemas = schemas; this.options = options; this.codeProvider = codeProvider; this.context = context; this.Schemas.SetCache(this.Context.Cache, this.Context.ShareTypes); SchemaImporterExtensionsSection section = System.Configuration.PrivilegedConfigurationManager.GetSection(ConfigurationStrings.SchemaImporterExtensionsSectionPath) as SchemaImporterExtensionsSection; if (section != null) { this.extensions = section.SchemaImporterExtensionsInternal; } else { this.extensions = new SchemaImporterExtensionCollection(); } }
internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, CodeDomProvider codeProvider, System.Xml.Serialization.ImportContext context) { if (!schemas.Contains("http://www.w3.org/2001/XMLSchema")) { schemas.AddReference(XmlSchemas.XsdSchema); schemas.SchemaSet.Add(XmlSchemas.XsdSchema); } if (!schemas.Contains("http://www.w3.org/XML/1998/namespace")) { schemas.AddReference(XmlSchemas.XmlSchema); schemas.SchemaSet.Add(XmlSchemas.XmlSchema); } this.schemas = schemas; this.options = options; this.codeProvider = codeProvider; this.context = context; this.Schemas.SetCache(this.Context.Cache, this.Context.ShareTypes); SchemaImporterExtensionsSection section = System.Configuration.PrivilegedConfigurationManager.GetSection(ConfigurationStrings.SchemaImporterExtensionsSectionPath) as SchemaImporterExtensionsSection; if (section != null) { this.extensions = section.SchemaImporterExtensionsInternal; } else { this.extensions = new SchemaImporterExtensionCollection(); } }
internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, CodeDomProvider codeProvider, ImportContext context) { if (!schemas.Contains(XmlSchema.Namespace)) { schemas.AddReference(XmlSchemas.XsdSchema); schemas.SchemaSet.Add(XmlSchemas.XsdSchema); } if (!schemas.Contains(XmlReservedNs.NsXml)) { schemas.AddReference(XmlSchemas.XmlSchema); schemas.SchemaSet.Add(XmlSchemas.XmlSchema); } this.schemas = schemas; this.options = options; this.codeProvider = codeProvider; this.context = context; Schemas.SetCache(Context.Cache, Context.ShareTypes); SchemaImporterExtensionsSection section = PrivilegedConfigurationManager.GetSection(ConfigurationStrings.SchemaImporterExtensionsSectionPath) as SchemaImporterExtensionsSection; if (section != null) { extensions = section.SchemaImporterExtensionsInternal; } else { extensions = new SchemaImporterExtensionCollection(); } }
internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, ImportContext context) { if (!schemas.Contains(XmlSchema.Namespace)) { schemas.AddReference(XmlSchemas.XsdSchema); schemas.SchemaSet.Add(XmlSchemas.XsdSchema); } if (!schemas.Contains(XmlReservedNs.NsXml)) { schemas.AddReference(XmlSchemas.XmlSchema); schemas.SchemaSet.Add(XmlSchemas.XmlSchema); } _schemas = schemas; _options = options; _context = context; Schemas.SetCache(Context.Cache, Context.ShareTypes); }
internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, ImportContext context) { if (!schemas.Contains(XmlSchema.Namespace)) { schemas.AddReference(XmlSchemas.XsdSchema); schemas.SchemaSet.Add(XmlSchemas.XsdSchema); } if (!schemas.Contains(XmlReservedNs.NsXml)) { schemas.AddReference(XmlSchemas.XmlSchema); schemas.SchemaSet.Add(XmlSchemas.XmlSchema); } _schemas = schemas; _options = options; _context = context; Schemas.SetCache(Context.Cache, Context.ShareTypes); }
internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, CodeDomProvider codeProvider, ImportContext context) { if (!schemas.Contains(XmlSchema.Namespace)) { schemas.AddReference(XmlSchemas.XsdSchema); schemas.SchemaSet.Add(XmlSchemas.XsdSchema); } if (!schemas.Contains(XmlReservedNs.NsXml)) { schemas.AddReference(XmlSchemas.XmlSchema); schemas.SchemaSet.Add(XmlSchemas.XmlSchema); } this.schemas = schemas; this.options = options; this.codeProvider = codeProvider; this.context = context; Schemas.SetCache(Context.Cache, Context.ShareTypes); SchemaImporterExtensionsSection section = PrivilegedConfigurationManager.GetSection(ConfigurationStrings.SchemaImporterExtensionsSectionPath) as SchemaImporterExtensionsSection; if (section != null) extensions = section.SchemaImporterExtensionsInternal; else extensions = new SchemaImporterExtensionCollection(); }
/// <summary> /// /// Resolve the pointers to included schemas. /// /// When we generate the schemas from types, and more than one schema is generated, /// the "master" schema that contains the schema for the type that is the parameter /// for this method will "include" the other schemas that define the /// types it inherits from or the types that it returns in it's properties. /// If we read this schema off the disk, then the XmlSchemaExternal class's Schema property /// would contain a pointer to the included schema. This is not the case for generated /// schemas. /// /// What we do in this method is recurse through the generated schemas, and look for /// included schemas who's pointers are null. Then we find out what namespoace those /// include schemas are in, and look for that in the generated schemas collection. /// /// If we find it, we "fix" the pointer by setting it to the proper generated schema. /// /// This method modified the schemas in the schema collection /// </summary> /// <param name="xmlSchema">The master schema</param> /// <param name="schemas">the collection of generated schemas</param> private void ResolveImportedSchemas(XmlSchema xmlSchema, XmlSchemas schemas) { string baseSchemaName = GenerateName(); if (string.IsNullOrEmpty(xmlSchema.SourceUri)) { xmlSchema.Id = Path.GetFileNameWithoutExtension(baseSchemaName); xmlSchema.SourceUri = baseSchemaName; } foreach (XmlSchemaObject externalSchemaObj in xmlSchema.Includes) { XmlSchemaExternal externalSchema = externalSchemaObj as XmlSchemaExternal; if (externalSchema == null) continue; // if the external schema is not null, we have nothing to worry about if (externalSchema.Schema != null) continue; // if the external schema is null, find it in the schema set XmlSchemaImport importSchema = externalSchemaObj as XmlSchemaImport; if (importSchema != null) { if (schemas.Contains(importSchema.Namespace)) { XmlSchema referencedSchema = schemas[importSchema.Namespace]; importSchema.Schema = referencedSchema; string name = GenerateName(); importSchema.Schema.Id = Path.GetFileNameWithoutExtension(name); importSchema.Schema.SourceUri = name; importSchema.SchemaLocation = MakeRelative(xmlSchema.SourceUri, name); } } // resolve any included schemas in the external schema ResolveImportedSchemas(externalSchema.Schema, schemas); } }
private static void AddSchema(XmlSchema schema, bool isEncoded, bool isLiteral, XmlSchemas abstractSchemas, XmlSchemas concreteSchemas, Hashtable references) { if (schema != null) { if (isEncoded && !abstractSchemas.Contains(schema)) { if (references.Contains(schema)) { abstractSchemas.AddReference(schema); } else { abstractSchemas.Add(schema); } } if (isLiteral && !concreteSchemas.Contains(schema)) { if (references.Contains(schema)) { concreteSchemas.AddReference(schema); } else { concreteSchemas.Add(schema); } } } }
/// <summary> /// /// Resolve the pointers to included schemas. /// /// When we generate the schemas from types, and more than one schema is generated, /// the "master" schema that contains the schema for the type that is the parameter /// for this method will "include" the other schemas that define the /// types it inherits from or the types that it returns in it's properties. /// If we read this schema off the disk, then the XmlSchemaExternal class's Schema property /// would contain a pointer to the included schema. This is not the case for generated /// schemas. /// /// What we do in this method is recurse through the generated schemas, and look for /// included schemas who's pointers are null. Then we find out what namespoace those /// include schemas are in, and look for that in the generated schemas collection. /// /// If we find it, we "fix" the pointer by setting it to the proper generated schema. /// /// This method modified the schemas in the schema collection /// </summary> /// <param name="xmlSchema">The master schema</param> /// <param name="schemas">the collection of generated schemas</param> private static void ResolveImportedSchemas(XmlSchema xmlSchema, XmlSchemas schemas) { string baseSchemaName = NameGenerator.GenerateName(); if (string.IsNullOrEmpty(xmlSchema.SourceUri)) { xmlSchema.Id = baseSchemaName; xmlSchema.SourceUri = "file:///" + baseSchemaName + ".xsd"; } foreach (XmlSchemaObject externalSchemaObj in xmlSchema.Includes) { XmlSchemaExternal externalSchema = externalSchemaObj as XmlSchemaExternal; if (externalSchema == null) continue; // if the external schema is not null, we have nothing to worry about if (externalSchema.Schema != null) continue; // if the external schema is null, find it in the schema set XmlSchemaImport importSchema = externalSchemaObj as XmlSchemaImport; if (importSchema != null) { if (schemas.Contains(importSchema.Namespace)) { XmlSchema referencedSchema = schemas[importSchema.Namespace]; importSchema.Schema = referencedSchema; string name = NameGenerator.GenerateName(); importSchema.Schema.Id = name; importSchema.Schema.SourceUri = "file:///" + name + ".xsd"; importSchema.SchemaLocation = name + ".xsd"; } } // resolve any included schemas in the external schema ResolveImportedSchemas(externalSchema.Schema, schemas); } }
// 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 or literal types in the encoded schemas, // beacase it can cause schema coimpilation falure. static void CollectEncodedAndLiteralSchemas(WsdlNS.ServiceDescriptionCollection serviceDescriptions, XmlSchemas encodedSchemas, XmlSchemas literalSchemas, XmlSchemaSet allSchemas) { XmlSchema wsdl = StockSchemas.CreateWsdl(); XmlSchema soap = StockSchemas.CreateSoap(); XmlSchema soapEncoding = StockSchemas.CreateSoapEncoding(); Hashtable references = new Hashtable(); if (!allSchemas.Contains(wsdl.TargetNamespace)) { references[soap] = wsdl; } if (!allSchemas.Contains(soap.TargetNamespace)) { references[soap] = soap; } if (!allSchemas.Contains(soapEncoding.TargetNamespace)) { references[soapEncoding] = soapEncoding; } foreach (WsdlNS.ServiceDescription description in serviceDescriptions) { foreach (WsdlNS.Message message in description.Messages) { foreach (WsdlNS.MessagePart part in message.Parts) { bool isEncoded; bool isLiteral; FindUse(part, out isEncoded, out isLiteral); if (part.Element != null && !part.Element.IsEmpty) { XmlSchemaElement element = FindSchemaElement(allSchemas, part.Element); if (element != null) { AddSchema(element.Parent as XmlSchema, isEncoded, isLiteral, encodedSchemas, literalSchemas, references); if (element.SchemaTypeName != null && !element.SchemaTypeName.IsEmpty) { XmlSchemaType type = FindSchemaType(allSchemas, element.SchemaTypeName); if (type != null) { AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, encodedSchemas, literalSchemas, references); } } } } if (part.Type != null && !part.Type.IsEmpty) { XmlSchemaType type = FindSchemaType(allSchemas, part.Type); if (type != null) { AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, encodedSchemas, literalSchemas, references); } } } } } Hashtable imports; foreach (XmlSchemas schemas in new XmlSchemas[] { encodedSchemas, literalSchemas }) { // collect all imports imports = new Hashtable(); foreach (XmlSchema schema in schemas) { AddImport(schema, imports, allSchemas); } // make sure we add them to the corresponding schema collections foreach (XmlSchema schema in imports.Keys) { if (references[schema] == null && !schemas.Contains(schema)) { 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. imports = new Hashtable(); foreach (XmlSchema schema in allSchemas.Schemas()) { if (!encodedSchemas.Contains(schema) && !literalSchemas.Contains(schema)) { AddImport(schema, imports, allSchemas); } } // make sure we add them to the corresponding schema collections foreach (XmlSchema schema in imports.Keys) { if (references[schema] != null) continue; if (!encodedSchemas.Contains(schema)) { encodedSchemas.Add(schema); } if (!literalSchemas.Contains(schema)) { literalSchemas.Add(schema); } } if (encodedSchemas.Count > 0) { foreach (XmlSchema schema in references.Values) { encodedSchemas.AddReference(schema); } } if (literalSchemas.Count > 0) { foreach (XmlSchema schema in references.Values) { literalSchemas.AddReference(schema); } } AddSoapEncodingSchemaIfNeeded(literalSchemas); }
static void AddSchema(XmlSchema schema, bool isEncoded, bool isLiteral, XmlSchemas encodedSchemas, XmlSchemas literalSchemas, Hashtable references) { if (schema != null) { if (isEncoded && !encodedSchemas.Contains(schema)) { if (references.Contains(schema)) { encodedSchemas.AddReference(schema); } else { encodedSchemas.Add(schema); } } if (isLiteral && !literalSchemas.Contains(schema)) { if (references.Contains(schema)) { literalSchemas.AddReference(schema); } else { literalSchemas.Add(schema); } } } }
void AddIncludingSchema (XmlSchemas list, string ns) { XmlSchema sc = Schemas [ns]; if (sc == null || list.Contains (sc)) return; list.Add (sc); foreach (XmlSchemaObject ob in sc.Includes) { XmlSchemaImport import = ob as XmlSchemaImport; if (import != null) AddIncludingSchema (list, import.Namespace); } }
void ClasifySchemas (ArrayList importInfo) { // I don't like this, but I could not find any other way of clasifying // schemas between encoded and literal. xmlSchemas = new XmlSchemas (); soapSchemas = new XmlSchemas (); foreach (ImportInfo info in importInfo) { foreach (Service service in info.ServiceDescription.Services) { foreach (Port port in service.Ports) { this.iinfo = info; this.port = port; binding = ServiceDescriptions.GetBinding (port.Binding); if (binding == null) continue; portType = ServiceDescriptions.GetPortType (binding.Type); if (portType == null) continue; foreach (OperationBinding oper in binding.Operations) { operationBinding = oper; operation = FindPortOperation (); if (operation == null) continue; foreach (OperationMessage omsg in operation.Messages) { Message msg = ServiceDescriptions.GetMessage (omsg.Message); if (msg == null) continue; if (omsg is OperationInput) inputMessage = msg; else outputMessage = msg; } if (GetMessageEncoding (oper.Input) == SoapBindingUse.Encoded) AddMessageSchema (soapSchemas, oper.Input, inputMessage); else AddMessageSchema (xmlSchemas, oper.Input, inputMessage); if (oper.Output != null) { if (GetMessageEncoding (oper.Output) == SoapBindingUse.Encoded) AddMessageSchema (soapSchemas, oper.Output, outputMessage); else AddMessageSchema (xmlSchemas, oper.Output, outputMessage); } } } } } XmlSchemas defaultList = xmlSchemas; if (xmlSchemas.Count == 0 && soapSchemas.Count > 0) defaultList = soapSchemas; // Schemas not referenced by any message foreach (XmlSchema sc in Schemas) { if (!soapSchemas.Contains (sc) && !xmlSchemas.Contains (sc)) { if (ImportsEncodedNamespace (sc)) soapSchemas.Add (sc); else defaultList.Add (sc); } } }
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; }
void AddIncludingSchema (XmlSchemas list, string ns) { foreach (XmlSchema sc in Schemas) { if (sc.TargetNamespace == ns && !list.Contains (sc)) { list.Add (sc); foreach (XmlSchemaObject ob in sc.Includes) { XmlSchemaImport import = ob as XmlSchemaImport; if (import != null) AddIncludingSchema (list, import.Namespace); } } } }