Generieren Sie ein XML-Dokument basierend auf XSD

Heutzutage gibt es viele XML-Tool-Software, die XML-Dokumente basierend auf XSD-Dateien schreiben kann. Daher habe ich mehrere Methoden zum Durchsuchen, Überprüfen und Erstellen von XML geschrieben.

Verwenden des Systems;
Verwenden von System.Data;
Verwenden von System.Configuration;
mit System.Web;
mit System.Web.Security;
mit System.Web.UI;
mit System.Web.UI.WebControls;
mit System.Web.UI.WebControls.WebParts;
mit System.Web.UI.HtmlControls;
mit System.Xml;
mit System.Xml.Schema;
Verwenden von System.Collections;

/**////
/// Zusammenfassende Beschreibung von ProXML
///
öffentliche Klasse ProXml
{
publicProXml()
{
//
// TODO: Konstruktorlogik hier hinzufügen
//
}
/**////
/// XSD-Dateipfad abrufen
///
öffentliche statische Zeichenfolge GetSchemaPath
{
erhalten{
return HttpContext.Current.Request.PhysicalApplicationPath + "App_Data\system\publish.xsd";
}
}
/**////
/// Verarbeitungsknoten abrufen
///
///
öffentliches statisches System.Collections.Generic.List GetDatas()
{
XmlSchemaSet xsSet = new XmlSchemaSet();
xsSet.Add(" http://www.w3.org/2001/XMLSchema ", GetSchemaPath);
xsSet.Compile();
XmlSchema-Schema = null;
foreach (XmlSchema xs in xsSet.Schemas())
{
schema = xs;
}
System.Collections.Generic.List elements=new System.Collections.Generic.List ();
foreach (XmlSchemaObject obj in schema.Elements.Values)
{
if (obj.GetType() == typeof(XmlSchemaElement))
{
elements.Add((XmlSchemaElement)obj);
}

}
Rückgabeelemente;

}
/**////
/// Element hinzufügen
///
///
///
///
///
///
public static void AddElement(XmlSchemaObject sourceXsd, Hashtable titles, XmlDocument sourceXml, XmlNode sourceNd, string[]-Werte)
{

if (sourceXsd.GetType() == typeof(XmlSchemaChoice))
{
XmlSchemaChoice choice = sourceXsd as XmlSchemaChoice;
dezimal min = choice.MinOccurs;
foreach (XmlSchemaObject-Element in choice.Items)
{
if (item.GetType() == typeof(XmlSchemaElement))
{
string name = ((XmlSchemaElement)item).Name;
if (titles.ContainsKey(name))
{
XmlElement element = sourceXml.CreateElement(name);
// element.InnerText = ((Excel.Range)st.Cells[rowIndex, (int)titles[name]]).Value2.ToString();
element.InnerText = Werte[(int)Titel[Name]];
sourceNd.AppendChild(element);
}

}
anders
{
AddElement (Element, Titel, sourceXml, sourceNd, Werte);
}

}

}
else if (sourceXsd.GetType() == typeof(XmlSchemaElement))
{
string name = ((XmlSchemaElement)sourceXsd).Name;
if (titles.ContainsKey(name))
{
XmlElement element = sourceXml.CreateElement(name);
element.InnerText = Werte[(int)Titel[Name]];
sourceNd.AppendChild(element);
}

}
else if (sourceXsd.GetType() == typeof(XmlSchemaSequence))
{
foreach (XmlSchemaObject childItem in ((XmlSchemaSequence)sourceXsd).Items)
{
if (childItem.GetType() == typeof(XmlSchemaElement))
{
string name = ((XmlSchemaElement)childItem).Name;
if (titles.ContainsKey(name))
{
XmlElement element = sourceXml.CreateElement(name);
element.InnerText = Werte[(int)Titel[Name]];
sourceNd.AppendChild(element);
}
}
anders
{
AddElement(childItem, titles, sourceXml, sourceNd, Values);
}

}
}
anders
{
zurückkehren;
}
}
/**////
/// Elemente abrufen
///
///
///
öffentliches statisches System.Collections.Generic.List GetDataItem(string name)
{
System.Collections.Generic.List arr = new System.Collections.Generic.List();
XmlSchemaElement element = GetTableSchema(name);
if (element == null)
{
null zurückgeben;
}
XmlSchemaComplexType complex = element.SchemaType as XmlSchemaComplexType;
XmlSchemaSequence sequence = complex.ContentTypeParticle as XmlSchemaSequence;

foreach (XmlSchemaObject obj in sequence.Items)
{
if (obj.GetType() == typeof(XmlSchemaElement))
{
XmlSchemaElement item = (XmlSchemaElement)obj;
arr.Add(item);

}
anders
{
GetItem(arr, obj);
}
}
Rückkehr arr;
}
public static void GetItem(System.Collections.Generic.List arr, XmlSchemaObject obj)
{
if (obj.GetType() == typeof(XmlSchemaElement))
{
XmlSchemaElement item = (XmlSchemaElement)obj;
arr.Add(item);
}
else if (obj.GetType() == typeof(XmlSchemaChoice))
{
XmlSchemaChoice choice = obj as XmlSchemaChoice;
foreach (XmlSchemaObject untergeordnetes Element in choice.Items)
{
if (child.GetType() == typeof(XmlSchemaElement))
{
XmlSchemaElement item = child as XmlSchemaElement;
arr.Add(item);
}
anders
{
GetItem(arr, child);
}
}
}
else if (obj.GetType() == typeof(XmlSchemaSequence))
{
XmlSchemaSequence sequence = obj as XmlSchemaSequence;
foreach (XmlSchemaObject untergeordnetes Element in sequence.Items)
{
if (child.GetType() == typeof(XmlSchemaObject))
{
XmlSchemaElement item = child as XmlSchemaElement;
arr.Add(item);
}
anders
{
GetItem(arr, child);
}
}
}
anders
{
zurückkehren;
}
}
/**////
/// Den Knoten basierend auf dem Knotennamen abrufen
///
///
///
öffentliches statisches XmlSchemaElement GetTableSchema(String-Name)
{
XmlSchemaSet xsSet = new XmlSchemaSet();
xsSet.Add(" http://www.w3.org/2001/XMLSchema ", GetSchemaPath);
xsSet.Compile();
XmlSchema schema=null;
foreach (XmlSchema xs in xsSet.Schemas())
{
schema = xs;
}
XmlQualifiedName qf = new XmlQualifiedName(name, " http://www.w3.org/2001/XMLSchema ");
if(schema.Elements.Contains(qf))
{
return (XmlSchemaElement)schema.Elements[qf];
}
return null

}
static void XmlValidation(object sender, ValidationEventArgs e)
{
Schalter (z.B. Schweregrad)
{
Fall XmlSeverityType.Error:
throw e.Exception;

case XmlSeverityType.Warning:
throw e.Exception;

}

}
/**////
/// Dom-Objekt überprüfen
///
///
///
öffentliche statische Zeichenfolge CheckDataXml(XmlDocument doc)
{
XmlSchemaSet xsd = new XmlSchemaSet();
xsd.Add("", GetSchemaPath);
doc.Schemas = xsd;
versuchen
{
doc.Validate(new ValidationEventHandler(XmlValidation));
}
Catch (Ausnahme ex)
{
ex.Message zurückgeben;
}
null zurückgeben;
}
}
http://www.cnblogs.com/eric812/archive/2006/11/01/546914.html