Generar documento xml basado en xsd

Hoy en día, existen muchos programas de herramientas XML que pueden escribir documentos XML basados ​​en archivos XSD. Net no implementa este método, así que escribí varios métodos para explorar, verificar y crear XML.

usando Sistema;
usando System.Data;
usando System.Configuration;
usando System.Web;
utilizando System.Web.Security;
utilizando System.Web.UI;
usando System.Web.UI.WebControls;
usando System.Web.UI.WebControls.WebParts;
usando System.Web.UI.HtmlControls;
usando System.Xml;
usando System.Xml.Schema;
usando System.Collections;

/**////
/// Descripción resumida de ProXML
///
clase pública ProXml
{
públicoProXml()
{
//
// TODO: agregue la lógica del constructor aquí
//
}
/**////
/// Obtener la ruta del archivo xsd
///
cadena estática pública GetSchemaPath
{
conseguir{
devolver HttpContext.Current.Request.PhysicalApplicationPath + "App_Data\system\publish.xsd";
}
}
/**////
/// Obtener el nodo de procesamiento
///
///
System.Collections.Generic.List GetDatas() estático público
{
XmlSchemaSet xsSet = nuevo XmlSchemaSet();
xsSet.Add(" http://www.w3.org/2001/XMLSchema ", GetSchemaPath);
xsSet.Compile();
Esquema XmlSchema = nulo;
foreach (XmlSchema xs en xsSet.Schemas())
{
esquema = xs;
}
System.Collections.Generic.List elementos=new System.Collections.Generic.List ();
foreach (objeto XmlSchemaObject en esquema.Elements.Values)
{
si (obj.GetType() == tipode(XmlSchemaElement))
{
elementos.Add((XmlSchemaElement)obj);
}

}
elementos de retorno;

}
/**////
/// Agregar elemento
///
///
///
///
///
///
public static void AddElement (XmlSchemaObject sourceXsd, títulos de Hashtable, XmlDocument sourceXml, XmlNode sourceNd, string[] valores)
{

if (sourceXsd.GetType() == tipode(XmlSchemaChoice))
{
XmlSchemaChoice elección = sourceXsd como XmlSchemaChoice;
decimal min = elección.MinOccurs;
foreach (elemento XmlSchemaObject en Choice.Items)
{
si (item.GetType() == tipode(XmlSchemaElement))
{
nombre de cadena = ((XmlSchemaElement)item).Nombre;
si (títulos.ContieneClave(nombre))
{
Elemento XmlElement = sourceXml.CreateElement(nombre);
// elemento.InnerText = ((Excel.Range)st.Cells[rowIndex, (int)titles[name]]).Value2.ToString();
elemento.InnerText = valores[(int)títulos[nombre]];
fuenteNd.AppendChild(elemento);
}

}
demás
{
AddElement (elemento, títulos, sourceXml, sourceNd, valores);
}

}

}
de lo contrario si (sourceXsd.GetType() == typeof(XmlSchemaElement))
{
nombre de cadena = ((XmlSchemaElement)sourceXsd).Name;
si (títulos.ContieneClave(nombre))
{
Elemento XmlElement = sourceXml.CreateElement(nombre);
elemento.InnerText = valores[(int)títulos[nombre]];
fuenteNd.AppendChild(elemento);
}

}
de lo contrario si (sourceXsd.GetType() == typeof(XmlSchemaSequence))
{
foreach (XmlSchemaObject childItem en ((XmlSchemaSequence)sourceXsd).Items)
{
si (childItem.GetType() == tipode(XmlSchemaElement))
{
nombre de cadena = ((XmlSchemaElement)childItem).Name;
si (títulos.ContieneClave(nombre))
{
Elemento XmlElement = sourceXml.CreateElement(nombre);
elemento.InnerText = valores[(int)títulos[nombre]];
fuenteNd.AppendChild(elemento);
}
}
demás
{
AddElement(childItem, títulos, sourceXml, sourceNd, valores);
}

}
}
demás
{
devolver;
}
}
/**////
/// Obtener elementos
///
///
///
System.Collections.Generic.List estático público GetDataItem (nombre de cadena)
{
System.Collections.Generic.List arr = nuevo System.Collections.Generic.List();
Elemento XmlSchemaElement = GetTableSchema(nombre);
si (elemento == nulo)
{
devolver nulo;
}
XmlSchemaComplexType complejo = element.SchemaType como XmlSchemaComplexType;
Secuencia XmlSchemaSequence = complex.ContentTypeParticle como XmlSchemaSequence;

foreach (obj XmlSchemaObject en secuencia. Elementos)
{
si (obj.GetType() == tipode(XmlSchemaElement))
{
XmlSchemaElement elemento = (XmlSchemaElement)obj;
arr.Agregar(elemento);

}
demás
{
ObtenerArtículo(arr,obj);
}
}
volver llegar;
}
público estático vacío GetItem(System.Collections.Generic.List arr, XmlSchemaObject obj)
{
si (obj.GetType() == tipode(XmlSchemaElement))
{
XmlSchemaElement elemento = (XmlSchemaElement)obj;
arr.Agregar(elemento);
}
de lo contrario si (obj.GetType() == typeof(XmlSchemaChoice))
{
XmlSchemaChoice elección = obj como XmlSchemaChoice;
foreach (niño XmlSchemaObject en elección.Items)
{
si (child.GetType() == tipode(XmlSchemaElement))
{
XmlSchemaElement elemento = hijo como XmlSchemaElement;
arr.Agregar(elemento);
}
demás
{
GetItem(arr, hijo);
}
}
}
de lo contrario si (obj.GetType() == typeof(XmlSchemaSequence))
{
Secuencia XmlSchemaSequence = obj como XmlSchemaSequence;
foreach (XmlSchemaObject hijo en secuencia.Items)
{
si (child.GetType() == tipode(XmlSchemaObject))
{
XmlSchemaElement elemento = hijo como XmlSchemaElement;
arr.Agregar(elemento);
}
demás
{
GetItem(arr, hijo);
}
}
}
demás
{
devolver;
}
}
/**////
/// Obtener el nodo según el nombre del nodo
///
///
///
XmlSchemaElement estático público GetTableSchema (nombre de cadena)
{
XmlSchemaSet xsSet = nuevo XmlSchemaSet();
xsSet.Add(" http://www.w3.org/2001/XMLSchema ", GetSchemaPath);
xsSet.Compile();
esquema XmlSchema = nulo;
foreach (XmlSchema xs en xsSet.Schemas())
{
esquema = xs;
}
XmlQualifiedName qf = nuevo XmlQualifiedName(nombre, " http://www.w3.org/2001/XMLSchema ");
if(esquema.Elementos.Contiene(qf))
{
return (XmlSchemaElement)schema.Elements[qf];
}
devolver nulo;

}
XmlValidation vacío estático (sendor de objeto, ValidationEventArgs e)
{
interruptor (e.Severidad)
{
caso XmlSeverityType.Error:
lanzar e.Exception

caso XmlSeverityType.Warning:
lanzar e.Exception;

}

}
/**////
/// Verificar objeto dom
///
///
///
cadena estática pública CheckDataXml (documento XmlDocument)
{
XmlSchemaSet xsd = nuevo XmlSchemaSet();
xsd.Add("", GetSchemaPath);
doc.Esquemas = xsd;
intentar
{
doc.Validate(new ValidationEventHandler(XmlValidation));
}
captura (Excepción ex)
{
devolver ex.Mensaje;
}
devolver nulo;
}
}
http://www.cnblogs.com/eric812/archive/2006/11/01/546914.html