## Saxon.Api

Class DocumentBuilder

Class DomDestination

Class DynamicContext

Class DynamicError

Class EmptyEnumerator

Class ExtensionFunctionCall

Class ExtensionFunctionDefinition

Class NullDestination

Class Processor

Class QName

Class SchemaManager

Class SchemaValidator

Class Serializer

Class StaticContext

Class StaticError

Class TextWriterDestination

Class XPathCompiler

Class XPathExecutable

Class XPathSelector

Class XQueryCompiler

Class XQueryEvaluator

Class XQueryExecutable

Class XdmAnyFunctionType

Class XdmAnyItemType

Class XdmAnyNodeType

Class XdmAtomicType

Class XdmAtomicValue

Class XdmDestination

Class XdmEmptySequence

Class XdmFunctionItem

Class XdmItem

Class XdmItemType

Class XdmNode

Class XdmNodeKind

Class XdmSequenceType

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 IXdmEnumerator

Interface IXmlLocation

Interface SchemaResolver

## Saxon.Api
Class Processor

    public class Processor

implements object

  The Processor class serves three purposes: it allows global Saxon configuration options to be set; it acts as a factory for generating XQuery, XPath, and XSLT compilers; and it owns certain shared resources such as the Saxon NamePool and compiled schemas. This is the first object that a Saxon application should create. Once established, a Processor may be used in multiple threads.

Constructor Summary
`Processor()` Create a new Processor. This Processor will have capabilities that depend on the version of the software that has been loaded, and on the features that have been licensed.
`Processor(bool licensedEdition)` Create a Processor.
`Processor(bool licensedEdition, bool loadLocally)` Create a Processor.
`Processor(System.IO.Stream configurationFile)` Create a Processor, based on configuration information supplied in a configuration file.

Property Summary
`string` | `ProductTitle` Get the full name of the Saxon product version implemented by this Processor
`string` | `ProductVersion` Get the Saxon product version number (for example, "9.2.0.2")
`string` | `Edition` Get the Saxon product edition (for example, "EE" for Enterprise Edition)
`bool` | `IsSchemaAware` Indicates whether the Processor is schema-aware. In Saxon 9.2, returns true if using Saxon Enterprise Edition.
`SchemaManager` | `SchemaManager` Gets the SchemaManager for the Processor. Returns null if the Processor is not schema-aware.
`XmlResolver` | `XmlResolver` An XmlResolver, which will be used while compiling and running queries, XPath expressions, and stylesheets, if no other XmlResolver is nominated
`decimal` | `XmlVersion` The XML version used in this `Processor` (for example, this determines what characters are permitted in a name)
`net.sf.saxon.Configuration` | `Implementation` The underlying Configuration object in the Saxon implementation

Method Summary
`DocumentBuilder` | `NewDocumentBuilder()` Create a new `DocumentBuilder`, which may be used to build XDM documents from a variety of sources.
`XQueryCompiler` | `NewXQueryCompiler()` Create a new XQueryCompiler, which may be used to compile XQuery queries.
`XsltCompiler` | `NewXsltCompiler()` Create a new XsltCompiler, which may be used to compile XSLT stylesheets.
`XPathCompiler` | `NewXPathCompiler()` Create a new XPathCompiler, which may be used to compile XPath expressions.
`void` | `RegisterCollection(System.Uri collectionUri, System.Collections.IEnumerable contents)` Register a named collection. A collection is identified by a URI (the collection URI), and its content is represented by an `IEnumerable` that enumerates the contents of the collection. The values delivered by this enumeration are Uri values, which can be mapped to nodes using the registered `XmlResolver`.
`void` | `RegisterExtensionFunction(ExtensionFunctionDefinition function)` Register an extension function with the Processor
`void` | `WriteXdmValue(XdmValue sequence, XmlDestination destination)` Copy an XdmValue to an XmlDestination
`void` | `SetProperty(string name, string value)` Set a configuration property
`String` | `GetProperty(string name)` Get the value of a configuration property

