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);
}
}
}
private void AddDocument(string path, object document, XmlSchemas schemas,
ServiceDescriptionCollection descriptions)
{
var serviceDescription = document as ServiceDescription;
if (serviceDescription != null)
{
if (descriptions[serviceDescription.TargetNamespace] == null)
{
descriptions.Add(serviceDescription);
var w = new StringWriter();
var writer = new XmlTextWriter(w);
writer.Formatting = Formatting.Indented;
serviceDescription.Write(writer);
wsdls.Add(w.ToString());
}
else
{
CheckPoint(MessageType.Warning,
string.Format(duplicateService, serviceDescription.TargetNamespace, path));
}
}
else
{
var schema = document as XmlSchema;
if (schema != null)
{
if (schemas[schema.TargetNamespace] == null)
{
schemas.Add(schema);
var writer3 = new StringWriter();
var writer4 = new XmlTextWriter(writer3);
writer4.Formatting = Formatting.Indented;
schema.Write(writer4);
xsds.Add(writer3.ToString());
}
else
{
CheckPoint(MessageType.Warning,
string.Format(duplicateSchema, serviceDescription.TargetNamespace, path));
}
}
}
}
private CodeNamespace GeneratedClassFromStream(Stream stream, string nameSpace)
{
try
{
XmlSchema xsd;
stream.Seek(0, SeekOrigin.Begin);
using (stream)
{
xsd = XmlSchema.Read(stream, null);
}
var xsds = new XmlSchemas();
xsds.Add(xsd);
xsds.Compile(null, true);
var schemaImporter = new XmlSchemaImporter(xsds);
// create the codedom
var codeNamespace = new CodeNamespace(nameSpace);
var codeExporter = new XmlCodeExporter(codeNamespace);
var maps = new List <XmlTypeMapping>();
foreach (XmlSchemaType schemaType in xsd.SchemaTypes.Values)
{
maps.Add(schemaImporter.ImportSchemaType(schemaType.QualifiedName));
}
foreach (XmlSchemaElement schemaElement in xsd.Elements.Values)
{
maps.Add(schemaImporter.ImportTypeMapping(schemaElement.QualifiedName));
}
foreach (XmlTypeMapping map in maps)
{
codeExporter.ExportTypeMapping(map);
}
return(codeNamespace);
}
catch (Exception e)
{
return(null);
}
}
private void AddDocument(string path, object document, XmlSchemas schemas,
ServiceDescriptionCollection descriptions)
{
ServiceDescription description1 = document as ServiceDescription;
if (description1 != null)
{
if (descriptions[description1.TargetNamespace] == null)
{
descriptions.Add(description1);
StringWriter writer1 = new StringWriter();
XmlTextWriter writer2 = new XmlTextWriter(writer1);
writer2.Formatting = Formatting.Indented;
description1.Write(writer2);
wsdls.Add(writer1.ToString());
}
else
{
CheckPoint(MessageType.Warning, string.Format(duplicateService, description1.TargetNamespace, path));
}
}
else
{
XmlSchema schema1 = document as XmlSchema;
if (schema1 != null)
{
if (schemas[schema1.TargetNamespace] == null)
{
schemas.Add(schema1);
StringWriter writer3 = new StringWriter();
XmlTextWriter writer4 = new XmlTextWriter(writer3);
writer4.Formatting = Formatting.Indented;
schema1.Write(writer4);
xsds.Add(writer3.ToString());
}
else
{
CheckPoint(MessageType.Warning,
string.Format(duplicateSchema, description1.TargetNamespace, path));
}
}
}
}
public void XsdToClassTest(IEnumerable <Func <TextReader> > xsds, TextWriter codeWriter)
{
var schemas = new XmlSchemas();
foreach (var getReader in xsds)
{
using (var reader = getReader())
{
var xsd = XmlSchema.Read(reader, null);
schemas.Add(xsd);
}
}
schemas.Compile(null, true);
var schemaImporter = new XmlSchemaImporter(schemas);
var maps = new List <XmlTypeMapping>();
foreach (XmlSchema xsd in schemas)
{
foreach (XmlSchemaType schemaType in xsd.SchemaTypes.Values)
{
maps.Add(schemaImporter.ImportSchemaType(schemaType.QualifiedName));
}
foreach (XmlSchemaElement schemaElement in xsd.Elements.Values)
{
maps.Add(schemaImporter.ImportTypeMapping(schemaElement.QualifiedName));
}
}
// create the codedom
var codeNamespace = new CodeNamespace(this.Namespace);
var codeExporter = new XmlCodeExporter(codeNamespace);
foreach (XmlTypeMapping map in maps)
{
codeExporter.ExportTypeMapping(map);
}
ModifyGeneratedCode(codeNamespace);
// Check for invalid characters in identifiers
CodeGenerator.ValidateIdentifiers(codeNamespace);
// output the C# code
var codeProvider = new CSharpCodeProvider();
codeProvider.GenerateCodeFromNamespace(codeNamespace, codeWriter, new CodeGeneratorOptions());
}
/// <summary>
/// Loads external schemas for each schema in the collection.
/// </summary>
/// <param name="schemas">Collection of XML schemas.</param>
/// <remarks>
/// External schemas are those schemas referenced by import and include schema elements.
/// </remarks>
private void ReadExternalSchemas(XmlSchemas schemas)
{
Dictionary <string, XmlSchema> externalSchemas = new Dictionary <string, XmlSchema>();
foreach (XmlSchema schema in schemas)
{
if (schema.TargetNamespace != null && schema.TargetNamespace.Length == 0)
{
schema.TargetNamespace = null;
}
this.ReadExternalSchemas(schema, externalSchemas, schema);
}
foreach (XmlSchema schema in externalSchemas.Values)
{
schemas.Add(schema);
}
}
public void ExportEndpoint()
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "ExportEndpoint");
try
{
System.Web.Services.Description.ServiceDescription wsdl = _exporter.GeneratedWsdlDocuments[0];
XmlSchemaSet schemaSet = _exporter.GeneratedXmlSchemas;
XmlSchemas imports = new XmlSchemas();
foreach (XmlSchema schema in _exporter.GeneratedXmlSchemas.Schemas())
{
imports.Add(schema);
}
foreach (XmlSchema schema in imports)
{
schema.Includes.Clear();
}
wsdl.Types.Schemas.Clear();
wsdl.Types.Schemas.Add(imports);
//List<XmlSchema> importsList = new List<XmlSchema>();
// foreach (XmlSchema schema in wsdl.Types.Schemas)
// {
// AddImportedSchemas(schema, schemaSet, importsList);
// }
// wsdl.Types.Schemas.Clear();
// foreach (XmlSchema schema in importsList)
// {
// RemoveXsdImports(schema);
// wsdl.Types.Schemas.Add(schema);
// }
//}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
}
private static CodeNamespace ProcessSchema(SchemaDefinition schemaDefinition, bool includeDataContractAttributes)
{
var ns = new CodeNamespace(schemaDefinition.Namespace);
var reader = XmlReader.Create(schemaDefinition.SchemaPath);
var xsd = XmlSchema.Read(reader, Validate);
var schemas = new XmlSchemas();
var schemaSet = new XmlSchemaSet();
schemaSet.Add(xsd);
schemaSet.Compile();
foreach (XmlSchema schema in schemaSet.Schemas())
{
schemas.Add(schema);
}
const CodeGenerationOptions generationOptions = CodeGenerationOptions.GenerateOrder;
var exporter = new XmlCodeExporter(ns);
var importer = new XmlSchemaImporter(schemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));
foreach (var mapping in
xsd.Items.OfType <XmlSchemaType>().Select(item => importer.ImportSchemaType(item.QualifiedName)))
{
exporter.ExportTypeMapping(mapping);
}
var includes = Helper.GetSchemaIncludes(schemaSet);
FilterIncludedTypes(ns, xsd);
AddIncludeImports(ns, includes);
RemoveXmlRootAttributeForNoneRootTypes(ns, schemaSet);
if (includeDataContractAttributes)
{
AddDataContractAttributes(ns, schemaDefinition.XmlNamespace);
}
return(ns);
}
internal static CodeNamespaceResult CreateCodeNamespace(PhysicalSchema schema, string targetNamespace)
{
XmlSchemaSet xset = new XmlSchemaSet();
foreach (var file in schema.Files)
{
var sr = new StringReader(file.Content);
xset.Add(XmlSchema.Read(sr, null));
}
xset.Compile();
XmlSchemas schemas = new XmlSchemas();
foreach (XmlSchema xmlSchema in xset.Schemas())
{
schemas.Add(xmlSchema);
}
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
var ns = new CodeNamespace(targetNamespace);
var exporter = new XmlCodeExporter(ns);
var result = new CodeNamespaceResult();
foreach (XmlSchemaElement element in xset.GlobalElements.Values)
{
XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
if (string.IsNullOrEmpty(result.RootElementName))
{
result.RootElementName = mapping.TypeName;
}
exporter.ExportTypeMapping(mapping);
}
result.Code = ns;
return(result);
}
public static XmlSchema GetDataSetSchema(XmlTypeMapping mapping, string dataSetName, string dataTableName)
{
// create schema
XmlSchema xsd = new XmlSchema();
xsd.Id = dataSetName;
// create dataset-element
XmlSchemaElement xsdDataset = new XmlSchemaElement();
xsdDataset.Name = dataSetName;
// anonymous complextype
XmlSchemaComplexType xsdDatasetType = new XmlSchemaComplexType();
// anonymous sequence
XmlSchemaSequence xsdDatasetSequence = new XmlSchemaSequence();
// add sequence to complextype
xsdDatasetType.Particle = xsdDatasetSequence;
// add complextype to dataset-element
xsdDataset.SchemaType = xsdDatasetType;
// add mapped type
XmlSchemas schemas = new XmlSchemas();
schemas.Add(xsd);
XmlSchemaExporter exporter = new XmlSchemaExporter(schemas);
exporter.ExportTypeMapping(mapping);
// get datatable-element and move it to dataset-sequence
XmlSchemaObject o = xsd.Items[0];
xsd.Items.RemoveAt(0);
xsdDatasetSequence.Items.Add(o);
// add dataset-element to xsd
xsd.Items.Add(xsdDataset);
//schemas.Compile(null, false); // we only need the string
return(schemas[mapping.Namespace]);
}
internal static void ExportEndpoint(WsdlExporter wsdlExporter)
{
if (wsdlExporter.GeneratedWsdlDocuments.Count > 1)
{
throw new ApplicationException("Single file option is not supported in multiple wsdl files");
}
ServiceDescription rootDescription = wsdlExporter.GeneratedWsdlDocuments[0];
XmlSchemas imports = new XmlSchemas();
foreach (XmlSchema schema in wsdlExporter.GeneratedXmlSchemas.Schemas())
{
imports.Add(schema);
}
foreach (XmlSchema schema in imports)
{
schema.Includes.Clear();
}
rootDescription.Types.Schemas.Clear();
rootDescription.Types.Schemas.Add(imports);
}
} //method GenerateSchemaForDocument
private CodeNamespace GenerateCodeForSchema(XmlSchema schema)
{
XmlSchemas schemas = new XmlSchemas();
schemas.Add(schema);
XmlSchemaImporter imp = new XmlSchemaImporter(schemas);
CodeNamespace tempSpace = new CodeNamespace();
XmlCodeExporter exp = new XmlCodeExporter(tempSpace);
// Iterate schema items (top-level elements only) and generate code for each
foreach (XmlSchemaObject item in schema.Items)
{
if (item is XmlSchemaElement)
{
// Import the mapping first
XmlTypeMapping map = imp.ImportTypeMapping(new XmlQualifiedName(((XmlSchemaElement)item).Name, schema.TargetNamespace));
// Export the code finally
exp.ExportTypeMapping(map);
} //if
} //foreach
return(tempSpace);
} //method GenerateCodeForSchema
public static CodeNamespace Process(string xsdSchema, string modelsNamespace)
{
// Load the XmlSchema and its collection.
XmlSchema xsd;
using (var fs = new StringReader(xsdSchema))
{
xsd = XmlSchema.Read(fs, null);
xsd.Compile(null);
}
XmlSchemas schemas = new XmlSchemas();
schemas.Add(xsd);
// Create the importer for these schemas.
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
// System.CodeDom namespace for the XmlCodeExporter to put classes in.
CodeNamespace ns = new CodeNamespace(modelsNamespace);
XmlCodeExporter exporter = new XmlCodeExporter(ns);
// Iterate schema top-level elements and export code for each.
foreach (XmlSchemaElement element in xsd.Elements.Values)
{
// Import the mapping first.
XmlTypeMapping mapping = importer.ImportTypeMapping(
element.QualifiedName);
// Export the code finally.
exporter.ExportTypeMapping(mapping);
}
// execute extensions
//var collectionsExt = new ArraysToCollectionsExtension();
//collectionsExt.Process(ns, xsd);
//var filedsExt = new FieldsToPropertiesExtension();
//filedsExt.Process(ns, xsd);
return(ns);
}
static void Main(string[] args)
{
var xmlSchemas = new XmlSchemas();
xmlSchemas.Add(XmlSchema.Read(File.OpenRead("name5.xsd"), validationHandler));
xmlSchemas.Compile(validationHandler, true);
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(xmlSchemas);
CodeNamespace codeNamespace = new CodeNamespace("CSharpGenerated");
XmlCodeExporter codeExporter = new XmlCodeExporter(codeNamespace, null, CodeGenerationOptions.None);
foreach (XmlSchema xsd in xmlSchemas)
{
foreach (XmlSchemaType schemaType in xsd.SchemaTypes.Values) // XmlSchemaComplexType or XmlSchemaSimpleType
{
//Console.WriteLine(schemaType.GetType().Name);
codeExporter.ExportTypeMapping(schemaImporter.ImportSchemaType(schemaType.QualifiedName));
}
foreach (XmlSchemaElement schemaElement in xsd.Elements.Values)
{
//Console.WriteLine(schemaElement.GetType().Name);
codeExporter.ExportTypeMapping(schemaImporter.ImportTypeMapping(schemaElement.QualifiedName));
}
}
RemoveAttributes(codeNamespace);
CodeGenerator.ValidateIdentifiers(codeNamespace);
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
CodeGeneratorOptions opts = new CodeGeneratorOptions
{
BlankLinesBetweenMembers = false,
VerbatimOrder = true
};
codeProvider.GenerateCodeFromNamespace(codeNamespace, Console.Out, opts);
Console.ReadLine();
}
private static void GenerateClasses(CodeNamespace code, XmlSchema schema)
{
XmlSchemas schemas = new XmlSchemas();
schemas.Add(schema);
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeGenerationOptions options = CodeGenerationOptions.None;
XmlCodeExporter exporter = new XmlCodeExporter(code, codeCompileUnit, options);
foreach (XmlSchemaObject item in schema.Items)
{
XmlSchemaElement element = item as XmlSchemaElement;
if (element != null)
{
XmlQualifiedName name = new XmlQualifiedName(element.Name, schema.TargetNamespace);
XmlTypeMapping map = importer.ImportTypeMapping(name);
exporter.ExportTypeMapping(map);
}
}
}
private static void AddTypes(CodeNamespace codeNamespace, XmlSchemaSet schemaSet)
{
var schemas = new XmlSchemas();
foreach (var schema in schemaSet.Schemas().Cast <XmlSchema>())
{
schemas.Add(schema);
}
var schemaImporter = new XmlSchemaImporter(schemas);
#if NETFRAMEWORK
schemaImporter.Extensions.Add(new NodaTimeSchemaImporterExtension());
var codeExporter = new XmlCodeExporter(codeNamespace);
foreach (var schemaObject in schemas.SelectMany(e => e.Items.Cast <XmlSchemaObject>()))
{
XmlTypeMapping mapping;
switch (schemaObject)
{
case XmlSchemaType schemaType:
mapping = schemaImporter.ImportSchemaType(schemaType.QualifiedName);
break;
case XmlSchemaElement schemaElement:
mapping = schemaImporter.ImportTypeMapping(schemaElement.QualifiedName);
break;
default:
continue;
}
codeExporter.ExportTypeMapping(mapping);
}
CodeGenerator.ValidateIdentifiers(codeNamespace);
#else
throw new PlatformNotSupportedException($"{nameof(XmlCodeExporterAssemblyCreator)} is not available");
#endif
}
public void Generate()
{
CheckPoint(MessageType.Begin, "Initializing");
var descriptions = new ServiceDescriptionCollection();
var schemas = new XmlSchemas();
var urls = new StringCollection();
var localPaths = new StringCollection();
GetPaths(localPaths, urls);
descriptions.Clear();
schemas.Clear();
if ((localPaths != null) && (localPaths.Count > 0))
{
string path = localPaths[0];
string extension = Path.GetExtension(path);
if ((string.Compare(extension, ".exe", true) == 0) || (string.Compare(extension, ".dll", true) == 0))
{
CheckPoint(MessageType.Begin, "Loading Assembly");
proxyAssembly = Assembly.LoadFrom(path);
if (proxyAssembly != null)
{
CheckPoint(MessageType.Success, "Loaded Assembly");
}
else
{
CheckPoint(MessageType.Failure, "Failed to load Assembly");
}
return;
}
}
CheckPoint(MessageType.Begin, "Generating WSDL");
try
{
System.Net.ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
DiscoveryClientProtocol client = CreateDiscoveryClient();
ProcessLocalPaths(client, localPaths, schemas, descriptions);
ProcessRemoteUrls(client, urls, schemas, descriptions);
}
catch (Exception exception)
{
CheckPoint(MessageType.Failure, exception.ToString());
return;
}
try
{
ICodeGenerator generator;
string str3;
CheckPoint(MessageType.Begin, "Generating Proxy");
CreateCodeGenerator(out generator, out str3);
var userSchemas = new XmlSchemas();
userSchemas.Add(schemas);
foreach (ServiceDescription description in descriptions)
{
userSchemas.Add(description.Types.Schemas);
}
var includeSchemas = new Hashtable();
foreach (XmlSchema schema in userSchemas)
{
CollectIncludes(schema, includeSchemas);
}
Compile(userSchemas);
GenerateCode(descriptions, schemas, "http://tempuri.org", generator, str3);
CheckPoint(MessageType.Begin, "Compiling Proxy");
GenerateAssembly();
CheckPoint(MessageType.Success, "Generated Assembly");
}
catch (Exception exception2)
{
CheckPoint(MessageType.Failure, exception2.ToString());
}
}
public void Generate()
{
this.CheckPoint(MessageType.Begin, "Initializing");
ServiceDescriptionCollection descriptions = new ServiceDescriptionCollection();
XmlSchemas schemas = new XmlSchemas();
StringCollection urls = new StringCollection();
StringCollection localPaths = new StringCollection();
this.GetPaths(localPaths, urls);
descriptions.Clear();
schemas.Clear();
if ((localPaths != null) && (localPaths.Count > 0))
{
string path = localPaths[0];
string extension = Path.GetExtension(path);
if ((string.Compare(extension, ".exe", true) == 0) || (string.Compare(extension, ".dll", true) == 0))
{
this.CheckPoint(MessageType.Begin, "Loading Assembly");
this.proxyAssembly = Assembly.LoadFrom(path);
if (this.proxyAssembly != null)
{
this.CheckPoint(MessageType.Success, "Loaded Assembly");
}
else
{
this.CheckPoint(MessageType.Failure, "Failed to load Assembly");
}
return;
}
}
this.CheckPoint(MessageType.Begin, "Generating WSDL");
try
{
DiscoveryClientProtocol client = this.CreateDiscoveryClient();
this.ProcessLocalPaths(client, localPaths, schemas, descriptions);
this.ProcessRemoteUrls(client, urls, schemas, descriptions);
}
catch (Exception exception)
{
this.CheckPoint(MessageType.Failure, exception.ToString());
return;
}
try
{
this.CheckPoint(MessageType.Begin, "Generating Proxy");
this.CreateCodeGenerator();
XmlSchemas userSchemas = new XmlSchemas();
userSchemas.Add(schemas);
foreach (ServiceDescription description in descriptions)
{
userSchemas.Add(description.Types.Schemas);
}
Hashtable includeSchemas = new Hashtable();
foreach (XmlSchema schema in userSchemas)
{
CollectIncludes(schema, includeSchemas);
}
this.Compile(userSchemas);
this.GenerateCode(descriptions, schemas, "http://tempuri.org");
this.CheckPoint(MessageType.Begin, "Compiling Proxy");
this.GenerateAssembly();
this.CheckPoint(MessageType.Success, "Generated Assembly");
}
catch (Exception exception2)
{
this.CheckPoint(MessageType.Failure, exception2.ToString());
}
}
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);
}
public IEnumerable <CodeTypeDeclaration> CreateCodeTypeDeclarations(XmlSchemaSet schemaSet, string[] targetNamespaces)
{
XmlSchemas allSchemas = new XmlSchemas();
foreach (XmlSchema schema in schemaSet.Schemas().Cast <XmlSchema>())
{
allSchemas.Add(schema);
}
allSchemas.Compile(UblSettings.XsdValidationEvent, true);
if (!allSchemas.IsCompiled)
{
Console.WriteLine("Warning: allSchemas is not compiled!!! .NET BUG?");
}
XmlSchemaImporter importer = new XmlSchemaImporter(allSchemas);
importer.Extensions.Clear(); // Remove System.Data.SqlTypes.TypeXxxx stuff
CodeNamespace bigBlobCodeNamespace = new CodeNamespace("UblDummyLibrary"); // temporary to hold everything
CodeGenerationOptions opts = CodeGenerationOptions.GenerateOrder;
if (UblSettings.OptionMemberTypeToGenerate == UblXsdSettings.FieldTypesEnum.Property)
{
opts |= CodeGenerationOptions.GenerateProperties;
}
XmlCodeExporter exporter = new XmlCodeExporter(bigBlobCodeNamespace, null, opts);
foreach (var ns in targetNamespaces)
{
XmlSchema schema = allSchemas[ns];
foreach (XmlSchemaElement element in schema.Elements.Values)
{
XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
exporter.ExportTypeMapping(mapping);
}
}
IEnumerable <CodeTypeDeclaration> allCodeDecls = bigBlobCodeNamespace.Types.Cast <CodeTypeDeclaration>().ToList();
foreach (var codeDecl in allCodeDecls)
{
// clear auto generated comment "<remarks/>"
codeDecl.Comments.Clear();
foreach (var item in codeDecl.Members.OfType <CodeTypeMember>())
{
item.Comments.Clear();
}
// populate userdata with things we often query from xsd files
XmlQualifiedName qname = codeDecl.GetQualifiedName();
XmlSchema schema = allSchemas[qname.Namespace];
codeDecl.UserData[Constants.XmlSchemaLabel] = schema;
XmlSchemaType xmlSchemaType = (XmlSchemaType)schema.SchemaTypes[qname];
codeDecl.UserData[Constants.XmlSchemaTypeLabel] = xmlSchemaType;
if (xmlSchemaType == null)
{
Console.WriteLine($"Warning: {codeDecl.Name} is missing schema information {qname}");
}
}
return(allCodeDecls);
}
public string Convert(CodeDomProvider codeProvider)
{
StringBuilder code = new StringBuilder();
List <XmlQualifiedName> arrayTypeList = BuildDataContractArrayTypeList();
try
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeNamespace namespace2 = new CodeNamespace();
compileUnit.Namespaces.Add(namespace2);
XmlCodeExporter codeExporter = new XmlCodeExporter(namespace2, compileUnit, codeProvider, CodeGenerationOptions.GenerateProperties, null);
// XmlSchemaImporter needs XmlSchemas and not XmlSchemaSet
XmlSchemas userSchemas = new XmlSchemas();
foreach (XmlSchema schema in schemas.Schemas())
{
userSchemas.Add(schema);
}
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(userSchemas, CodeGenerationOptions.GenerateProperties, codeProvider, new ImportContext(new CodeIdentifiers(), false));
foreach (XmlSchema schema in userSchemas)
{
if (schema != null)
{
foreach (XmlSchemaElement element in schema.Elements.Values)
{
// Don't generate code for abstract elements or array types
if (!element.IsAbstract && !arrayTypeList.Contains(element.QualifiedName))
{
XmlTypeMapping mapping = schemaImporter.ImportTypeMapping(element.QualifiedName);
codeExporter.ExportTypeMapping(mapping);
}
}
}
}
CodeTypeDeclarationCollection types = namespace2.Types;
if ((types == null) || (types.Count == 0))
{
//RtlAwareMessageBox.Show(
// PublicDI.log.error("The XML instance or XML Schema is valid, but no classes could be generated to match. Please ensure it contains a root element with some nested elements inside of it.");
//, "Error",
// MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
}
else
{
CodeGenerator.ValidateIdentifiers(namespace2);
// Now we have to run Silverlight-specific fix-up
//DC
// ServiceContractGenerator generator = new ServiceContractGenerator(compileUnit);
// WcfSilverlightCodeGenerationExtension fixupExtension = new WcfSilverlightCodeGenerationExtension();
// fixupExtension.ClientGenerated(generator);
using (StringWriter writer = new StringWriter(code, CultureInfo.CurrentCulture))
{
foreach (CodeTypeDeclaration type in namespace2.Types)
{
codeProvider.GenerateCodeFromType(type, writer, null);
}
}
}
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
//RtlAwareMessageBox.Show( //DC
// PublicDI.log.error("The XML instance or XML Schema is valid, but no classes could be generated to match." + Environment.NewLine + Environment.NewLine + exception.Message);
//, "Error",
// MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
}
return(code.ToString());
}
/// <summary>
/// Add documents to either service description collection or
/// schema collection
/// </summary>
/// <param name="path"></param>
/// <param name="document"></param>
private void AddDocument(string path, object document)
{
ServiceDescription serviceDescription = document as ServiceDescription;
if (serviceDescription != null)
{
// if the service description has not already been imported,
// add it to the "descriptions" collection
if (!m_descriptions.Contains(serviceDescription))
{
m_descriptions.Add(serviceDescription);
#region write out the WSDL string to the m_wsdl
StringWriter stringWriter = new StringWriter();
using (XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter))
{
xmlWriter.Formatting = Formatting.Indented;
serviceDescription.Write(xmlWriter);
}
m_wsdl = stringWriter.ToString();
#endregion
}
else
{
Trace.TraceWarning(
string.Format("Warning: Ignoring duplicate service description with TargetNamespace='{0}' from '{1}'.",
serviceDescription.TargetNamespace,
path));
}
}
else
{
XmlSchema schema = document as XmlSchema;
if (schema != null)
{
// if this schema is no already in the "schemas" collection,
// then add it
if (!m_schemas.Contains(schema.TargetNamespace))
{
m_schemas.Add(schema);
#region write the schema text out to the m_xsds StringCollection
//StringWriter stringWriter = new StringWriter();
//using (XmlTextWriter xmlWriter = new XmlTextWriter(stringWriter))
//{
// xmlWriter.Formatting = Formatting.Indented;
// schema.Write(xmlWriter);
//}
//this.m_xsds.Add(stringWriter.ToString());
#endregion
}
else
{
Trace.TraceWarning(string.Format("Warning: Ignoring duplicate schema description with TargetNamespace='{0}' from '{1}'.",
schema.TargetNamespace,
path));
}
}
}
}
// SERIALIZE
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
// Can't do anything if the result hasn't been set as a ViewResult
if (!(filterContext.Result is ViewResult))
{
return;
}
// Don't change anything if an error code has been set
try
{
if (filterContext.HttpContext.Response.StatusCode >= 300)
{
return;
}
}
catch { }
// SETUP
UTF8Encoding utf8 = new UTF8Encoding(false);
HttpRequestBase request = filterContext.RequestContext.HttpContext.Request;
String contentType = request.ContentType ?? string.Empty;
ViewResult view = (ViewResult)(filterContext.Result);
var data = view.ViewData.Model;
// Did caller request the XSD?
if (request.QueryString.ToString().IndexOf("XSD", StringComparison.InvariantCultureIgnoreCase) != -1)
{
// Generate an XSD document from the class
string finalXSD = string.Empty;
var soapReflectionImporter = new SoapReflectionImporter();
var xmlTypeMapping = soapReflectionImporter.ImportTypeMapping(data.GetType());
var xmlSchemas = new XmlSchemas();
var xmlSchema = new XmlSchema();
xmlSchemas.Add(xmlSchema);
var xmlSchemaExporter = new XmlSchemaExporter(xmlSchemas);
xmlSchemaExporter.ExportTypeMapping(xmlTypeMapping);
MemoryStream ms = new MemoryStream();
xmlSchema.Write(ms);
ms.Position = 0;
ms.Capacity = Convert.ToInt32(ms.Length);
XmlDocument xmldoc = new XmlDocument();
xmldoc.Load(ms);
finalXSD = xmldoc.InnerXml;
ms.Close();
ms.Dispose();
filterContext.Result = new ContentResult
{
ContentType = "text/xml",
Content = finalXSD,
ContentEncoding = System.Text.Encoding.UTF8
};
}
// Did caller request XML result?
else if (request.QueryString.ToString().IndexOf("XML", StringComparison.InvariantCultureIgnoreCase) != -1)
{
string objectAsXml = SerializeObjectAsXML(data, null);
filterContext.Result = new ContentResult
{
ContentType = "text/xml",
Content = objectAsXml,
ContentEncoding = System.Text.Encoding.UTF8
};
}
// Did caller request JSON result?
else if (request.QueryString.ToString().IndexOf("JSON", StringComparison.InvariantCultureIgnoreCase) != -1)
{
using (var stream = new MemoryStream())
{
JavaScriptSerializer js = new JavaScriptSerializer();
String content = js.Serialize(data);
filterContext.Result = new ContentResult
{
ContentType = "application/json",
Content = content,
ContentEncoding = System.Text.Encoding.UTF8
};
}
}
// Did caller request HTML result?
else if (request.QueryString.ToString().IndexOf("HTML", StringComparison.InvariantCultureIgnoreCase) != -1)
{
filterContext.Result = filterContext.Result; // Nothing to modify here
}
// Not specified, so we will default response to XML
else
{
string objectAsXml = SerializeObjectAsXML(data, null);
filterContext.Result = new ContentResult
{
ContentType = "text/xml",
Content = objectAsXml,
ContentEncoding = System.Text.Encoding.UTF8
};
}
}
public void Start(string sDirIn, string sDirCppXmlOut, string sDirCppBinOut, string sDirJsBinOut, ValidationEventHandler oValidationEventHandler)
{
string sChartNamespace = "http://purl.oclc.org/ooxml/drawingml/chart";
string[] aFiles = Directory.GetFiles(sDirIn);
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.ValidationEventHandler += oValidationEventHandler;
for (int i = 0; i < aFiles.Length; i++)
{
string sFile = aFiles[i];
if (".xsd" == Path.GetExtension(sFile))
{
schemaSet.Add(null, sFile);
}
}
schemaSet.Compile();
XmlSchema chartSchema = null;
XmlSchemas schemas = new XmlSchemas();
foreach (XmlSchema schema in schemaSet.Schemas())
{
if (schema.TargetNamespace == sChartNamespace)
{
chartSchema = schema;
schemas.Add(schema);
}
}
if (null != chartSchema)
{
CodeNamespace ns = new CodeNamespace();
XmlCodeExporter exporter = new XmlCodeExporter(ns);
CodeGenerationOptions generationOptions = CodeGenerationOptions.None;
XmlSchemaImporter importer = new XmlSchemaImporter(schemas, generationOptions, new ImportContext(new CodeIdentifiers(), false));
foreach (XmlSchemaElement element in chartSchema.Elements.Values)
{
XmlTypeMapping mapping = importer.ImportTypeMapping(element.QualifiedName);
exporter.ExportTypeMapping(mapping);
}
CodeGenerator.ValidateIdentifiers(ns);
//Microsoft.CSharp.CSharpCodeProvider oProvider;
//// output the C# code
//Microsoft.CSharp.CSharpCodeProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
//using (StringWriter writer = new StringWriter())
//{
// codeProvider.GenerateCodeFromNamespace(ns, writer, new CodeGeneratorOptions());
// string sCode = writer.GetStringBuilder().ToString();
//}
List <GenClass> aGenClasses = PreProcess(ns, chartSchema);
aGenClasses = FilterClasses(aGenClasses);
(new CodegenCPP()).Process(sDirCppXmlOut, sDirCppBinOut, aGenClasses);
(new CodegenJS()).Process(sDirJsBinOut, aGenClasses);
}
}
private CodeCompileUnit CreateCodeNamespace(XmlSchemaSet schemaSet, CodeNamespaceProvider namespaceProvider)
{
var compileUnit = new CodeCompileUnit();
var schemas = new XmlSchemas();
foreach (var s in schemaSet.Schemas())
{
schemas.Add((XmlSchema)s);
}
schemas.Compile(_options.ValidationHandler, true);
foreach (XmlSchema schema in schemas)
{
var codeNamespace = namespaceProvider.CreateCodeNamespace(schema);
compileUnit.Namespaces.Add(codeNamespace);
}
var codeOptions = CodeGenerationOptions.GenerateOrder | CodeGenerationOptions.GenerateNewAsync;
// foreach (var ns in rootNamespaces.Concat(extensionNamespaces))
foreach (XmlSchema schema in schemas)
{
var schemaImporter = new XmlSchemaImporter(schemas);
schemaImporter.Extensions.Clear();
// var schema = schemas[ns];
var codeNamespace = compileUnit.Namespaces.OfType <CodeNamespace>().Single(x => x.UserData[CodeTypeMemberExtensions.XmlSchemaKey] == schema);
Console.WriteLine($"Import root namespace: {schema.TargetNamespace}");
var codeExporter = new XmlCodeExporter(codeNamespace, compileUnit, codeOptions);
foreach (XmlSchemaElement element in schema.Elements.Values.OfType <XmlSchemaElement>())
{
Console.WriteLine($"Import type mapping for {element.QualifiedName.Namespace} : {element.QualifiedName.Name}");
var xmlTypeMapping = schemaImporter.ImportTypeMapping(element.QualifiedName);
codeExporter.ExportTypeMapping(xmlTypeMapping);
}
var baseTypes = schema.Elements.Values.OfType <XmlSchemaElement>().Select(x => x.SchemaTypeName.Name).ToList();
foreach (XmlSchemaComplexType element in schema.SchemaTypes.Values.OfType <XmlSchemaComplexType>().Where(x => !baseTypes.Contains(x.Name)))
{
Console.WriteLine($"Import schema type for {element.QualifiedName.Namespace} : {element.QualifiedName.Name}");
var xmlTypeMapping = schemaImporter.ImportSchemaType(element.QualifiedName);
codeExporter.ExportTypeMapping(xmlTypeMapping);
}
}
var codeDeclarations = compileUnit.Namespaces.OfType <CodeNamespace>().SelectMany(x => x.Types.Cast <CodeTypeDeclaration>()).ToList();
foreach (var codeDecl in codeDeclarations)
{
codeDecl.Comments.Clear();
foreach (var item in codeDecl.Members.OfType <CodeTypeMember>())
{
item.Comments.Clear();
}
var qname = codeDecl.GetQualifiedName();
codeDecl.UserData[CodeTypeMemberExtensions.QualifiedNameKey] = qname;
// Note, this can fail when there are multiple schemas for one namespace, like urn:oasis:names:specification:ubl:schema:xsd:CommonExtensionComponents-2
var schema = schemas.GetSchemas(qname.Namespace).OfType <XmlSchema>().FirstOrDefault();
// var schema = schemas[qname.Namespace];
codeDecl.UserData[CodeTypeMemberExtensions.XmlSchemaKey] = schema;
var xmlSchemaType = (XmlSchemaType)schema.SchemaTypes[qname];
codeDecl.UserData[CodeTypeMemberExtensions.XmlSchemaTypeKey] = xmlSchemaType;
foreach (CodeTypeMember member in codeDecl.Members)
{
member.UserData[CodeTypeMemberExtensions.XmlSchemaKey] = schema;
member.UserData[CodeTypeMemberExtensions.XmlSchemaTypeKey] = xmlSchemaType;
}
}
return(compileUnit);
}
public model.WebSvcMethodContainer GenerateSampleData()
{
Dictionary <string, model.WebSvcMethod> results = new Dictionary <string, model.WebSvcMethod>();
List <string> methodList = GetMethodList();
foreach (string method in methodList)
{
ServiceDescriptionCollection descCol = new ServiceDescriptionCollection();
foreach (ServiceDescription sd in _descriptions)
{
descCol.Add(sd);
}
XmlSchemas schemaCol;
if (_schemas.Count > 0)
{
schemaCol = new XmlSchemas();
foreach (XmlSchema sc in _schemas)
{
schemaCol.Add(sc);
}
}
else
{
schemaCol = descCol[0].Types.Schemas;
}
string req;
string resp;
SampleGeneratorWebSvc sg = new SampleGeneratorWebSvc(descCol, schemaCol);
sg.GenerateMessages(method, null, "Soap", out req, out resp);
int indexOfReqMsg = req.IndexOf(@"<soap:Envelope");
string reqHeaderMsg = req.Substring(0, indexOfReqMsg);
string sampleReqMsg = req.Substring(indexOfReqMsg);
int indexOfRespMsg = resp.IndexOf(@"<soap:Envelope");
string respHeaderMsg = resp.Substring(0, indexOfRespMsg);
string sampleRespMsg = resp.Substring(indexOfRespMsg);
string[] reqHeaderLines = reqHeaderMsg.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
string soapAction = GetHeader(reqHeaderLines, "SOAPAction:");
string reqContentType = GetHeader(reqHeaderLines, "Content-Type:");
string[] respHeaderLines = respHeaderMsg.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
string respContentType = GetHeader(respHeaderLines, "Content-Type:");
model.WebSvcMessageRequest messageRequest = new model.WebSvcMessageRequest();
messageRequest.Body = sampleReqMsg;
messageRequest.Headers[model.WebSvcMessage.HEADER_NAME_CONTENT_TYPE] = reqContentType;
messageRequest.Headers[model.WebSvcMessageRequest.HEADER_NAME_SOAP_ACTION] = soapAction;
model.WebSvcMessageResponse messageResponse = new model.WebSvcMessageResponse();
messageResponse.Body = sampleRespMsg;
messageResponse.Headers[model.WebSvcMessage.HEADER_NAME_CONTENT_TYPE] = respContentType;
model.WebSvcMethod webMethod = new model.WebSvcMethod(method, _serviceURI)
{
Request = messageRequest,
Response = messageResponse
};
results[method] = webMethod;
}
return(new model.WebSvcMethodContainer(results));
}
public void Generate(IList <String> schemas, TextWriter output)
{
if (Options == null)
{
Options = new XsdCodeGeneratorOptions
{
UseLists = true,
PropertyNameCapitalizer = new FirstCharacterCapitalizer(),
OutputNamespace = "Xsd2",
UseNullableTypes = true,
AttributesToRemove =
{
"System.Diagnostics.DebuggerStepThroughAttribute"
}
};
}
if (Options.Imports != null)
{
foreach (var import in Options.Imports)
{
if (File.Exists(import))
{
ImportImportedSchema(import);
}
else if (Directory.Exists(import))
{
foreach (var file in Directory.GetFiles("*.xsd"))
{
ImportImportedSchema(file);
}
}
else
{
throw new InvalidOperationException(String.Format("Import '{0}' is not a file nor a directory.", import));
}
}
}
var inputs = new List <XmlSchema>();
foreach (var path in schemas)
{
using (var r = File.OpenText(path))
{
XmlSchema xsd = XmlSchema.Read(r, null);
xsds.Add(xsd);
inputs.Add(xsd);
}
}
xsds.Compile(null, true);
XmlSchemaImporter schemaImporter = new XmlSchemaImporter(xsds);
// create the codedom
CodeNamespace codeNamespace = new CodeNamespace(Options.OutputNamespace);
XmlCodeExporter codeExporter = new XmlCodeExporter(codeNamespace);
List <XmlTypeMapping> maps = new List <XmlTypeMapping>();
foreach (var xsd in inputs)
{
foreach (XmlSchemaElement schemaElement in xsd.Elements.Values)
{
if (!ElementBelongsToImportedSchema(schemaElement))
{
maps.Add(schemaImporter.ImportTypeMapping(schemaElement.QualifiedName));
}
}
}
foreach (var xsd in inputs)
{
foreach (XmlSchemaComplexType schemaElement in xsd.Items.OfType <XmlSchemaComplexType>())
{
maps.Add(schemaImporter.ImportSchemaType(schemaElement.QualifiedName));
}
}
foreach (var xsd in inputs)
{
foreach (XmlSchemaSimpleType schemaElement in xsd.Items.OfType <XmlSchemaSimpleType>())
{
maps.Add(schemaImporter.ImportSchemaType(schemaElement.QualifiedName));
}
}
foreach (XmlTypeMapping map in maps)
{
codeExporter.ExportTypeMapping(map);
}
foreach (var xsd in inputs)
{
ImproveCodeDom(codeNamespace, xsd);
}
if (OnValidateGeneratedCode != null)
{
foreach (var xsd in inputs)
{
OnValidateGeneratedCode(codeNamespace, xsd);
}
}
// Check for invalid characters in identifiers
CodeGenerator.ValidateIdentifiers(codeNamespace);
if (Options.WriteFileHeader)
{
// output the header
string lineCommentCharacter;
switch (Options.Language)
{
case XsdCodeGeneratorOutputLanguage.VB:
lineCommentCharacter = "'";
break;
default:
lineCommentCharacter = "//";
break;
}
output.WriteLine("{0}------------------------------------------------------------------------------", lineCommentCharacter);
output.WriteLine("{0} <auto-generated>", lineCommentCharacter);
output.WriteLine("{0} This code has been generated by a tool.", lineCommentCharacter);
output.WriteLine("{0} </auto-generated>", lineCommentCharacter);
output.WriteLine("{0}------------------------------------------------------------------------------", lineCommentCharacter);
output.WriteLine();
}
// output the C# code
CodeDomProvider codeProvider;
switch (Options.Language)
{
case XsdCodeGeneratorOutputLanguage.VB:
codeProvider = new VBCodeProvider();
break;
default:
codeProvider = new CSharpCodeProvider();
break;
}
codeProvider.GenerateCodeFromNamespace(codeNamespace, output, new CodeGeneratorOptions());
}
public void Generate(bool updateAssembly)
{
if (useLocalAssembly && !updateAssembly)
{
if (File.Exists(GetDllOutPutPath()))
{
proxyAssembly = Assembly.LoadFrom(GetDllOutPutPath().ToString());
CheckPoint(MessageType.Success, "Local Assembly Path:" + GetDllOutPutPath().ToString());
return;
}
}
CheckPoint(MessageType.Begin, "Initializing");
ServiceDescriptionCollection collection1 = new ServiceDescriptionCollection();
XmlSchemas schemas1 = new XmlSchemas();
StringCollection collection2 = new StringCollection();
StringCollection collection3 = new StringCollection();
GetPaths(collection3, collection2);
collection1.Clear();
schemas1.Clear();
if ((collection3 != null) && (collection3.Count > 0))
{
string text1 = collection3[0];
string text2 = Path.GetExtension(text1);
if ((string.Compare(text2, ".exe", true) == 0) || (string.Compare(text2, ".dll", true) == 0))
{
CheckPoint(MessageType.Begin, "Loading Assembly");
proxyAssembly = Assembly.LoadFrom(text1);
if (proxyAssembly != null)
{
CheckPoint(MessageType.Success, "Loaded Assembly");
}
else
{
CheckPoint(MessageType.Failure, "Failed to load Assembly");
}
return;
}
}
CheckPoint(MessageType.Begin, "Generating WSDL");
try
{
DiscoveryClientProtocol protocol1 = CreateDiscoveryClient();
ProcessLocalPaths(protocol1, collection3, schemas1, collection1);
ProcessRemoteUrls(protocol1, collection2, schemas1, collection1);
}
catch (Exception exception1)
{
CheckPoint(MessageType.Failure, exception1.ToString());
return;
}
try
{
ICodeGenerator generator1;
string text3;
CheckPoint(MessageType.Begin, "Generating Proxy");
CreateCodeGenerator(out generator1, out text3);
XmlSchemas schemas2 = new XmlSchemas();
schemas2.Add(schemas1);
foreach (ServiceDescription description1 in collection1)
{
schemas2.Add(description1.Types.Schemas);
}
Hashtable hashtable1 = new Hashtable();
foreach (XmlSchema schema1 in schemas2)
{
CollectIncludes(schema1, hashtable1);
}
Compile(schemas2);
GenerateCode(collection1, schemas1, "http://tempuri.org", generator1, text3);
CheckPoint(MessageType.Begin, "Compiling Proxy");
//if (proxyCode.Length < 1000)
//{
// CheckPoint(MessageType.Failure, "Empty Assembly");
// return;
//}
if (updateAssembly)
{
GenerateAssembly(true);
}
else
{
GenerateAssembly();
}
CheckPoint(MessageType.Success, "Generated Assembly");
}
catch (Exception exception2)
{
CheckPoint(MessageType.Failure, exception2.ToString());
return;
}
}
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);
}
}
}
}
public void GenerateClasses()
{
if (namesp == null)
{
namesp = "Schemas";
}
if (uri == null)
{
uri = "";
}
string targetFile = "";
XmlSchemas schemas = new XmlSchemas();
foreach (string fileName in schemaNames)
{
StreamReader sr = new StreamReader(fileName);
schemas.Add(XmlSchema.Read(sr, new ValidationEventHandler(HandleValidationError)));
sr.Close();
if (targetFile == "")
{
targetFile = Path.GetFileNameWithoutExtension(fileName);
}
else
{
targetFile += "_" + Path.GetFileNameWithoutExtension(fileName);
}
}
targetFile += "." + provider.FileExtension;
CodeCompileUnit cunit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace(namesp);
cunit.Namespaces.Add(codeNamespace);
codeNamespace.Comments.Add(new CodeCommentStatement("\nThis source code was auto-generated by MonoXSD\n"));
// Locate elements to generate
ArrayList qnames = new ArrayList();
if (elements.Count > 0)
{
foreach (string name in elements)
{
qnames.Add(new XmlQualifiedName(name, uri));
}
}
else
{
foreach (XmlSchema schema in schemas)
{
if (!schema.IsCompiled)
{
schema.Compile(new ValidationEventHandler(HandleValidationError));
}
foreach (XmlSchemaElement el in schema.Elements.Values)
{
if (!qnames.Contains(el.QualifiedName))
{
qnames.Add(el.QualifiedName);
}
}
}
}
// Import schemas and generate the class model
XmlSchemaImporter importer = new XmlSchemaImporter(schemas);
XmlCodeExporter sx = new XmlCodeExporter(codeNamespace, cunit);
ArrayList maps = new ArrayList();
foreach (XmlQualifiedName qname in qnames)
{
XmlTypeMapping tm = importer.ImportTypeMapping(qname);
if (tm != null)
{
maps.Add(tm);
}
}
foreach (XmlTypeMapping tm in maps)
{
sx.ExportTypeMapping(tm);
}
// Generate the code
ICodeGenerator gen = provider.CreateGenerator();
string genFile = Path.Combine(outputDir, targetFile);
StreamWriter sw = new StreamWriter(genFile, false);
gen.GenerateCodeFromCompileUnit(cunit, sw, new CodeGeneratorOptions());
sw.Close();
Console.WriteLine("Written file " + genFile);
}
