private XElement GetXElement(XmlNode node)
{
XDocument xDoc = new XDocument();
using (XmlWriter xmlWriter = xDoc.CreateWriter())
node.WriteTo(xmlWriter);
return xDoc.Root;
}
private static XElement GetXElement(XmlNode node) {
var xDoc = new XDocument();
using (XmlWriter xmlWriter = xDoc.CreateWriter()) {
node.WriteTo(xmlWriter);
}
return xDoc.Root;
}
public XmlConverter(XmlNode e)
: this()
{
Contract.Requires(e != null);
e.WriteTo(_writer);
}
internal static string GetXml(XmlNode node)
{
using (var stringWriter = new StringWriter())
using (var xmlTextWriter = XmlWriter.Create(stringWriter))
{
node.WriteTo(xmlTextWriter);
xmlTextWriter.Flush();
return stringWriter.GetStringBuilder().ToString();
}
}
private void WriteXmlOutput(XmlNode resultNode, XmlWriter xmlWriter)
{
this.xmlWriter = xmlWriter;
InitializeXmlFile(resultNode);
resultNode.WriteTo(xmlWriter);
TerminateXmlFile();
}
/// Standard callback
public object Create(object parent, object configContext, XmlNode section)
{
using (MemoryStream ms = new MemoryStream())
{
using (XmlWriter xw = XmlWriter.Create(ms))
section.WriteTo(xw);
ms.Position = 0;
return ms.ToArray();
}
}
private static string FormattedXml(XmlNode node)
{
using (TextWriter textwriter = new StringWriter())
{
XmlTextWriter writer = new XmlTextWriter(textwriter);
writer.Formatting = Formatting.Indented;
node.WriteTo(writer);
return textwriter.ToString();
}
}
static string GetXmlFragment(XmlNode node)
{
using (var stringWriter = new StringWriter())
using (var xmlFragmentWriter = new XmlFragmentWriter(stringWriter))
{
xmlFragmentWriter.Formatting = Formatting.Indented;
node.WriteTo(xmlFragmentWriter);
return stringWriter.GetStringBuilder().ToString();
}
}
public static Stream GetStream(XmlNode node)
{
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(stream);
node.WriteTo(writer);
writer.Flush();
stream.Seek(0, SeekOrigin.Begin);
return stream;
}
public void WriteResultFile(XmlNode resultNode, TextWriter writer)
{
var settings = new XmlWriterSettings();
settings.Indent = true;
using (XmlWriter xmlWriter = XmlWriter.Create(writer, settings))
{
xmlWriter.WriteStartDocument(false);
resultNode.WriteTo(xmlWriter);
}
}
public StudyXmlNode(XmlNode node)
{
using (TextWriter writer = new Utf8StringWriter())
{
using (XmlWriter xmlWriter = XmlWriter.Create(writer,new XmlWriterSettings(){ConformanceLevel = ConformanceLevel.Fragment}))
{
node.WriteTo(xmlWriter);
}
XmlElementFragment = writer.ToString();
}
}
//public static double GetAttribute(this XmlNode suiteResult, string name, double defaultValue)
//{
// XmlAttribute attr = suiteResult.Attributes[name];
// return attr == null
// ? defaultValue
// : double.Parse(attr.Value, System.Globalization.CultureInfo.InvariantCulture);
//}
#endregion
public static string ToFormattedString(System.Xml.XmlNode node, int indentation)
{
using (var sw = new System.IO.StringWriter())
{
using (var xw = new System.Xml.XmlTextWriter(sw))
{
xw.Formatting = System.Xml.Formatting.Indented;
xw.Indentation = indentation;
node.WriteTo(xw);
}
return(sw.ToString());
}
}
private static String FormatRawMessage(XmlNode document)
{
var sb = new StringBuilder();
using (var stringWriter = new StringWriter(sb))
using (var xmlTextWriter = new XmlTextWriter(stringWriter))
{
xmlTextWriter.Formatting = Formatting.Indented;
document.WriteTo(xmlTextWriter);
}
return sb.ToString();
}
private static string FormatXml(XmlNode node)
{
var settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = true;
settings.Indent = true;
settings.IndentChars = " ";
using (var output = new StringWriter())
{
using (var writer = XmlTextWriter.Create(output, settings))
{
node.WriteTo(writer);
}
return output.ToString();
}
}
void WriteXmlNode (XmlNode node)
{
if (node is XmlDocument)
node = ((XmlDocument) node).DocumentElement;
node.WriteTo (Writer);
}
public void WriteNodeTo (XmlNode node)
{
node.WriteTo (output);
}
public override void WriteContentTo (XmlWriter w)
{
for (XmlNode n = FirstChild; n != null; n = n.NextSibling)
n.WriteTo (w);
}
private string FormatXml(XmlNode sUnformattedXml)
{
//will hold formatted xml
StringBuilder sb = new StringBuilder();
//pumps the formatted xml into the StringBuilder above
StringWriter sw = new StringWriter(sb);
//does the formatting
XmlTextWriter xtw = null;
try
{
//point the xtw at the StringWriter
xtw = new XmlTextWriter(sw);
//we want the output formatted
xtw.Formatting = Formatting.Indented;
//get the dom to dump its contents into the xtw
//xd.WriteTo(xtw);
sUnformattedXml.WriteTo(xtw);
}
finally
{
//clean up even if error
if (xtw != null)
xtw.Close();
}
//return the formatted xml
return sb.ToString();
}
public XmlConverter(System.Xml.XmlNode e)
: this()
{
e.WriteTo(_writer);
}
/// <summary>
/// Returns a pretty-printed XML string for the given node.
/// </summary>
/// <param name="node">Node to return the XML for.</param>
/// <param name="formatting">Formatting of the string to be returned.</param>
/// <returns>Returns a formatted XML string.</returns>
public static string GetXml(XmlNode node, Formatting formatting)
{
StringWriter stringWriter = new StringWriter();
XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);
xmlTextWriter.Formatting = formatting;
node.WriteTo(xmlTextWriter);
xmlTextWriter.Flush();
return stringWriter.ToString();
}
public static string ToFormattedString(XmlNode node)
{
string outerXml;
try
{
using (MemoryStream stream = new MemoryStream())
{
XmlWriterSettings settings = new XmlWriterSettings {
Indent = true,
IndentChars = " ",
ConformanceLevel = ConformanceLevel.Fragment
};
using (XmlWriter writer = XmlWriter.Create(stream, settings))
{
node.WriteTo(writer);
}
stream.Position = 0L;
outerXml = Encoding.UTF8.GetString(stream.ToArray());
}
}
catch
{
outerXml = node.OuterXml;
}
return outerXml;
}
//-------------------------------------------------------------------------------------------------//
public static string ToXmlString(XmlNode xmlNode)
{
string xmlString = string.Empty;
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.Formatting = Formatting.Indented;
xmlNode.WriteTo(xtw);
xtw.Flush();
xmlString = sw.ToString();
return xmlString;
}
/// <summary>
/// Writes the Xml Node
/// </summary>
/// <param name="xmlNode">The XML node.</param>
public void WriteNode(XmlNode xmlNode)
{
if (xmlNode != null)
{
xmlNode.WriteTo(this.xmlWriter);
}
}
public static MemoryStream WriteToMemory(XmlNode node)
{
MemoryStream memoryStream = new MemoryStream();
XmlTextWriter xmlTextWriter = new XmlTextWriter(new StreamWriter(memoryStream))
{
Formatting = Formatting.Indented,
Indentation = 4,
IndentChar = ' '
};
node.WriteTo(xmlTextWriter);
xmlTextWriter.Flush();
return memoryStream;
}
// 获得缩进的XML源代码
public static string GetIndentXml(XmlNode node)
{
MemoryStream m = new MemoryStream();
XmlTextWriter w = new XmlTextWriter(m, Encoding.UTF8);
w.Formatting = Formatting.Indented;
w.Indentation = 4;
node.WriteTo(w);
w.Flush();
m.Seek(0, SeekOrigin.Begin);
StreamReader sr = new StreamReader(m, Encoding.UTF8);
string strText = sr.ReadToEnd();
sr.Close();
w.Close();
return strText;
}
private static XmlTextWriter Write(XmlNode node, TextWriter s)
{
XmlTextWriter xmlTextWriter = new XmlTextWriter(s);
xmlTextWriter.Formatting = Formatting.Indented;
xmlTextWriter.Indentation = 1;
xmlTextWriter.IndentChar = '\t';
node.WriteTo(xmlTextWriter);
return xmlTextWriter;
}
private string GetIndentedInnerXml(XmlNode node)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
StringWriter sw = new StringWriter();
using (XmlWriter writer = XmlWriter.Create(sw, settings))
{
node.WriteTo(writer);
}
return sw.ToString();
}
//-------------------------------------------------------------------------------
//
private XElement XmlNodeToXElement(XmlNode node)
{
XDocument doc = new XDocument();
using (XmlWriter xw = doc.CreateWriter()) {
node.WriteTo(xw);
}
return doc.Root;
}
protected IEnumerable<OutputChunk> ChunkXml(XmlNode node)
{
using (var ms = new MemoryStream())
{
var writer = XmlWriter.Create(ms, new XmlWriterSettings { Encoding = Encoding.UTF8 });
node.WriteTo(writer);
writer.Flush();
return ChunkBytes(ms.ToArray());
}
}
/// <summary>
/// Internal function to process response
/// </summary>
/// <param name="errorResources"></param>
/// <param name="appendResponseNode"></param>
/// <returns></returns>
internal static string ProcessErrorRequest(DavProcessErrorCollection errorResources, XmlNode appendResponseNode)
{
string _errorRequest = "";
//Build the response
using (Stream _responseStream = new MemoryStream())
{
var _xmlWriter = new XmlTextWriter(_responseStream, new UTF8Encoding(false));
_xmlWriter.Formatting = Formatting.Indented;
_xmlWriter.IndentChar = '\t';
_xmlWriter.Indentation = 1;
_xmlWriter.WriteStartDocument();
//Set the Multistatus
_xmlWriter.WriteStartElement("D", "multistatus", "DAV:");
//Append the errors
foreach (Enum _errorCode in errorResources.AllResourceErrors)
{
foreach (DavResourceBase _resource in errorResources[_errorCode])
{
//Open the response element
_xmlWriter.WriteStartElement("response", "DAV:");
_xmlWriter.WriteElementString("href", "DAV:", _resource.ResourcePath);
_xmlWriter.WriteElementString("status", "DAV:", GetEnumHttpResponse(_errorCode));
//Close the response element section
_xmlWriter.WriteEndElement();
}
}
if (appendResponseNode != null)
appendResponseNode.WriteTo(_xmlWriter);
_xmlWriter.WriteEndElement();
_xmlWriter.WriteEndDocument();
_xmlWriter.Flush();
using (StreamReader _streamReader = new StreamReader(_responseStream, Encoding.UTF8))
{
//Go to the begining of the stream
_streamReader.BaseStream.Position = 0;
_errorRequest = _streamReader.ReadToEnd();
}
_xmlWriter.Close();
}
return _errorRequest;
}
/// <summary>
/// XmlNode转换为XElement
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static XElement XmlNodeToXElement(XmlNode node)
{
XDocument xDoc = new XDocument();
using (XmlWriter xmlWriter = xDoc.CreateWriter())
node.WriteTo(xmlWriter);
return xDoc.Root;
}
/// <summary>
/// Logs the node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="msg">The MSG.</param>
private void LogNode(XmlNode node, string msg)
{
Console.WriteLine("\n#############################\n{0}", msg);
XmlTextWriter writer = new XmlTextWriter(Console.Out);
writer.Formatting = Formatting.Indented;
node.WriteTo(writer);
}
string GetIndentedOutput (XmlNode n)
{
StringWriter sw = new StringWriter ();
sw.NewLine = "\n";
XmlTextWriter xtw = new XmlTextWriter (sw);
xtw.QuoteChar = '\'';
xtw.Formatting = Formatting.Indented;
n.WriteTo (xtw);
return sw.ToString ();
}