Constructor Detail

### Processor

    public Processor()

  Create a new Processor. This Processor will have capabilities that depend on the version of the software that has been loaded, and on the features that have been licensed.

### Processor

    public Processor(bool licensedEdition)

  Create a Processor.

  Parameters:
  `licensedEdition` -
    Set to true if the Processor is to use a licensed edition of Saxon (that is, Saxon-PE or Saxon-EE). If true, the Processor will attempt to enable the capabilities of the licensed edition of Saxon, according to the version of the software that is loaded, and will verify the license key. If false, the Processor will load a default Configuration that gives restricted capability and does not require a license, regardless of which version of the software is actually being run.

### Processor

    public Processor(bool licensedEdition,
                     bool loadLocally)

  Create a Processor.

  Parameters:
  `licensedEdition` -
    Set to true if the Processor is to use a licensed edition of Saxon (that is, Saxon-PE or Saxon-EE). If true, the Processor will attempt to enable the capabilities of the licensed edition of Saxon, according to the version of the software that is loaded, and will verify the license key. If false, the Processor will load a default Configuration that gives restricted capability and does not require a license, regardless of which version of the software is actually being run.
  `loadLocally` -
    This option has no effect at this release.

### Processor

    public Processor(System.IO.Stream configurationFile)

  Create a Processor, based on configuration information supplied in a configuration file.

  Not fully supported in this release: for experimental use only.

  Parameters:
  `configurationFile` -
    A stream holding the text of the XML configuration file. Details of the file format can be found in the Saxon documentation.

Property Detail

### ProductTitle

    public string ProductTitle {get; }

  Get the full name of the Saxon product version implemented by this Processor

### ProductVersion

    public string ProductVersion {get; }

  Get the Saxon product version number (for example, "9.2.0.2")

### Edition

    public string Edition {get; }

  Get the Saxon product edition (for example, "EE" for Enterprise Edition)

### IsSchemaAware

    public bool IsSchemaAware {get; }

  Indicates whether the Processor is schema-aware. In Saxon 9.2, returns true if using Saxon Enterprise Edition.

  Deprecated since Saxon 9.2; schema-awareness is not directly a property of a Processor any more. Use the Edition property to determine which Saxon edition is in use.

### SchemaManager

    public SchemaManager SchemaManager {get; }

  Gets the SchemaManager for the Processor. Returns null if the Processor is not schema-aware.

### XmlResolver

    public XmlResolver XmlResolver {get; set; }

  An XmlResolver, which will be used while compiling and running queries, XPath expressions, and stylesheets, if no other XmlResolver is nominated

  By default an `XmlUrlResolver` is used. This means that the responsibility for resolving and dereferencing URIs rests with the .NET platform, not with the GNU Classpath.

  When Saxon invokes a user-written `XmlResolver`, the `GetEntity` method may return any of: a `System.IO.Stream`; a `System.IO.TextReader`; or a `java.xml.transform.Source`.

### XmlVersion

    public decimal XmlVersion {get; set; }

  The XML version used in this `Processor` (for example, this determines what characters are permitted in a name)

  The value must be 1.0 or 1.1, as a `decimal`. The default version is currently 1.0, but may change in the future.

### Implementation

    public net.sf.saxon.Configuration Implementation {get; }

  The underlying Configuration object in the Saxon implementation

  This property provides access to internal methods in the Saxon engine that are not specifically exposed in the .NET API. In general these methods should be considered to be less stable than the classes in the Saxon.Api namespace.

  The internal methods follow Java naming conventions rather than .NET conventions.

  Information about the returned object (and the objects it provides access to) is included in the Saxon JavaDoc docmentation, available online.

Method Detail

### NewDocumentBuilder

    public DocumentBuilder NewDocumentBuilder()

  Create a new `DocumentBuilder`, which may be used to build XDM documents from a variety of sources.

  returns
    A new `DocumentBuilder`

