public static void XTransformToWriter(this Linq.XElement xmlDoc, TextWriter writer,
Linq.XElement xmlXslt = null, // Action<XslCompiledTransform> onXsltLoad = null,
object xsltExtension = null,
string urn = "urn:request-info")
{
XslCompiledTransform trans = new XslCompiledTransform();
//if (onXsltLoad != null)
// onXsltLoad(trans);
//else
trans.Load(xmlXslt.CreateReader());
if (xsltExtension != null)
{
XsltArgumentList xslArg = new XsltArgumentList();
xslArg.AddExtensionObject(urn, xsltExtension);
// XTransformTo(trans, xmlDoc.CreateReader(), xslArg, writer);
// var results = writer;
XmlReader input = xmlDoc.CreateReader();
XmlWriterSettings outputSettings = trans.OutputSettings;
using (XmlWriter writerXml = XmlWriter.Create(writer, outputSettings))
{
trans.Transform(input, arguments: xslArg, results: writerXml,
documentResolver: XmlNullResolver.Singleton); // XsltConfigSection.CreateDefaultResolver());
writerXml.Close();
}
}
else
{
// trans.Transform(xmlDoc.CreateNavigator() as IXPathNavigable, arguments: null, results: writer);
XTransformTo(trans, xmlDoc.CreateReader(), null, writer);
}
}
private static AssemblyBinding GetRedirectList(XElement element)
{
var serializer = new XmlSerializer(typeof(AssemblyBinding));
if (!serializer.CanDeserialize(element.CreateReader()))
{
Error("Unable to deserialize assembly bindings, please ensure xml is valid", true);
return null;
}
return serializer.Deserialize(element.CreateReader()) as AssemblyBinding;
}
public void LineNumber_and_LinePosition_return_line_and_column_number_for_text_if_XNodeReader_positioned_on_text_node()
{
var inputXml = new XElement("dummy", "value");
var mockModelProvider = new Mock<XmlModelProvider>();
mockModelProvider
.Setup(m => m.GetTextSpanForXObject(It.Is<XObject>(x => x == inputXml.FirstNode), It.IsAny<Uri>()))
.Returns(new TextSpan { iStartLine = 21, iStartIndex = 42, });
using (var reader = inputXml.CreateReader())
{
reader.Read();
reader.Read();
Assert.Equal(XmlNodeType.Text, reader.NodeType);
Assert.Equal("value", reader.Value);
using (var modelProvider = mockModelProvider.Object)
{
Assert.Equal(
21,
new XNodeReaderLineNumberService(modelProvider, reader, new Uri("urn:abc")).LineNumber);
Assert.Equal(
42,
new XNodeReaderLineNumberService(modelProvider, reader, new Uri("urn:abc")).LinePosition);
}
}
}
/// <summary>
///将xml转化为html;
///应用命名空间:
/// using System.Xml;
/// using System.Xml.XPath;
/// using System.Xml.Xsl;
/// </summary>
/// <param name="xmlDocument">XDocument对象</param>
/// <param name="xslFileStream">xsl数据流</param>
/// <param name="htmlFilePath">输出路径</param>
/// <returns>Exception</returns>
public static Exception Xml2Html(XElement xmlDocument, TextReader xslFileStream, string htmlFilePath)
{
Exception SuFlag = new Exception("操作成功");
try
{
//生成Html文件路径
string HtmlFilePath = htmlFilePath;
XmlReader xst = XmlReader.Create(xslFileStream, new XmlReaderSettings() { DtdProcessing = DtdProcessing.Ignore});
XmlReader xmlreader = xmlDocument.CreateReader(ReaderOptions.OmitDuplicateNamespaces);
XPathDocument myXPathDoc = new XPathDocument(xmlreader);
XslCompiledTransform myXslTrans = new XslCompiledTransform();
xmlreader.Close();
//加载XSL文件
XsltSettings xs = XsltSettings.TrustedXslt;
myXslTrans.Load(xst, xs, new XmlUrlResolver());
XmlWriter myWriter = XmlTextWriter.Create(HtmlFilePath, myXslTrans.OutputSettings);
myXslTrans.Transform(myXPathDoc, null, myWriter);
myWriter.Close();
xst.Close();
}
catch (Exception ex)
{
SuFlag = ex;
}
return SuFlag;
}
private static XmlReader CreateXmlReader(EFArtifact artifact, XElement xobject)
{
var baseReader = xobject.CreateReader();
var lineNumberService = new XNodeReaderLineNumberService(artifact.XmlModelProvider, baseReader, artifact.Uri);
var proxyReader = new XmlReaderProxy(baseReader, artifact.Uri, lineNumberService);
return proxyReader;
}
/// <summary>
/// Converts source XML with given transform with applying DSL
/// </summary>
/// <param name="xml"> </param>
/// <returns>XElement with data, converted by transform</returns>
/// <exception cref="XmlDslLoaderException">
/// <list type="bullet">
/// <item><description>cannot find transform file</description></item>
/// <item><description>any problem with underlined XmlDslDefinition</description></item>
/// </list>
/// </exception>
public XElement Load(XElement xml) {
if (null == xml.Element("transform")) return xml; //no dsl needed
var trdef = new XmlDslDefinition().Extract(xml);
var langfile = Resolver.Resolve(Rootdir+"/" + trdef.LangName + ".xslt", false);
if (!File.Exists(langfile))
{
throw new XmlDslLoaderException("Не возможно найти файл XML языка" + langfile);
}
var xsl = new XslCompiledTransform();
if(trdef.NeedPrepareXslt) {
var xsltcontent = XElement.Load(langfile);
xsltcontent = trdef.PrepareXslt(xsltcontent);
var resolver = new XmlDslRootBasedXmlUrlResolver(langfile);
xsl.Load(xsltcontent.CreateReader(),XsltSettings.TrustedXslt,resolver);
}else {
xsl.Load(langfile, XsltSettings.TrustedXslt, new XmlUrlResolver());
}
var args = trdef.CreateArguments();
var sw = new StringWriter();
using (var xw = XmlWriter.Create(sw)) {
xsl.Transform(xml.CreateReader(),args,xw);
xw.Flush();
}
return XElement.Parse(sw.ToString());
}
private static StorageException Create(int httpStatusCode, XElement extendedErrorElement)
{
// Unfortunately, the RequestResult properties are all internal-only settable. ReadXml is the only way to
// create a populated RequestResult instance.
XElement requestResultElement = new XElement("RequestResult",
new XElement("HTTPStatusCode", httpStatusCode),
new XElement("HttpStatusMessage"),
new XElement("TargetLocation"),
new XElement("ServiceRequestID"),
new XElement("ContentMd5"),
new XElement("Etag"),
new XElement("RequestDate"),
new XElement("StartTime", DateTime.Now),
new XElement("EndTime", DateTime.Now),
extendedErrorElement);
RequestResult result = new RequestResult();
using (XmlReader reader = requestResultElement.CreateReader())
{
result.ReadXml(reader);
}
return new StorageException(result, null, null);
}
public void When_transforming_xml_to_html_output_is_generated()
{
XElement element = new XElement("ApiCheckResult");
MemoryStream sut = new MemoryStream();
Assert.DoesNotThrow(() => XmlTransformer.TransformToHtml(element.CreateReader(), sut));
Assert.Greater(sut.Length, 0);
}
/// <summary>
/// Converts an object into its XML representation.
/// </summary>
/// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized.</param>
void IXmlSerializable.WriteXml(XmlWriter writer)
{
var type = GetType();
var element = new XElement(type.Name);
var serializer = SerializationFactory.GetXmlSerializer();
serializer.Serialize(this, new XmlSerializationContextInfo(element, this));
// The serializer gives us the full element, but we only need the actual content. According to
// http://stackoverflow.com/questions/3793/best-way-to-get-innerxml-of-an-xelement, this method is the fastest:
var reader = element.CreateReader();
reader.MoveToContent();
// CTL-710: fix attributes on top level elements
if (reader.HasAttributes)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
var attributePrefix = reader.Prefix;
var attributeLocalName = reader.LocalName;
var attributeNs = reader.NamespaceURI;
var attributeValue = reader.Value;
writer.WriteAttributeString(attributePrefix, attributeLocalName, attributeNs, attributeValue);
}
reader.MoveToElement();
}
var elementContent = reader.ReadInnerXml();
writer.WriteRaw(elementContent);
}
private string ConvertToErrorHtml(XElement xml) {
var xslt = GetType().Assembly.ReadManifestResource("errors.xslt");
var cxslt = new XslCompiledTransform();
cxslt.Load(XmlReader.Create(new StringReader(xslt)),XsltSettings.TrustedXslt, new XmlUrlResolver());
var sw = new StringWriter();
cxslt.Transform(xml.CreateReader(),new XsltArgumentList(),sw);
return sw.ToString();
}
/// <summary>
/// Creates the specified path to config file.
/// </summary>
/// <param name="sectionElement">The section element.</param>
/// <returns>The strongly typed consfig section</returns>
private object Create(XElement sectionElement)
{
var typeName = sectionElement.HasAttributes ? sectionElement.Attributes()
.SingleOrDefault(x => x.Name.LocalName.Equals("Type", StringComparison.InvariantCultureIgnoreCase)).Value
: string.Empty;
var ser = new XmlSerializer(Type.GetType(typeName));
return ser.Deserialize(sectionElement.CreateReader());
}
static XmlNode GetXmlNode(XElement element)
{
using (XmlReader xmlReader = element.CreateReader())
{
var xmlDoc = new XmlDocument();
xmlDoc.Load(xmlReader);
return xmlDoc;
}
}
public static XmlNamespaceManager GetXmlNamespaceManager(XElement elem)
{
XmlNamespaceManager xnsm = new XmlNamespaceManager(elem.CreateReader().NameTable);
foreach (var key in TypeNamespaces.AllKeys) {
xnsm.AddNamespace(TypeNamespaces[key], key);
}
return xnsm;
}
private void Execute(XslCompiledTransform xslt, XElement xml, XsltArgumentList args, string path) {
Directory.CreateDirectory(Path.GetDirectoryName(path));
if (NoXml)
{
using (var tw = new StreamWriter(path))
{
xslt.Transform(xml.CreateReader(),args,tw);
tw.Flush();
}
}
else
{
using (var xw = XmlWriter.Create(path))
{
xslt.Transform(xml.CreateReader(), args, xw, new BSharpXmlResolver(Project));
xw.Flush();
}
}
}
public static IExpression Expression(this IExpressionsManager manager, XElement element)
{
Configuration config = new Configuration();
IConfigurationElement configElement = config.AddSection("expression extensions").AddElement("expression");
configElement.ReadXml(element.CreateReader());
IExpression expression = manager.Token(configElement.GetAttributeReference("type").Value.ToString()) as IExpression;
if (null != expression)
expression.Make(configElement, manager);
return expression;
}
private static XmlElement DownCastToSurfaceElement(XElement element)
{
XNamespace ns = "http://www.opengis.net/gml/3.2";
XmlDocument doc = new XmlDocument();
element.Name = ns+ "Surface";
return doc.ReadNode(element.CreateReader()) as XmlElement;
}
private ISequenceTypeDataModel _GenerateSequenceDataModel(ISequenceTypeModuleInstance sequenceTypeModule,
XElement xmlContent)
{
DataContractSerializer serializer = SequenceTypeService.GetSequenceTypeDataSerializer(sequenceTypeModule);
if (serializer == null) return null;
using (XmlReader xmlReader = xmlContent.CreateReader()) {
object sequenceData = serializer.ReadObject(xmlReader);
return (ISequenceTypeDataModel) sequenceData;
}
}
public static object DeserializeXElement(this XmlSerializer xs, XElement xe)
{
object o;
using (var r = xe.CreateReader())
{
o = xs.Deserialize(r);
r.Close();
}
return o;
}
public static XmlElement ToXmlElement(XElement xElement)
{
if (xElement == null)
return null;
var xmlElement = (XmlElement)null;
var xmlReader = (XmlReader)null;
try
{
xmlReader = xElement.CreateReader();
xmlElement = new XmlDocument().ReadNode(xElement.CreateReader()) as XmlElement;
}
catch
{
}
finally
{
if (xmlReader != null)
xmlReader.Close();
}
return xmlElement;
}
public static void FromXml(this IExpression expression, XElement element, IExpressionsManager expressionsManager)
{
if (null == expression) throw new ArgumentNullException("expression");
if (null == element) throw new ArgumentNullException("element");
if (null == expressionsManager) throw new ArgumentNullException("expressionsManager");
Configuration config = new Configuration();
IConfigurationElement configElement = config.AddSection("expression extensions").AddElement("expression");
configElement.ReadXml(element.CreateReader());
expression.Make(configElement, expressionsManager);
}
private XDocument TransformMarkup(XElement inputRoot)
{
var newTree = new XDocument();
using (XmlWriter writer = newTree.CreateWriter())
{
var xslTransformer = new XslCompiledTransform();
xslTransformer.LoadFromPath(this.MapPath(XsltFileName));
xslTransformer.Transform(inputRoot.CreateReader(), writer);
}
return newTree;
}
static void Handler_XslTransform(string xslPath, XElement xml, string outputFileName)
{
var xmlTransform = new XslCompiledTransform();
using (var writer = XmlWriter.Create(outputFileName, new XmlWriterSettings { Indent = true }))
using (var xsltStream = File.Open(xslPath, FileMode.Open, FileAccess.Read))
using (var xsltReader = XmlReader.Create(xsltStream))
using (var xmlReader = xml.CreateReader())
{
xmlTransform.Load(xsltReader);
xmlTransform.Transform(xmlReader, writer);
}
}
public XElement GenerateDiffGram(XElement element1, XElement element2) {
using (var node1Reader = element1.CreateReader())
using (var node2Reader = element2.CreateReader()) {
var result = new XDocument();
using (var writer = result.CreateWriter()) {
var diff = new XmlDiff(XmlDiffOptions.IgnoreChildOrder | XmlDiffOptions.IgnoreWhitespace | XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreXmlDecl);
diff.Compare(node1Reader, node2Reader, writer);
writer.Flush();
writer.Close();
}
return result.Root;
}
}
/// <summary>
/// Deserialize a specific service configuration node.
/// </summary>
/// <param name="calendarType"></param>
/// <param name="configuration"></param>
/// <returns></returns>
private IServiceConfiguration DeserializeServiceConfiguration(string calendarType, XElement configuration)
{
Type serializationType = typeof(object);
if (calendarType.Equals("GoogleServiceConfiguration"))
{
serializationType = typeof(GoogleServiceConfiguration);
}
else
{
throw new InvalidDataException("Unknown type for service configuration.");
}
var serializer = new XmlSerializer(serializationType);
return (IServiceConfiguration)serializer.Deserialize(configuration.CreateReader());
}
/// <summary>
/// Converts an object into its XML representation.
/// </summary>
/// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized.</param>
void IXmlSerializable.WriteXml(XmlWriter writer)
{
var type = GetType();
var element = new XElement(type.Name);
var serializer = SerializationFactory.GetXmlSerializer();
serializer.Serialize(this, new XmlSerializationContextInfo(element, this));
// The serializer gives us the full element, but we only need the actual content. According to
// http://stackoverflow.com/questions/3793/best-way-to-get-innerxml-of-an-xelement, this method is the fastest:
var reader = element.CreateReader();
reader.MoveToContent();
var elementContent = reader.ReadInnerXml();
writer.WriteRaw(elementContent);
}
public XmlDocument GenerateXml(Feed feed)
{
var element = new XElement("feed",
new XElement("id", m_feedInfo.PublicationName),
GetLinkElement(m_feedInfo.PublicationName),
new XElement("title", feed.Title),
new XElement("updated", feed.LastUpdated.ToString("yyyy-MM-ddTH:mm:sszzz")),
GetEntries(feed.Entries));
XmlReader xmlReader = element.CreateReader();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlReader);
SetNamespaces(xmlDoc);
return xmlDoc;
}
/// <summary>
/// Deserialize a specific calendar configuration node.
/// </summary>
/// <param name="calendarType"></param>
/// <param name="configuration"></param>
/// <returns></returns>
private ICalendarConfiguration DeserializeCalendarConfiguration(string calendarType, XElement configuration)
{
Type serializationType = typeof(object);
if (calendarType.Equals("GoogleCalendarConfiguration"))
{
serializationType = typeof (GoogleCalendarConfiguration);
}
else if (calendarType.Equals("ExchangeCalendarConfiguration"))
{
serializationType = typeof (ExchangeCalendarConfiguration);
}
else
{
throw new InvalidDataException("Unable to parse calendar configuration");
}
var serializer = new XmlSerializer(serializationType);
return (ICalendarConfiguration)serializer.Deserialize(configuration.CreateReader());
}
private XmlElement MakeXmlEnemyInstanceTemplate(XmlDocument doc)
{
XmlElement enemyInst = doc.CreateElement("EnemyInstance");
enemyInst.SetAttribute("level", "0");
XElement template = new XElement("EnemyInstance", new XAttribute("level", "0"),
new XElement("Description", new XAttribute("value", "0")),
new XElement("Classes"),
new XElement("Stats", new XAttribute("HP", "1"), new XAttribute("MP", "0"), new XAttribute("SP", "0"), new XAttribute("Strength", "0"), new XAttribute("Vitality", "0"), new XAttribute("Magic", "0"), new XAttribute("Spirit", "0"), new XAttribute("Skill", "0"), new XAttribute("Speed", "0"), new XAttribute("Evasion", "0"), new XAttribute("MgEvasion", "0"), new XAttribute("Accuracy", "0"), new XAttribute("Luck", "0")),
new XElement("StatusResistances"),
new XElement("ElementalEffectiveness"),
new XElement("LootTable"),
new XElement("DropTable"),
new XElement("AIScript"),
new XElement("Flags"));
using (var xmlRead = template.CreateReader())
{
return (XmlElement)doc.ReadNode(xmlRead);
}
}
private void CreateOrUpdateContent(ZipFile zipFile, Guid key, XmlSerializer xmlSerialiser, XElement node)
{
var content = Services.ContentService.GetById(key);
var newContent = (Content)xmlSerialiser.Deserialize(node.CreateReader());
if (content != null)
{
SaveContent(node, content, newContent, zipFile);
Report.Add(new Report(content.Id, ActionTypes.Update, ObjectTypes.Document));
}
else
{
var parentId = GetContentParentId(newContent);
var newNode = Services.ContentService.CreateContent(newContent.Name, parentId, newContent.ContentTypeAlias,
User.GetCurrent().Id);
newNode.Key = newContent.Key;
SaveContent(node, newNode, newContent, zipFile);
Report.Add(new Report(newNode.Id, ActionTypes.Create, ObjectTypes.Document));
}
}
static XElement GetInnerXmlPriv(XElement elem, bool addCss)
{
if (elem == null)
return null;
ReplaceSee(elem);
using (var r = elem.CreateReader(ReaderOptions.OmitDuplicateNamespaces))
{
r.MoveToContent();
var str = r.ReadInnerXml().Trim();
//if (str.FirstOrDefault() != '<')
str = "<span>{0}</span>".Put(str);
var retVal = new XElement("div", XElement.Parse(str));
if (addCss)
retVal.Add(new XAttribute("class", "doc_" + elem.Name));
return retVal;
}
}
internal static string Render(XElement element)
{
try
{
var xslCompiledTransform = new XslCompiledTransform(true);
System.IO.StringReader stringReader = new System.IO.StringReader(Properties.Resources.XmlToHtml10Basic);
XmlReader xmlReader = XmlReader.Create(stringReader);
XsltSettings xsltSettings = new XsltSettings(true, true);
xslCompiledTransform.Load(xmlReader, xsltSettings, new XmlUrlResolver());
XsltArgumentList a = new XsltArgumentList();
// Need to pass the xml string as an input parameter so
// we can do some parsing for extra bits that XSLT won't do.
a.AddParam(@"xmlinput", string.Empty, element.ToString());
var stringBuilder = new StringBuilder();
XmlWriter xmlWriter = XmlWriter.Create(stringBuilder); // Target not a chorus file so Palaso.Xml.CanonicalXmlSettings not needed here.
xslCompiledTransform.Transform(element.CreateReader(), a, xmlWriter);
return stringBuilder.ToString();
}
catch (Exception e)
{
return e.Message;
}
}
