/// <summary>
/// Метод получение XSD-схемы из указанной XML.
/// </summary>
/// <param name="XMLpathIn">Путь до XML</param>
/// <param name="XSDpathOut">Путь куда сохранять полученные XSD-схемы. Должен содержать расширение .xsd</param>
public static void GetXSDFromXML(string XMLpathIn, string XSDpathOut)
{
if (!string.IsNullOrEmpty(XMLpathIn))
{
using (var reader = XmlReader.Create(XMLpathIn))
{
var schema = new XmlSchemaInference();
var schemaSet = schema.InferSchema(reader);
if (!string.IsNullOrEmpty(XSDpathOut))
{
int i = 0;
int insertIndex = XSDpathOut.IndexOf(".xsd", StringComparison.CurrentCulture);
foreach (XmlSchema s in schemaSet.Schemas())
{
var path = XSDpathOut.Insert(insertIndex, $"_{i++}");
using (var writer = XmlWriter.Create(path))
{
s.Write(writer);
}
}
}
}
}
}
/// <summary>
/// Pulls the XML out of a Configuration section, and then generates its XSD
/// </summary>
/// <param name="section"></param>
/// <returns></returns>
public XmlDetails GetXmlDetails(ConfigurationSection section)
{
try
{
var xml = section.SectionInformation.GetRawXml();
if (string.IsNullOrWhiteSpace(xml))
{
return(null);
}
//Get schema
XmlReader reader = XmlReader.Create(new StringReader(xml));
XmlSchemaSet schemaSet = new XmlSchemaInference().InferSchema(reader);
var schema = schemaSet.Schemas().Cast <XmlSchema>().First();
StringBuilder xmlSchemaBuilder = new StringBuilder();
StringWriter writer = new StringWriter(xmlSchemaBuilder);
schema.Write(writer);
return(new XmlDetails()
{
RawData = xml,
Schema = xmlSchemaBuilder.ToString()
});
}
catch (Exception exc)
{
throw new MigrationException("There was an error while migrating the XML details", exc);
}
}
public string GenerateXsd()
{
XmlReader reader = XmlReader.Create(new StringReader(xmlString));
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schemaSet = schema.InferSchema(reader);
foreach (XmlSchema s in schemaSet.Schemas())
{
using (var stringWriter = new StringWriter())
{
XmlWriterSettings settings = new XmlWriterSettings {
Indent = true
};
using (var writer = XmlWriter.Create(stringWriter, settings))
{
s.Write(writer);
xsdString = stringWriter.ToString();
}
}
}
return(xsdString);
}
static void RefinementProcess()
{
//<snippet4>
XmlReader reader = XmlReader.Create("item1.xml");
XmlReader reader1 = XmlReader.Create("item2.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference inference = new XmlSchemaInference();
schemaSet = inference.InferSchema(reader);
// Display the inferred schema.
Console.WriteLine("Original schema:\n");
foreach (XmlSchema schema in schemaSet.Schemas("http://www.contoso.com/items"))
{
schema.Write(Console.Out);
}
// Use the additional data in item2.xml to refine the original schema.
schemaSet = inference.InferSchema(reader1);
// Display the refined schema.
Console.WriteLine("\n\nRefined schema:\n");
foreach (XmlSchema schema in schemaSet.Schemas("http://www.contoso.com/items"))
{
schema.Write(Console.Out);
}
//</snippet4>
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ChooseXMLFile());
XmlReader reader = XmlReader.Create("dfstaf.xml");
//XmlReader reader1 = XmlReader.Create("item2.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference inference = new XmlSchemaInference();
schemaSet = inference.InferSchema(reader);
XmlWriter writer;
// Display the inferred schema.
Console.WriteLine("\n\nOriginal schema:\n");
foreach (XmlSchema schema in schemaSet.Schemas())
{
writer = XmlWriter.Create("dfstaf.xsd");
schema.Write(Console.Out);
schema.Write(writer);
writer.Close();
}
}
public static string BuildXmlSchema(string xmlFileName)
{
string xmlSchema = "";
using (XmlReader reader = XmlReader.Create(xmlFileName))
{
var schemaSet = new XmlSchemaSet();
var schemaInference = new XmlSchemaInference();
schemaSet = schemaInference.InferSchema(reader);
foreach (XmlSchema schema in schemaSet.Schemas())
{
using (var stringWriter = new StringWriter())
{
using (var writer = XmlWriter.Create(stringWriter))
{
schema.Write(writer);
}
xmlSchema = stringWriter.ToString();
}
}
return(xmlSchema);
}
}
/// <summary>
/// Infers the schema.
/// </summary>
private void InferSchema()
{
string schemaText = string.Empty;
string schemaError = string.Empty;
XmlSchemaInference infer = new XmlSchemaInference();
XmlTextReader xmlReader = new XmlTextReader(m_fileName);
XmlSchemaSet schemas = null;
try
{
schemas = infer.InferSchema(xmlReader);
}
catch (Exception exception)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine(exception.Message);
builder.AppendLine(exception.StackTrace);
schemaError = builder.ToString();
}
finally
{
xmlReader.Close();
}
if (schemas != null)
{
schemaText = GetSchemaString(schemas);
}
if (m_infererOutputDelegate != null)
{
m_infererOutputDelegate(schemaText, schemaError);
}
}
public void GenerateXsd()
{
try
{
XmlReader reader = XmlReader.Create(xmlPath);
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schemaSet = schema.InferSchema(reader);
FileInfo xmlPathFile = new FileInfo(xmlPath);
xmlPath = Path.Combine(xmlPathFile.DirectoryName, "XSD_") + xmlPathFile.Name;
using (XmlWriter writer = XmlWriter.Create(Path.ChangeExtension(xmlPath, "xsd")))
{
foreach (XmlSchema s in schemaSet.Schemas())
{
s.Write(writer);
writer.Close();
}
}
reader.Close();
}
catch (Exception ex)
{
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "errors.txt");
using StreamWriter sw = new StreamWriter(path, true);
sw.Write(ex.Message);
}
}
public static void GenerateSchemasForFile(string file)
{
// set up a reader for the file
using (XmlReader reader = XmlReader.Create(file))
{
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schemaInference =
new XmlSchemaInference();
// get the schema
schemaSet = schemaInference.InferSchema(reader);
string schemaPath = string.Empty;
foreach (XmlSchema schema in schemaSet.Schemas())
{
// make schema file path and write it out
schemaPath = $"{Path.GetDirectoryName(file)}\\" +
$"{Path.GetFileNameWithoutExtension(file)}.xsd";
using (FileStream fs =
new FileStream(schemaPath, FileMode.OpenOrCreate))
{
schema.Write(fs);
fs.Flush();
}
}
}
}
// Note that this method doesn't use the LINQ To XML API since
// no inference capabilities were added to it
static void InferSchemaFromXml()
{
Print.Header();
// Save the XML to disk
xml.Save("Persons.xml");
// Infer the scema set from the XML file
XmlSchemaSet schemaSet = new XmlSchemaInference().InferSchema(new XmlTextReader("Persons.xml"));
// Iterate through all schemas in the set (only one in this case)
// and write the result to the XSD file
using (XmlWriter writer = XmlWriter.Create("Persons.xsd"))
{
foreach (XmlSchema schema in schemaSet.Schemas())
{
schema.Write(writer);
}
}
// Load the schema from disk
XDocument scemaDocument = XDocument.Load("Persons.xsd");
Console.WriteLine(scemaDocument);
}
/// <summary>
/// Creates a schema based on the xml content.
/// </summary>
/// <returns>A set of generated schemas or null if the xml content is not
/// well formed.</returns>
public string[] InferSchema()
{
ITextEditor editor = TextEditor;
if (editor == null)
{
return(null);
}
TaskService.ClearExceptCommentTasks();
if (IsWellFormed)
{
try {
using (XmlTextReader reader = new XmlTextReader(new StringReader(editor.Document.Text))) {
XmlSchemaInference schemaInference = new XmlSchemaInference();
XmlSchemaSet schemaSet = schemaInference.InferSchema(reader);
return(GetSchemas(schemaSet, editor));
}
} catch (XmlSchemaInferenceException ex) {
AddTask(editor.FileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskType.Error);
}
}
ShowErrorList();
return(null);
}
protected XmlSchemaSet CreateSchemaSetFromXml(string XmlContent)
{
XmlSchemaInference infer = new XmlSchemaInference();
StringReader s = new StringReader(XmlContent);
return(infer.InferSchema(XmlReader.Create(s)));
}
private void InferSchemaFromXML(object sender, EventArgs e)
{
OpenFileDialog openFile = new OpenFileDialog();
openFile.InitialDirectory = Application.ExecutablePath;
openFile.Filter = "Xml files (*.xml)|*.xml|All files (*.*)|*.*";
openFile.FilterIndex = 1;
openFile.RestoreDirectory = true;
if (openFile.ShowDialog() == DialogResult.OK)
{
string fullName = openFile.FileName;
try
{
XmlReader reader = XmlReader.Create(fullName);
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference inference = new XmlSchemaInference();
schemaSet = inference.InferSchema(reader);
// Display the inferred schema.
using (FileStream stream = new FileStream("Schema.xsd", FileMode.OpenOrCreate))
{
foreach (XmlSchema schema in schemaSet.Schemas())
{
schema.Write(stream);
}
}
OpenFile("Schema.xsd", null);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
}
public void CreateXmlFile(XmlModel obj, string targetPath)
{
XmlSerializer serializer = new XmlSerializer(typeof(XmlModel));
using (var fs = new FileStream(targetPath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
{
serializer.Serialize(fs, obj);
}
XmlReader reader = XmlReader.Create(targetPath);
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schemaSet = schema.InferSchema(reader);
targetPath = Path.ChangeExtension(targetPath, ".xsd");
foreach (XmlSchema s in schemaSet.Schemas())
{
using (var sw = new StringWriter())
{
using (var writer = XmlWriter.Create(sw))
{
s.Write(writer);
}
File.WriteAllText(targetPath, sw.ToString());
}
}
}
public String Generate(String xml)
{
String genertatedXsd = "";
XmlReader reader = XmlReader.Create(new StringReader(xml));
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schemaSet = schema.InferSchema(reader);
XmlWriterSettings writerSettings = new XmlWriterSettings();
foreach (XmlSchema s in schemaSet.Schemas())
{
StringBuilder sb = new StringBuilder();
using (var stringWriter = new StringWriterWithEncoding(sb, Encoding.UTF8))
{
using (var writer = XmlWriter.Create(stringWriter))
{
s.Write(writer);
}
genertatedXsd = stringWriter.ToString();
}
}
return(genertatedXsd);
}
XmlSchemaSet genSchema(string xmlName)
{
XmlReader reader = XmlReader.Create (@xmlName);
XmlSchemaSet schemaSet = new XmlSchemaSet ();
XmlSchemaInference schema = new XmlSchemaInference ();
schemaSet = schema.InferSchema (reader);
return schemaSet;
}
protected override void Execute(EditorFrame ef)
{
try
{
XmlReader reader = XmlReader.Create(ef.XmlEditor.Text.ToStream());
SaveFileDialog dlgOpenFile = new SaveFileDialog();
dlgOpenFile.Filter = "Xsd Files (*.xsd)|*.xsd";
dlgOpenFile.Title = "Select an Xsd File to generate";
dlgOpenFile.FileName = Path.ChangeExtension(Path.GetFileName(ef.XSDocument.Filename), "xsd");
dlgOpenFile.InitialDirectory = Path.GetDirectoryName(ef.XSDocument.Filename);
if (dlgOpenFile.ShowDialog() == true)
{
XmlSchemaInference schema = new XmlSchemaInference();
XmlSchemaSet schemaSet = schema.InferSchema(reader);
int i = 0;
foreach (XmlSchema s in schemaSet.Schemas())
{
string filename = dlgOpenFile.FileName;
if (i > 0)
{
string extension = Path.GetExtension(filename);
if (string.IsNullOrWhiteSpace(extension))
{
extension = ".xsd";
}
string name = Path.GetFileNameWithoutExtension(filename);
filename = Path.Combine(Path.GetDirectoryName(filename) ?? "", name + "." + i + extension);
}
if (File.Exists(filename))
{
var res = MessageBox.Show(Application.Current.MainWindow, "File " + filename + " already exists. Overwrite?", "Question", MessageBoxButton.OKCancel,
MessageBoxImage.Question);
if (res == MessageBoxResult.Cancel)
{
throw new Exception("Action was cancelled");
}
}
using (FileStream output = new FileStream(filename, FileMode.Create))
{
s.Write(output);
}
i++;
}
MessageBox.Show(Application.Current.MainWindow, i.ToString() + " files were created.", "Information", MessageBoxButton.OK,
MessageBoxImage.Information);
}
}
catch (Exception ex)
{
MessageBox.Show(Application.Current.MainWindow, "Error: " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
//Dictionary<string, string> GetTableInfo(string databaseName, string filterName)
//{
// Dictionary<string, string> tableInfo = new Dictionary<string, string>();
// string sqlString = "select * from sqlite_master WHERE type = \"table\"";
// using (SQLiteCommand cmd = mSqliteConn.CreateCommand())
// {
// cmd.CommandText = sqlString;
// SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
// DataTable dt = new DataTable();
// da.Fill(dt);
// DataColumn nameCol = dt.Columns["name"];
// foreach (DataRow row in dt.Rows)
// {
// string key = row[nameCol].ToString();
// if (filterName != "")
// {
// Regex regex = new Regex(@"^[" + filterName + "]");
// if (!regex.IsMatch(key))
// {
// continue;
// }
// }
// tableInfo.Add(key, null);
// //System.Diagnostics.Trace.WriteLine("Unhandled sqlite type [" + + "]");
// }
// }
// return tableInfo;
//}
//string GetString(SQLiteDataReader reader, string ordinal)
//{
// return reader.GetString(reader.GetOrdinal(ordinal));
//}
///// <summary>
///// Convsert specified xml file to cs file object
///// </summary>
CSFile ConvertTable(string xmlFile, string[] impledInterface)
{
CSFile writer = new CSFile();
writer.name = Path.GetFileName(xmlFile);
//read xml file
writer.AddReferencedLib("System");
CSClass classObj = writer.AddCSClass("public", writer.name, impledInterface);
using (XmlReader reader = XmlReader.Create(""))
{
XmlSchemaInference schema = new XmlSchemaInference();
XmlSchemaSet schemaSet = schema.InferSchema(reader);
//schemaSet.
}
// string sqlString = string.Format("PRAGMA table_info([{0}]);", tableName);
// using (SQLiteCommand cmd = mSqliteConn.CreateCommand())
// {
// cmd.CommandText = sqlString;
// //using
// writer.AddReferencedLib("System");
// CSClass classObj = writer.AddCSClass("public", tableName, impledInterface);
// SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
// DataTable dt = new DataTable();
// da.Fill(dt);
// DataColumn nameCol = dt.Columns["name"];
// DataColumn typeCol = dt.Columns["type"];
// CSParseFunc parseFunc = new CSParseFunc("public", tableName, "ReadData");
// CSVar dataForm = parseFunc.AddParam(string.Empty, "ASteinGameDataHolder", "dataForm");
// classObj.AddFuncDeclare(parseFunc);
// foreach (DataRow row in dt.Rows)
// {
// CSField dataVar = classObj.AddVar("public", SqliteType2CsType(row[typeCol].ToString()), row[nameCol].ToString());
// CSFuncCall parseCall = new CSFuncCall(string.Empty, SqliteType2CsType(row[typeCol].ToString()), SqliteType2CsReadType(row[typeCol].ToString()));
// parseCall.AddParam("string", row[nameCol].ToString());
// parseCall.targetObj = dataForm;
// parseCall.returnVar = dataVar;
// parseFunc.AddParseCall(parseCall);
// }
// }
// //System.Diagnostics.Trace.WriteLine(writer.GenerateFilsString());
return(writer);
}
static void Main(string[] args)
{
var bookObj = new BookStore();
var bookList = bookObj.GetBookStores();
XDocumentType docType = new XDocumentType("bookstoredoc", null,
null,
@"<!ELEMENT bookstore (book+)>
<!ELEMENT book (title|year|price|author+) >
<!ATTLIST book
category CDATA #REQUIRED>
<!ELEMENT title (#PCDATA)>
<!ATTLIST title
lang CDATA #REQUIRED>
<!ELEMENT year (#PCDATA)>
<!ELEMENT price (#PCDATA)>
<!ELEMENT author (name+)>
<!ELEMENT name (#PCDATA)>");
var xmlDocument = new XDocument(new XElement("bookstore",
bookList.Select(x =>
new XElement("book", new XAttribute("category", x.Category),
new XElement("title", new XAttribute("lang", x.Lang), x.Title),
new XElement("year", x.Year),
new XElement("price", x.Price),
new XElement("author", x.Author.Select(y => new XElement("name", y.Name)))
))));
xmlDocument.Save(@"D:\Test.xml");
XmlReader reader = XmlReader.Create(@"D:\Test.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schemaSet = schema.InferSchema(reader);
foreach (XmlSchema s in schemaSet.Schemas())
{
using (var stringWriter = new StringWriter())
{
using (var writer = XmlWriter.Create(stringWriter))
{
s.Write(writer);
}
string text = stringWriter.ToString();
}
}
Console.WriteLine("Hello World!");
}
public void InferConfigSchema()
{
XmlSchemaInference infer = new XmlSchemaInference();
var schemaSet = infer.InferSchema(XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream("NHibernate.Tool.hbm2net.Tests.t4config.xml")));
Assert.AreEqual(1, schemaSet.Schemas().Count);
foreach (XmlSchema schema in schemaSet.Schemas())
{
schema.Write(Console.Out);
}
}
public static XmlSchemaSet ToXsd(this XmlDocument source)
{
var schema = new XmlSchemaInference();
XmlSchemaSet xmlSchemaSet;
using (var xmlNodeReader = new XmlNodeReader(source))
{
xmlSchemaSet = schema.InferSchema(xmlNodeReader);
}
return(xmlSchemaSet);
}
private static ICollection GetSchemaSet(byte[] file)
{
using (var ms = new MemoryStream(file))
{
var reader = XmlReader.Create(ms);
var schema = new XmlSchemaInference();
var schemaSet = schema.InferSchema(reader);
return(schemaSet.Schemas());
}
}
static void XSDInference_TypeInference()
{
//<snippet3>
XmlReader reader = XmlReader.Create("input.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schema.TypeInference = XmlSchemaInference.InferenceOption.Relaxed;
schemaSet = schema.InferSchema(reader);
//</snippet3>
}
private void GenerateXsd(string path)
{
XmlSchemaInference infer = new XmlSchemaInference();
XmlSchemaSet schemaSet = infer.InferSchema(new XmlTextReader(path));
using (var xmlWriter = XmlWriter.Create(Path.ChangeExtension(path, ".xsd")))
{
foreach (XmlSchema schema in schemaSet.Schemas())
{
schema.Write(xmlWriter);
}
}
}
public void Run()
{
MemoryStream stream = new MemoryStream();
XmlReader reader = XmlReader.Create(FilePath);
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schemaSet = schema.InferSchema(reader);
foreach (XmlSchema item in schemaSet.Schemas())
{
item.Write(stream);
}
File.WriteAllBytes(FilePath + ".xsd", stream.ToArray());
}
public void GenerateSchemaFromXml(XmlReader inputXmlReader, XmlWriter outputXsdWriter)
{
var schemaSet = new XmlSchemaInference().InferSchema(inputXmlReader);
if (schemaSet.Count > 1)
{
throw new Exception("Cannot write multiple schemas to single XmlWriter");
}
foreach (XmlSchema schema in schemaSet.Schemas())
{
schema.Write(outputXsdWriter);
}
}
static void XSDInference_OverallExample()
{
//<snippet1>
XmlReader reader = XmlReader.Create("contosoBooks.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schemaSet = schema.InferSchema(reader);
foreach (XmlSchema s in schemaSet.Schemas())
{
s.Write(Console.Out);
}
//</snippet1>
}
private void GenerateSchema(string filePath)
{
try
{
using (var xmlReader = XmlReader.Create(filePath))
{
XmlSchemaInference schema = new XmlSchemaInference();
_schemaSet = schema.InferSchema(xmlReader);
}
}
catch (Exception ex)
{
MessageBox.Show("An XML schema cannot be infered.\n\n" + ex.Message, "Invalid XML", MessageBoxButton.OK, MessageBoxImage.Error);
_schemaSet = ex;
}
}
/// <summary>
/// Метод создания XSD-файла.
/// </summary>
/// <param name="fileName">XML-файл.</param>
private static void CreateSchema(string fileName)
{
XmlReader reader = XmlReader.Create(PathManager.GetConfigFilePath());
XmlSchemaInference infer = new XmlSchemaInference();
XmlSchemaSet schemaSet =
infer.InferSchema(new XmlTextReader(PathManager.GetConfigFilePath()));
XmlWriter w = XmlWriter.Create(fileName);
foreach (XmlSchema schema in schemaSet.Schemas())
{
schema.Write(w);
}
w.Close();
}
static void XmlSchemaInference_TypeInference()
{
//<snippet3>
XmlReader reader = XmlReader.Create("input.xml");
XmlSchemaSet schemaSet = new XmlSchemaSet();
XmlSchemaInference schema = new XmlSchemaInference();
schema.TypeInference = XmlSchemaInference.InferenceOption.Relaxed;
schemaSet = schema.InferSchema(reader);
foreach (XmlSchema s in schemaSet.Schemas())
{
s.Write(Console.Out);
}
//</snippet3>
}
internal static void inferSchema(string fileName)
{
XmlSchemaInference xsi;
XmlReaderSettings xrs;
//writeElements = false;
try {
ctrSerialAttr = new CodeTypeReference(writeElements ? "XmlElement" : "XmlAttribute");
xsi = new XmlSchemaInference();
xrs = new XmlReaderSettings();
using (XmlReader xr = XmlReader.Create(fileName, xrs)) {
handleSchemaInference(xsi.InferSchema(xr));
}
} catch (Exception ex) {
MyLogger.log(MethodBase.GetCurrentMethod(), ex);
} finally { }
}
