public static XElement GetElementByPath(this XContainer node, string path)
{
XElement rootElement = null;
try
{
if (path == null)
throw new ArgumentNullException(nameof(path));
var expr = XPathExpression.Compile(path);
var navigator = node.CreateNavigator();
var iterator = (XPathNodeIterator) navigator.Evaluate(expr);
if (iterator != null)
{
while (iterator.MoveNext())
{
if (iterator.Current.IsNode && iterator.Current.NodeType == XPathNodeType.Element)
{
rootElement = (XElement) iterator.Current.UnderlyingObject;
break;
}
}
}
return rootElement;
}
catch (Exception ex)
{
throw;
}
}
public static XPathNavigator GetFhirNavigator(this IXPathNavigable navigable)
{
var navigator = navigable.CreateNavigator();
manager = new XmlNamespaceManager(navigator.NameTable);
manager.AddNamespace("f", "http://hl7.org/fhir");
manager.AddNamespace("atom", "http://www.w3.org/2005/Atom");
return navigator;
}
public static XmlNodeList SelectNodes(this XmlNode source, string expression, params XPathVariable[] variables)
{
if (variables == null || variables.Length == 0 || variables[0] == null)
return source.SelectNodes(expression);
var iterator = Select(expression, source.CreateNavigator(), variables);
return XmlNodeListFactory.CreateNodeList(iterator);
}
/// <summary>
/// Converts an XmlElement to an XElement.
/// </summary>
/// <param name="xmlelement">The XmlElement to convert.</param>
/// <returns>The equivalent XElement.</returns>
/// <code source="..\Vodca.Core\Vodca.Extensions\Extensions.XmlElement.cs" title="C# Source File" lang="C#" />
public static XElement ToXElement(this XmlElement xmlelement)
{
if (xmlelement != null)
{
return XElement.Load(xmlelement.CreateNavigator().ReadSubtree());
}
return null;
}
/// <summary>
/// Converts an XmlDocument to an XDocument.
/// </summary>
/// <param name="xmldoc">The XmlDocument to convert.</param>
/// <returns>The equivalent XDocument.</returns>
/// <code source="..\Vodca.Core\Vodca.Extensions\Extensions.XmlElement.cs" title="C# Source File" lang="C#" />
public static XDocument ToXDocument(this XmlDocument xmldoc)
{
if (xmldoc != null)
{
return XDocument.Load(xmldoc.CreateNavigator().ReadSubtree());
}
return null;
}
public static XElement Transform(this XElement element, string xsl)
{
if (xsl.IsNullOrEmpty()) return element;
var document = new XDocument();
using (var writer = document.CreateWriter())
{
var xslt = new XslCompiledTransform();
xslt.Load(XmlReader.Create(new StringReader(xsl)));
xslt.Transform(element.CreateNavigator(), writer);
}
return document.Root;
}
/// <summary>
/// Gets the navigator.
/// </summary>
/// <param name="navigable">
/// The navigable.
/// </param>
/// <returns>
/// A <see cref="XPathNavigator"/> value.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// The <paramref name="navigable"/> parameter is <c>null</c>.
/// </exception>
/// <exception cref="System.InvalidOperationException">
/// The navigator could not be created.
/// </exception>
public static XPathNavigator GetNavigator(this IXPathNavigable navigable)
{
if (navigable == null)
{
throw new ArgumentNullException("navigable");
}
var navigator = navigable.CreateNavigator();
if (navigator == null)
{
throw new InvalidOperationException(Resources.XPathNavigator_NavigatorNotCreated);
}
return navigator;
}
public static XdmNode ToXdmNode(this IXPathNavigable value, DocumentBuilder documentBuilder) {
if (value == null) throw new ArgumentNullException("value");
return ToXdmNode(value.CreateNavigator(), documentBuilder);
}
public static IEnumerable<object> SelectMultipleResults(this XPathDocument doc, string expression)
{
var nav = doc.CreateNavigator();
var results = nav.Select(expression);
while (results.MoveNext())
{
yield return results.Current;
}
}
public static XElement ConvertToXElement(this XmlElement xmlElement)
{
return XElement.Load(xmlElement.CreateNavigator().ReadSubtree());
}
public static object Evaluate(this XPathDocument doc, string expression)
{
var nav = doc.CreateNavigator();
return nav.Evaluate(expression);
}
/// <summary>
/// Get namespaces.
/// </summary>
/// <param name="document"></param>
/// <returns></returns>
public static IEnumerable<Tuple<string, string>> Namespaces2(this XPathDocument document)
{
var navigator = document.CreateNavigator();
var iter = navigator.Select("//namespace::*[not(. = ../../namespace::*)]");
while (iter.MoveNext())
{
yield return new Tuple<string, string>(iter.Current.Name, iter.Current.Value);
}
}
/// <summary>
/// This is used to get the string result from evaluating an XPath expression against the given
/// document and context.
/// </summary>
/// <param name="document">The document to use</param>
/// <param name="expression">The XPath expression to evaluate</param>
/// <param name="context">The context to use</param>
/// <returns>The evaluated expression result</returns>
/// <overloads>There are two overloads for this method</overloads>
public static string EvalXPathExpr(this IXPathNavigable document, XPathExpression expression,
CustomContext context)
{
XPathExpression t = expression.Clone();
t.SetContext(context);
return document.CreateNavigator().Evaluate(t).ToString();
}
public static XPathNavigator CreateNavigatorSafe(this IXPathNavigable source)
{
if (source == null)
throw Error.ArgumentNull("source");
return source.CreateNavigator();
}
/// <summary>
/// Get namespaces.
/// </summary>
/// <param name="document"></param>
/// <returns></returns>
public static IEnumerable<Tuple<string, string>> Namespaces(this XPathDocument document)
{
var navigator = document.CreateNavigator();
var iter = navigator.Select("//namespace::*");
IDictionary<string, string> d = new Dictionary<string, string>();
while (iter.MoveNext())
{
d[iter.Current.Name] = iter.Current.Value;
}
return d.Select(x => new Tuple<string, string>(x.Key, x.Value));
}
public static System.Xml.XPath.XPathNavigator CreateNavigator(this XmlNode node)
{
return node.CreateNavigator();
}
/// <summary>
/// Wraps an XNode as an IXPathNavigable.
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static IXPathNavigable AsXPathNavigable(this XNode source)
{
Checker.NotNull(source, "source");
return AsXPathNavigable(() => source.CreateNavigator());
}
public static XdmNode ToXdmNode(this IXPathNavigable value, SaxonItemFactory itemFactory) {
if (value == null) throw new ArgumentNullException("value");
return ToXdmNode(value.CreateNavigator(), itemFactory);
}
public static System.Xml.XPath.XPathNavigator CreateNavigator(this XmlDocument document)
{
return document.CreateNavigator();
}
public static System.Xml.XPath.XPathNavigator CreateNavigator(this XmlDocument document, System.Xml.XmlNode node)
{
return document.CreateNavigator(node);
}
public static Func<XPathExpression, string> CreateExprEvaluator(this IXPathNavigable navigable) {
return navigable.CreateNavigator().GetExprEvaluator();
}
public static Func<string, string> CreateEvaluator(this IXPathNavigable navigable) {
return navigable.CreateNavigator().GetEvaluator();
}
public static XPathNavigator CreateNavigator(this XNode node)
{
return node.CreateNavigator(null);
}
/// <summary>
/// Converts the given navigable into an XNode.
/// </summary>
/// <param name="navigable"></param>
/// <returns></returns>
public static XNode ToXNode(this IXPathNavigable navigable)
{
Checker.NotNull(navigable, "navigable");
using (var reader = navigable.CreateNavigator().ReadSubtree())
{
// This bit is needed to avoid an error that says the XmlReader state isn't Interactive.
reader.MoveToContent();
return XNode.ReadFrom(reader);
}
}
