/// <summary>
/// Selects a node set using the specified XPath expression.
/// </summary>
public static XPathNodeIterator Select(string expression, XPathNavigator source,
XmlNamespaceManager context)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(context);
return(source.Select(expr));
}
/// <summary>
/// Evaluates the given expression and returns the typed result.
/// </summary>
public static object Evaluate(string expression, XPathNavigator source,
XmlNamespaceManager context)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(context);
return(source.Evaluate(expr));
}
/// <summary>
/// Evaluates the given expression and returns the typed result.
/// </summary>
public static object Evaluate(string expression, XPathNavigator source,
params XmlPrefix[] prefixes)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(PrepareContext(source, null, prefixes, null));
return(source.Evaluate(expr));
}
private static Uri FindAlternateUri(XPathNavigator navigator, Uri ns)
{
Uri uri = null;
XPathNavigator nav = navigator.Clone();
XPathNodeIterator iter;
XmlNamespaceManager nsm = new XmlNamespaceManager(nav.NameTable);
nsm.AddNamespace(DefaultValues.AtomNSPrefix, ns.ToString());
XPathExpression expr = nav.Compile("child::atom:link[@type=\"text/html\" and @rel=\"alternate\"]");
expr.SetContext(nsm);
iter = nav.Select(expr);
if (iter.Count == 0)
{
expr = nav.Compile("child::atom:link[@type=\"text/plain\" and @rel=\"alternate\"]");
expr.SetContext(nsm);
iter = nav.Select(expr);
}
if (iter.CurrentPosition == 0)
{
iter.MoveNext();
}
// select the attributes
iter = iter.Current.Select("@*");
do
{
switch (iter.Current.Name.ToLower())
{
case "href":
try
{
uri = resolveUri(xmlBaseRootUri, iter.Current.Value);
}
catch { }
break;
}
} while (iter.MoveNext());
return(uri);
}
/// <summary>
/// Evaluates the given expression and returns the typed result.
/// </summary>
public static object Evaluate(string expression, XPathNavigator source,
params XPathVariable[] variables)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(PrepareContext(source, null, null, variables));
return(source.Evaluate(expr));
}
/// <summary>
/// Selects a node set using the specified XPath expression.
/// </summary>
public static XPathNodeIterator Select(string expression, XPathNavigator source,
XmlPrefix[] prefixes, params XPathVariable[] variables)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(PrepareContext(source, null, prefixes, variables));
return(source.Select(expr));
}
/// <summary>
/// Selects a node set using the specified XPath expression.
/// </summary>
public static XPathNodeIterator Select(string expression, XPathNavigator source,
XmlNamespaceManager context, params XPathVariable[] variables)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(PrepareContext(source, context, null, variables));
return(source.Select(expr));
}
/// <summary>Sets the manager to use to resolve expression namespaces.</summary>
public void SetContext(XmlNamespaceManager nsManager)
{
if (_expr != null)
{
_expr.SetContext(nsManager);
}
_ns = nsManager;
}
public void FragmentDeserialization()
{
#region <publishers> framgment deserialization
XPathDocument doc = new XPathDocument(Globals.GetResource(Globals.PubsNsResource));
XPathNavigator nav = doc.CreateNavigator();
// Deserialize all publishers.
XmlNamespaceManager mgr = new XmlNamespaceManager(nav.NameTable);
mgr.AddNamespace("mvp", "mvp-xml");
XPathExpression expr = nav.Compile("/mvp:dsPubs/mvp:publishers");
expr.SetContext(mgr);
XmlSerializer ser = new XmlSerializer(typeof(publishers));
XPathNodeIterator it = nav.Select(expr);
while (it.MoveNext())
{
XPathNavigatorReader r = new XPathNavigatorReader(it.Current);
object publisher = ser.Deserialize(r);
Assert.IsNotNull(publisher);
}
#endregion <publishers> framgment deserialization
#region <titles> framgment deserialization
// Now deserialize expensive titles separately.
expr = nav.Compile("//mvp:titles[mvp:price>10]");
expr.SetContext(mgr);
ser = new XmlSerializer(typeof(titles));
it = nav.Select(expr);
while (it.MoveNext())
{
XPathNavigatorReader r = new XPathNavigatorReader(it.Current);
object title = ser.Deserialize(r);
Assert.IsNotNull(title);
}
#endregion <titles> framgment deserialization
}
public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
{
string str = XPathMessageFunction.ToString(args[0]);
string xpath = string.Format(CultureInfo.InvariantCulture, "/s11:Envelope/s11:Header/*[@s11:actor='{0}'] | /s12:Envelope/s12:Header/*[@s12:role='{1}']", new object[] { str, str });
XPathExpression expr = docContext.Compile(xpath);
expr.SetContext((XmlNamespaceManager)xsltContext);
return(docContext.Evaluate(expr));
}
public void SetContext(XsltContext context)
{
path.SetContext(context);
if (firstStep != null)
{
firstStep.SetContext(context);
}
}
/// <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());
}
/// <summary>
/// Implements the following function
/// object dyn2:evaluate(node-set, string, string?)
/// </summary>
/// <param name="contextNode">Context node</param>
/// <param name="expression">Expression to evaluate</param>
/// <param name="namespaces">Namespace bindings</param>
/// <returns>Result of evaluating given Xpath expression WRT to context node.</returns>
/// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
public object Evaluate(XPathNodeIterator contextNode, string expression, string namespaces)
{
if (expression == string.Empty || contextNode == null)
{
return(string.Empty);
}
if (contextNode.MoveNext())
{
try
{
XPathExpression expr = contextNode.Current.Compile(expression);
ExsltContext context = new ExsltContext(contextNode.Current.NameTable);
XPathNavigator node = contextNode.Current.Clone();
if (node.NodeType != XPathNodeType.Element)
{
node.MoveToParent();
}
if (node.MoveToFirstNamespace())
{
do
{
context.AddNamespace(node.Name, node.Value);
} while (node.MoveToNextNamespace());
}
if (namespaces != string.Empty)
{
try
{
Regex regexp = new Regex(@"xmlns:(?<p>\w+)\s*=\s*(('(?<n>.+)')|(""(?<n>.+)""))\s*");
Match m = regexp.Match(namespaces);
while (m.Success)
{
try
{
context.AddNamespace(m.Groups["p"].Value,
m.Groups["n"].Value);
}
catch { }
m = m.NextMatch();
}
}
catch { }
}
expr.SetContext(context);
return(contextNode.Current.Evaluate(expr, contextNode));
}
catch
{
//Any exception such as syntax error in XPath
return(string.Empty);
}
}
//Empty nodeset as context node
return(string.Empty);
}
/// <summary>
/// Selects a node set using the specified XPath expression.
/// </summary>
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source,
object sortExpression, IComparer comparer, params XPathVariable[] variables)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(PrepareContext(source, null, null, variables));
PrepareSort(expr, source, sortExpression, comparer);
return(source.Select(expr));
}
/// <summary>
/// This method sets the inherent XPathNodeIterator instance.
/// </summary>
/// <param name="xPath">A compiled XPath expression</param>
private void FindXPath(XPathExpression?xPath)
{
xPath?.SetContext(_paramContext);
if (xPath != null)
{
_xIter = _xNav?.Select(xPath);
}
InitializeCustomContext(_paramContext);
}
public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
{
if (this.expr == null)
{
XPathExpression expression = docContext.Compile("(/s11:Envelope/s11:Header | /s12:Envelope/s12:Header)[1]");
expression.SetContext(XPathMessageFunction.Namespaces);
this.expr = expression;
}
return(docContext.Evaluate(this.expr));
}
public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
{
if (this.expr == null)
{
XPathExpression expression = docContext.Compile("(sm:header()/wsa10:ReplyTo | sm:header()/wsaAugust2004:ReplyTo)[1]");
expression.SetContext((XmlNamespaceManager) new XPathMessageContext());
this.expr = expression;
}
return(docContext.Evaluate(this.expr));
}
protected override void ProcessXmlReader(XmlReader xmlReader)
{
try
{
while (!xmlReader.EOF)
{
XPathDocument xpathDocument = new XPathDocument(xmlReader);
XPathNavigator xpathNavigator = xpathDocument.CreateNavigator();
XPathNodeIterator nodes;
if (_xmlNamespaces != null)
{
XmlNamespaceManager xmlNamespaceMgr = new XmlNamespaceManager(xmlReader.NameTable);
foreach (string xmlNamespace in _xmlNamespaces)
{
string[] tmp = xmlNamespace.Split(new char[] { '=' });
xmlNamespaceMgr.AddNamespace(tmp[0].Trim(), tmp[1].Trim());
}
_compiledXPathExpression.SetContext(xmlNamespaceMgr);
nodes = xpathNavigator.Select(_compiledXPathExpression);
}
else
{
XPathNavigator namespaceResolver = xpathNavigator.Clone();
if (namespaceResolver.NodeType == XPathNodeType.Root)
{
// Move to doc element where namespaces are commonly defined
namespaceResolver.MoveToFirstChild();
}
nodes = xpathNavigator.Select(_xpathExpression, namespaceResolver);
}
while (nodes.MoveNext())
{
WriteObject(nodes.Current.Clone());
}
}
}
catch (Exception ex)
{
ErrorHandler.WriteXmlError(ex);
}
}
/// <summary>
/// Selects a node set using the specified XPath expression.
/// </summary>
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source,
object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType,
XmlNamespaceManager context)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(context);
PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType, context);
return(source.Select(expr));
}
/// <summary>
/// Selects a node set using the specified XPath expression.
/// </summary>
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source,
object sortExpression, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType,
params XPathVariable[] variables)
{
XPathExpression expr = GetCompiledExpression(expression, source);
expr.SetContext(PrepareContext(source, null, null, variables));
PrepareSort(expr, source, sortExpression, order, caseOrder, lang, dataType);
return(source.Select(expr));
}
/// <summary>Reinitializes the element with a new expression,
/// after the class has already been constructed</summary>
/// <param name="xpathExpression">The expression to evaluate.</param>
protected void InitializeExpression(string xpathExpression)
{
_xpath = xpathExpression;
_expr = Config.DefaultNavigator.Compile(xpathExpression);
_ret = _expr.ReturnType;
if (_ns != null)
{
_expr.SetContext(_ns);
}
}
protected void InitXPathExpression(string strXPathExpr, ref XPathExpression xpe)
{
XPathNavigator navigator = CreateNavigator();
xpe = navigator.Compile(strXPathExpr);
XmlNamespaceManager manager;
GetNamespaceManager(navigator, out manager);
xpe.SetContext(manager);
}
/// <summary>
/// Compile the given filter to run on an external (fx) xpath engine
/// </summary>
internal static OpcodeBlock CompileForExternalEngine(string expression, XmlNamespaceManager namespaces, object item, bool match)
{
// Compile...
XPathExpression xpathExpr = QueryMatcher.fxCompiler.Compile(expression);
// Fx will bind prefixes and functions here.
if (namespaces != null)
{
// There's a bug in System.Xml.XPath. If we pass an XsltContext to SetContext it won't throw if there's
// an undefined prefix.
if (namespaces is XsltContext)
{
// Lex the xpath to find all prefixes used
XPathLexer lexer = new XPathLexer(expression, false);
while (lexer.MoveNext())
{
string prefix = lexer.Token.Prefix;
if (prefix.Length > 0 && namespaces.LookupNamespace(prefix) == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XsltException(SR.GetString(SR.FilterUndefinedPrefix, prefix)));
}
}
}
xpathExpr.SetContext(namespaces);
}
//
// FORCE the function to COMPILE - they won't bind namespaces unless we check the return type
//
if (XPathResultType.Error == xpathExpr.ReturnType)
{
// This should never be reached. The above property should throw if there's an error
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XPathException(SR.GetString(SR.FilterCouldNotCompile, expression)));
}
OpcodeBlock codeBlock = new OpcodeBlock();
SingleFxEngineResultOpcode op;
if (!match)
{
op = new QuerySingleFxEngineResultOpcode();
}
else
{
op = new MatchSingleFxEngineResultOpcode();
}
op.XPath = xpathExpr;
op.Item = item;
codeBlock.Append(op);
return(codeBlock);
}
//=====================================================================
/// <inheritdoc />
public override void Initialize(XPathNavigator configuration)
{
XPathNodeIterator contentNodes = configuration.Select("examples");
foreach (XPathNavigator contentNode in contentNodes)
{
string file = contentNode.GetAttribute("file", String.Empty);
file = Environment.ExpandEnvironmentVariables(file);
if (String.IsNullOrEmpty(file))
{
WriteMessage(MessageLevel.Error, "Each examples element must contain a file attribute.");
}
LoadContent(file);
}
WriteMessage(MessageLevel.Info, "Loaded {0} code snippets", snippets.Count);
XPathNodeIterator colorsNodes = configuration.Select("colors");
foreach (XPathNavigator colorsNode in colorsNodes)
{
string language = colorsNode.GetAttribute("language", String.Empty);
List <ColorizationRule> rules = new List <ColorizationRule>();
XPathNodeIterator colorNodes = colorsNode.Select("color");
foreach (XPathNavigator colorNode in colorNodes)
{
string pattern = colorNode.GetAttribute("pattern", String.Empty);
string region = colorNode.GetAttribute("region", String.Empty);
string name = colorNode.GetAttribute("class", String.Empty);
if (String.IsNullOrEmpty(region))
{
rules.Add(new ColorizationRule(pattern, name));
}
else
{
rules.Add(new ColorizationRule(pattern, region, name));
}
}
colorization[language] = rules;
WriteMessage(MessageLevel.Info, "Loaded {0} colorization rules for the language '{1}'.", rules.Count, language);
}
CustomContext context = new CustomContext();
context.AddNamespace("ddue", "http://ddue.schemas.microsoft.com/authoring/2003/5");
selector = XPathExpression.Compile("//ddue:codeReference");
selector.SetContext(context);
}
public List <Knowledge> Search(string input)
{
List <Knowledge> searchResult = new List <Knowledge>();
var webRoot = _env.WebRootPath;
var schemaSet = new XmlSchemaSet();
var xsdFile = System.IO.Path.Combine(webRoot, "Knowledgebase.xsd");
using (System.IO.FileStream stream = File.OpenRead(xsdFile))
{
schemaSet.Add(XmlSchema.Read(stream, (s, e) =>
{
var x = e.Message;
}));
}
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas = schemaSet;
settings.DtdProcessing = DtdProcessing.Parse;
var file = System.IO.Path.Combine(webRoot, "Knowledgebase.xml");
XmlReader reader = XmlReader.Create(file, settings);
XmlDocument xmlDoc = new XmlDocument()
{
XmlResolver = null
};
xmlDoc.Load(reader);
XPathNavigator nav = xmlDoc.CreateNavigator();
XPathExpression expr = nav.Compile(@"//knowledge[tags[contains(text(),$input)] and sensitivity/text()='Public']");
XsltArgumentList varList = new XsltArgumentList();
varList.AddParam("input", string.Empty, input);
CustomContext context = new CustomContext(new NameTable(), varList);
expr.SetContext(context);
var matchedNodes = nav.Select(expr);
foreach (XPathNavigator node in matchedNodes)
{
searchResult.Add(new Knowledge()
{
Topic = node.SelectSingleNode(nav.Compile("topic")).Value, Description = node.SelectSingleNode(nav.Compile("description")).Value
});
}
return(searchResult);
}
// Select a list of nodes matching a particular XPath expression.
public XmlNodeList SelectNodes(String xpath, XmlNamespaceManager nsmgr)
{
XPathNavigator nav = CreateNavigator();
XPathExpression expr = nav.Compile(xpath);
if (nsmgr != null)
{
expr.SetContext(nsmgr);
}
return(new SelectNodeList(nav.Select(expr)));
}
public XPathExpression GetTargetExpression(XPathNavigator targetDoc, string key)
{
if (target == null)
{
XPathExpression keyedTargetExpression = targetDoc.Compile(string.Format(targetXPath, key));
keyedTargetExpression.SetContext(namespaceMgr);
return(keyedTargetExpression);
}
return(target);
}
/// <summary>
/// Selects a node set using the specified XPath expression.
/// </summary>
public static XPathNodeIterator SelectSorted(string expression, XPathNavigator source,
object sortExpression, IComparer comparer,
XmlPrefix[] prefixes, params XPathVariable[] variables)
{
XPathExpression expr = GetCompiledExpression(expression, source);
XmlNamespaceManager ctx = PrepareContext(source, null, prefixes, variables);
expr.SetContext(ctx);
PrepareSort(expr, source, sortExpression, comparer, ctx);
return(source.Select(expr));
}
internal XPathExpression GetValueQuery(int key)
{
Debug.Assert(key != Compiler.InvalidQueryKey);
Debug.Assert(this.queryStore[key] is TheQuery);
TheQuery theQuery = (TheQuery)this.queryStore[key];
XPathExpression expr = this.queryList[key];
XsltCompileContext context = new XsltCompileContext(theQuery._ScopeManager, this);
expr.SetContext(context);
return(expr);
}
public List <string> CreateKey(XPathNavigator nav,
XmlNamespaceManager nsmgr,
string strXPath)
{
List <string> aKey = new List <string>();
XPathExpression expr = nav.Compile(strXPath);
expr.SetContext(nsmgr);
string keystring = "";
if (expr.ReturnType == XPathResultType.Number)
{
keystring = nav.Evaluate(expr).ToString();//Convert.ToString((int)(nav.Evaluate(expr)));
aKey.Add(keystring);
}
else if (expr.ReturnType == XPathResultType.Boolean)
{
keystring = Convert.ToString((bool)(nav.Evaluate(expr)));
aKey.Add(keystring);
}
else if (expr.ReturnType == XPathResultType.String)
{
keystring = (string)(nav.Evaluate(expr));
aKey.Add(keystring);
}
else if (expr.ReturnType == XPathResultType.NodeSet)
{
XPathNodeIterator iterator = null;
iterator = nav.Select(expr);
if (iterator != null)
{
while (iterator.MoveNext())
{
XPathNavigator navigator = iterator.Current;
keystring = navigator.Value;
if (keystring == "")
{
continue;
}
aKey.Add(keystring);
}
}
}
else
{
throw new Exception("XPathExpression的ReturnType为'" + expr.ReturnType.ToString() + "'无效");
}
return(aKey);
}
