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);
}
}
}
}