### NewXQueryCompiler

    public XQueryCompiler NewXQueryCompiler()

  Create a new XQueryCompiler, which may be used to compile XQuery queries.

  The returned XQueryCompiler retains a live link to the Processor, and may be affected by subsequent changes to the Processor.

  returns
    A new XQueryCompiler

### NewXsltCompiler

    public XsltCompiler NewXsltCompiler()

  Create a new XsltCompiler, which may be used to compile XSLT stylesheets.

  The returned XsltCompiler retains a live link to the Processor, and may be affected by subsequent changes to the Processor.

  returns
    A new XsltCompiler

### NewXPathCompiler

    public XPathCompiler NewXPathCompiler()

  Create a new XPathCompiler, which may be used to compile XPath expressions.

  The returned XPathCompiler retains a live link to the Processor, and may be affected by subsequent changes to the Processor.

  returns
    A new XPathCompiler

### RegisterCollection

    public void RegisterCollection(System.Uri collectionUri,
                              System.Collections.IEnumerable contents)

  Register a named collection. A collection is identified by a URI (the collection URI), and its content is represented by an `IEnumerable` that enumerates the contents of the collection. The values delivered by this enumeration are Uri values, which can be mapped to nodes using the registered `XmlResolver`.

  Collections should be stable: that is, two calls to retrieve the same collection URI should return the same sequence of document URIs. This requirement is imposed by the W3C specifications, but in the case of a user-defined collection it is not enforced by the Saxon product.

  A collection may be "unregistered" by providing null as the value of the contents argument. A collection may be replaced by specifying the URI of an existing collection.

  Collections registered with a processor are available to all queries and stylesheets running under the control of that processor. Collections should not normally be registered while queries and transformations are in progress.

  Parameters:
  `collectionUri` -
    The URI used to identify the collection in a call of the XPath `collection()` function. The default collection is registered by supplying null as the value of this argument (this is the collection returned when the XPath `collection()` function is called with no arguments).
  `contents` -
    An enumerable object that represents the contents of the collection, as a sequence of document URIs. The enumerator returned by this IEnumerable object must return instances of the Uri class.

### RegisterExtensionFunction

    public void RegisterExtensionFunction(ExtensionFunctionDefinition function)

  Register an extension function with the Processor

  Parameters:
  `function` -
    An object that defines the extension function, including its name, arity, arguments types, and a reference to the class that implements the extension function call.

### WriteXdmValue

    public void WriteXdmValue(XdmValue sequence,
                         XmlDestination destination)

  Copy an XdmValue to an XmlDestination

  This method can be used to copy any kind of `XdmValue` to any kind of `XdmDestination`. The supplied `XdmValue` is first converted to an XML document according to the rules of the XSLT/XQuery serialization specification (for example, if the `XdmValue` is a sequence of atomic values, they will be turned in a text node in which the values are converted to strings and separated by single spaces). The resulting document is then written to the supplied `XmlDestination`.

  Parameters:
  `sequence` -
    The value to be written
  `destination` -
    The destination to which the value should be written

### SetProperty

    public void SetProperty(string name,
                       string value)

  Set a configuration property

  This method provides the ability to set named properties of the configuration. The property names are set as strings, whose values can be found in the Java class `net.sf.saxon.FeatureKeys`. The property values are always strings. Properties whose values are other types are not available via this interface: however all properties have an effective equivalent whose value is a string. Note that on/off properties are set using the strings "true" and "false".

  Method added in Saxon 9.1

  Parameters:
  `name` -
    The property name
  `value` -
    The property value

### GetProperty

    public String GetProperty(string name)

  Get the value of a configuration property

  This method provides the ability to get named properties of the configuration. The property names are supplied as strings, whose values can be found in the Java class `net.sf.saxon.FeatureKeys`. The property values are always returned as strings. Properties whose values are other types are returned by converting the value to a string. Note that on/off properties are returned using the strings "true" and "false".

  Method added in Saxon 9.1

  Parameters:
  `name` -
    The property name
  returns
    The property value, as a string; or null if the property is unset.