## Saxon.Api

Class DocumentBuilder

Class DomDestination

Class DynamicError

Class NullDestination

Class Processor

Class QName

Class SchemaManager

Class SchemaValidator

Class SequenceEnumerator

Class Serializer

Class StaticError

Class TextWriterDestination

Class XPathCompiler

Class XPathExecutable

Class XPathSelector

Class XQueryCompiler

Class XQueryEvaluator

Class XQueryExecutable

Class XdmAtomicValue

Class XdmDestination

Class XdmEmptySequence

Class XdmItem

Class XdmNode

Class XdmValue

Class XmlDestination

Class XsltCompiler

Class XsltExecutable

Class XsltTransformer

Enum RecoveryPolicy

Enum SchemaValidationMode

Enum TreeModel

Enum WhitespacePolicy

Enum XdmAxis

Interface IMessageListener

Interface IQueryResolver

Interface IResultDocumentHandler

Interface IXmlLocation

Interface SchemaResolver

## Saxon.Api
Class XPathSelector

    public class XPathSelector

implements IEnumerable

  An `XPathSelector` represents a compiled and loaded XPath expression ready for execution. The `XPathSelector` holds details of the dynamic evaluation context for the XPath expression.

  An `XPathSelector` should not be used concurrently in multiple threads. It is safe, however, to reuse the object within a single thread to evaluate the same XPath expression several times. Evaluating the expression does not change the context that has been established.

  An `XPathSelector` is always constructed by running the `Load` method of an `XPathExecutable`.

Property Summary
`XdmItem` | `ContextItem` The context item for the XPath expression evaluation.

Method Summary
`void` | `SetVariable(QName , XdmValue )` Set the value of a variable `name` - The name of the variable. This must match the name of a variable that was declared to the XPathCompiler. No error occurs if the expression does not actually reference a variable with this name. `value` - The value to be given to the variable.
`XdmValue` | `Evaluate()` Evaluate the expression, returning the result as an `XdmValue` (that is, a sequence of nodes and/or atomic values).
`XdmItem` | `EvaluateSingle()` Evaluate the XPath expression, returning the result as an `XdmItem` (that is, a single node or atomic value).
`IEnumerator` | `GetEnumerator()` Evaluate the expression, returning the result as an `IEnumerator` (that is, an enumerator over a sequence of nodes and/or atomic values).

Property Detail

### ContextItem

    public XdmItem ContextItem {get; set; }

  The context item for the XPath expression evaluation.

  This may be either a node or an atomic value. Most commonly it will be a document node, which might be constructed using the `Build` method of the `DocumentBuilder` object.

Method Detail

### SetVariable

    public void SetVariable(QName ,
                       XdmValue )

  Set the value of a variable

  `name` -
    The name of the variable. This must match the name of a variable that was declared to the XPathCompiler. No error occurs if the expression does not actually reference a variable with this name.
  `value` -
    The value to be given to the variable.

### Evaluate

    public XdmValue Evaluate()

  Evaluate the expression, returning the result as an `XdmValue` (that is, a sequence of nodes and/or atomic values).

  Although a singleton result may be represented as an `XdmItem`, there is no guarantee that this will always be the case. If you know that the expression will return at most one node or atomic value, it is best to use the `EvaluateSingle` method, which does guarantee that an `XdmItem` (or null) will be returned.

  returns
    An `XdmValue` representing the results of the expression.

### EvaluateSingle

    public XdmItem EvaluateSingle()

  Evaluate the XPath expression, returning the result as an `XdmItem` (that is, a single node or atomic value).

  returns
    An `XdmItem` representing the result of the expression, or null if the expression returns an empty sequence. If the expression returns a sequence of more than one item, any items after the first are ignored.

### GetEnumerator

    public IEnumerator GetEnumerator()

  Evaluate the expression, returning the result as an `IEnumerator` (that is, an enumerator over a sequence of nodes and/or atomic values).

  returns
    An enumerator over the sequence that represents the results of the expression. Each object in this sequence will be an instance of `XdmItem`. Note that the expression may be evaluated lazily, which means that a successful response from this method does not imply that the expression has executed successfully: failures may be reported later while retrieving items from the iterator.