name - xml comments c#

¿Cómo transformar XML como una cadena sin usar archivos en.NET?

Question

Digamos que tengo dos cadenas:

• uno es datos XML
• y el otro es datos XSL.

Los datos xml y xsl se almacenan en columnas de la base de datos, si es necesario.

¿Cómo puedo transformar el XML en C # sin guardar primero los archivos xml y xsl como archivos? Me gustaría que la salida sea también una cadena (HTML de la transformación).

Parece que C # prefiere transformarse a través de archivos. No pude encontrar una sobrecarga de entrada de cadena para Load () en XslCompiledTransform. Entonces, es por eso que estoy preguntando.

Answer 1

Envío el contenido xml y luego cargo el documento XSLT, aplique la transformación y luego devuelva el nuevo xml.

public static string Transform(string xmlString)
{
string output = String.Empty;
try
{
// Load an XML string into the XPathDocument.
StringReader rdr = new StringReader(xmlString);
XPathDocument myXPathDoc = new XPathDocument(rdr);
var myXslTrans = new XslTransform();
//load the Xsl
myXslTrans.Load("XSLTFile.xslt");
//create the output stream
StringWriter sw = new StringWriter();
XmlWriter xwo = XmlWriter.Create(sw);
//do the actual transform of Xml
myXslTrans.Transform(myXPathDoc, null, xwo);
output = sw.ToString();
xwo.Close();
return output;
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
throw;
}
}

NOTA: "XSLTFile.xslt" Se agrega a la solución y establece la propiedad "Copiar en el directorio de salida" en "Copiar siempre".

Answer 2

Esto es lo que hice. Es una combinación de tus respuestas. Voté las respuestas que inspiraron esto:

string output = String.Empty;
using (StringReader srt = new StringReader(xslInput)) // xslInput is a string that contains xsl
using (StringReader sri = new StringReader(xmlInput)) // xmlInput is a string that contains xml
{
using (XmlReader xrt = XmlReader.Create(srt))
using (XmlReader xri = XmlReader.Create(sri))
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(xrt);
using (StringWriter sw = new StringWriter())
using (XmlWriter xwo = XmlWriter.Create(sw, xslt.OutputSettings)) // use OutputSettings of xsl, so it can be output as HTML
{
xslt.Transform(xri, xwo);
output = sw.ToString();
}
}
}

Nota: esta declaración es obligatoria en xsl, para que salga como HTML:

<xsl:output method="html" omit-xml-declaration="yes" />

Answer 3

Me tomó mucho tiempo (literalmente años) averiguar qué tan conciso es el código usando Stream y / o TextWriter si usa los modismos adecuados.

Suponiendo que la transform y la input son cadenas:

StringWriter sw = new StringWriter();
using (XmlReader xrt = XmlReader.Create(new StringReader(transform))
using (XmlReader xri = XmlReader.Create(new StringReader(input))
using (XmlWriter xwo = XmlWriter.Create(sw))
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(xrt);
xslt.Transform(xri, xwo);
}
string output = sw.ToString();

Answer 4

Puede XmlReader.Create () desde un StringReader o un MemoryStream . XslCompileTransfrom puede cargar () desde un XmlReader .

Answer 5

Una versión de VB.Net inspirada en la respuesta de Robert Rossney:

Private Function TransformXML(XMLPath As String, XSLPath As String) As String
Dim XSLT As XslCompiledTransform = New XslCompiledTransform()
Dim sWriter As StringWriter = New StringWriter
Dim xReader As XmlReader = XmlReader.Create(XMLPath)
Using xWriter As XmlWriter = XmlWriter.Create(sWriter)
XSLT.Load(XSLPath)
XSLT.Transform(xReader, xWriter)
End Using
Return sWriter.ToString
End Function

Answer 6

Utilizaría las XmlReader.Create(DatabaseBlobStream) y XmlWriter.Create(StringBuilder) . Usando el siguiente objeto DatabaseBlobStream

DatabaseBlobStream.cs

internal class DatabaseBlobStream : Stream
{
private readonly IDataReader reader;
private readonly int columnIndex;
private long streamPosition;
internal DatabaseBlobStream(IDataReader reader, int columnIndex)
{
this.reader = reader;
this.columnIndex = columnIndex;
}
public override bool CanRead
{
get
{
return reader.GetFieldType(columnIndex) == typeof (byte[])
&& !reader.IsDBNull(columnIndex);
}
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return false; }
}
public override void Flush()
{
throw new Exception("This stream does not support writing.");
}
public override long Length
{
get { throw new Exception("This stream does not support the Length property."); }
}
public override long Position
{
get
{
return streamPosition;
}
set
{
streamPosition = value;
}
}
public override int Read(byte[] buffer, int offset, int count)
{
if (reader.IsDBNull(columnIndex))
return 0;
int bytesRead = (int)reader.GetBytes(columnIndex, streamPosition + offset, buffer, 0, count);
streamPosition += bytesRead;
return bytesRead;
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new Exception("This stream does not support seeking.");
}
public override void SetLength(long value)
{
throw new Exception("This stream does not support setting the Length.");
}
public override void Write(byte[] buffer, int offset, int count)
{
throw new Exception("This stream does not support writing.");
}
public override void Close()
{
try
{
reader.Close();
}
finally
{
base.Close();
}
}
protected override void Dispose(bool disposing)
{
try
{
reader.Dispose();
}
finally
{
base.Dispose(disposing);
}
}
}

Answer 7

editar: usando-bloques agregados

// input-xml
string xmlinput = String.Empty;
// xslt
string xsltinput = String.Empty;
// output-xml
string xmloutput = String.Empty;
// Prepare input-xml
XPathDocument doc = new XPathDocument(new StringReader(xmlinput));
// Prepare XSLT
XslTransform xslt = new XslTransform();
// Creates a XmlReader from your xsl string
using (XmlReader xmlreader = XmlReader.Create(new StringReader(xsltinput)))
{
//Load the stylesheet.
xslt.Load(xmlreader);
// transform
using (StringWriter sw = new StringWriter())
{
xslt.Transform(doc, null, sw);
// save to string
xmloutput = sw.ToString();
}
}