Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

940 lines
25 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System.Runtime;
using System.Xml;
using System.Xml.XPath;
#if NO
//
// A message is just one more source of Xml data. To filter a message, we create a navigator over it that
// surfaces its contained Xml to the filter engine.
// In M5.1, we navigate messages by first writing them into a message document. This turns the message into an
// Xml DOM. we then get a navigator from the DOM.
// In M5.2, we'll navigate messages without requiring this step.
//
internal class MessageNavigator : GenericSeekableNavigator
{
StringBuilder builder;
int headerCollectionVersion;
bool loaded;
bool navigatesBody;
internal MessageNavigator(MessageNavigator nav)
: base(nav)
{
this.headerCollectionVersion = nav.headerCollectionVersion;
this.loaded = nav.loaded;
this.navigatesBody = nav.navigatesBody;
}
internal MessageNavigator(Message message, bool navigateBody)
: base()
{
this.navigatesBody = navigateBody;
this.Load(message, this.navigatesBody);
}
internal bool IsLoaded
{
get
{
return this.loaded;
}
}
internal bool NavigatesBody
{
get
{
return this.navigatesBody;
}
}
internal override void Clear()
{
base.Clear();
this.loaded = false;
this.navigatesBody = false;
}
public override XPathNavigator Clone()
{
return new MessageNavigator(this);
}
internal MessageNavigator Ensure(Message message, bool navigateBody)
{
// Rebuild the navigator if:
// If this navigator does not navigate on bodies and now we need to (or vice versa)
// Or the header collection changed under us
if (this.navigatesBody != navigateBody || message.Headers.CollectionVersion != this.headerCollectionVersion)
{
this.Load(message, navigateBody);
}
else
{
this.MoveToRoot();
}
return this;
}
// To load a message into a message document, we write the message into a buffer and then let XPathDocument
// load that buffer
internal void Load(Message message, bool navigatesBody)
{
if (null == this.builder)
{
this.builder = new StringBuilder(1024);
}
StringWriter stringWriter = new StringWriter(this.builder);
XmlWriter writer = new XmlTextWriter(stringWriter);
message.WriteMessage(writer, navigatesBody);
writer.Close();
StringReader reader = new StringReader(this.builder.ToString());
XPathDocument messageDoc = new XPathDocument(reader);
reader.Close();
this.builder.Length = 0;
this.Init(messageDoc.CreateNavigator());
this.loaded = true;
this.navigatesBody = navigatesBody;
this.headerCollectionVersion = message.Headers.CollectionVersion;
}
}
#endif
// To prevent XPaths from running forever etc, users can specify limits on:
// the # of nodes a filter or filter table should inspect
//
// This file contains navigators that impose these limits
internal interface INodeCounter
{
int CounterMarker { get; set; }
int MaxCounter { set; }
int ElapsedCount(int marker);
void Increase();
void IncreaseBy(int count);
}
internal class DummyNodeCounter : INodeCounter
{
internal static DummyNodeCounter Dummy = new DummyNodeCounter();
public int CounterMarker
{
get { return 0; }
set { }
}
public int MaxCounter
{
set { }
}
public int ElapsedCount(int marker) { return 0; }
public void Increase() { }
public void IncreaseBy(int count) { }
}
/// <summary>
/// Seekable navigators that wrap other navigators and doesn't exceed node counting limits
/// </summary>
internal class SafeSeekableNavigator : SeekableXPathNavigator, INodeCounter
{
SeekableXPathNavigator navigator;
SafeSeekableNavigator counter;
int nodeCount;
int nodeCountMax;
internal SafeSeekableNavigator(SafeSeekableNavigator nav)
{
this.navigator = (SeekableXPathNavigator)nav.navigator.Clone();
this.counter = nav.counter;
}
internal SafeSeekableNavigator(SeekableXPathNavigator navigator, int nodeCountMax)
{
this.navigator = navigator;
this.counter = this;
this.nodeCount = nodeCountMax;
this.nodeCountMax = nodeCountMax;
}
public override string BaseURI
{
get
{
return this.navigator.BaseURI;
}
}
public int CounterMarker
{
get
{
return this.counter.nodeCount;
}
set
{
this.counter.nodeCount = value;
}
}
public int MaxCounter
{
set
{
this.counter.nodeCountMax = value;
}
}
/// <summary>
/// Setting the current position moves this navigator to the location specified by the given position
/// </summary>
public override long CurrentPosition
{
get
{
return this.navigator.CurrentPosition;
}
set
{
this.navigator.CurrentPosition = value;
}
}
public override bool HasAttributes
{
get
{
return this.navigator.HasAttributes;
}
}
public override bool HasChildren
{
get
{
return this.navigator.HasChildren;
}
}
public override bool IsEmptyElement
{
get
{
return this.navigator.IsEmptyElement;
}
}
public override string LocalName
{
get
{
return this.navigator.LocalName;
}
}
public override string Name
{
get
{
return this.navigator.Name;
}
}
public override string NamespaceURI
{
get
{
return this.navigator.NamespaceURI;
}
}
public override XmlNameTable NameTable
{
get
{
return this.navigator.NameTable;
}
}
public override XPathNodeType NodeType
{
get
{
return this.navigator.NodeType;
}
}
public override string Prefix
{
get
{
return this.navigator.Prefix;
}
}
public override string Value
{
get
{
return this.navigator.Value;
}
}
public override string XmlLang
{
get
{
return this.navigator.XmlLang;
}
}
public override XPathNavigator Clone()
{
return new SafeSeekableNavigator(this);
}
#if NO
internal SafeNavigator CreateSafeXPathNavigator()
{
return new SafeNavigator(this, this.navigator);
}
#endif
public override XmlNodeOrder ComparePosition(XPathNavigator navigator)
{
if (navigator == null)
{
return XmlNodeOrder.Unknown;
}
SafeSeekableNavigator nav = navigator as SafeSeekableNavigator;
if (nav != null)
{
return this.navigator.ComparePosition(nav.navigator);
}
return XmlNodeOrder.Unknown;
}
public override XmlNodeOrder ComparePosition(long x, long y)
{
return this.navigator.ComparePosition(x, y);
}
public int ElapsedCount(int marker)
{
return marker - this.counter.nodeCount;
}
public override string GetLocalName(long nodePosition)
{
return this.navigator.GetLocalName(nodePosition);
}
public override string GetName(long nodePosition)
{
return this.navigator.GetName(nodePosition);
}
public override string GetNamespace(long nodePosition)
{
return this.navigator.GetNamespace(nodePosition);
}
public override XPathNodeType GetNodeType(long nodePosition)
{
return this.navigator.GetNodeType(nodePosition);
}
public override string GetValue(long nodePosition)
{
return this.navigator.GetValue(nodePosition);
}
public override string GetNamespace(string name)
{
this.IncrementNodeCount();
return this.navigator.GetNamespace(name);
}
public override string GetAttribute(string localName, string namespaceURI)
{
this.IncrementNodeCount();
return this.navigator.GetAttribute(localName, namespaceURI);
}
public void Increase()
{
this.IncrementNodeCount();
}
public void IncreaseBy(int count)
{
this.counter.nodeCount -= (count - 1);
Increase();
}
internal void IncrementNodeCount()
{
if (this.counter.nodeCount > 0)
{
this.counter.nodeCount--;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XPathNavigatorException(SR.GetString(SR.FilterNodeQuotaExceeded, this.counter.nodeCountMax)));
}
}
#if NO
internal virtual void Init(SeekableXPathNavigator navigator, int nodeCountMax)
{
this.navigator = navigator;
this.nodeCount = nodeCountMax;
this.counter = this;
}
#endif
public override bool IsDescendant(XPathNavigator navigator)
{
if (navigator == null)
{
return false;
}
SafeSeekableNavigator nav = navigator as SafeSeekableNavigator;
if (nav != null)
{
return this.navigator.IsDescendant(nav.navigator);
}
return false;
}
public override bool IsSamePosition(XPathNavigator other)
{
if (other == null)
{
return false;
}
SafeSeekableNavigator nav = other as SafeSeekableNavigator;
if (nav != null)
{
return this.navigator.IsSamePosition(nav.navigator);
}
return false;
}
public override void MoveToRoot()
{
this.IncrementNodeCount();
this.navigator.MoveToRoot();
}
public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
{
this.IncrementNodeCount();
return this.navigator.MoveToNextNamespace(namespaceScope);
}
public override bool MoveToNextAttribute()
{
this.IncrementNodeCount();
return this.navigator.MoveToNextAttribute();
}
public override bool MoveToPrevious()
{
this.IncrementNodeCount();
return this.navigator.MoveToPrevious();
}
public override bool MoveToFirstAttribute()
{
this.IncrementNodeCount();
return this.navigator.MoveToFirstAttribute();
}
public override bool MoveToNamespace(string name)
{
this.IncrementNodeCount();
return this.navigator.MoveToNamespace(name);
}
public override bool MoveToParent()
{
this.IncrementNodeCount();
return this.navigator.MoveToParent();
}
public override bool MoveTo(XPathNavigator other)
{
if (other == null)
{
return false;
}
this.IncrementNodeCount();
SafeSeekableNavigator nav = other as SafeSeekableNavigator;
if (nav != null)
{
return this.navigator.MoveTo(nav.navigator);
}
return false;
}
public override bool MoveToId(string id)
{
this.IncrementNodeCount();
return this.navigator.MoveToId(id);
}
public override bool MoveToFirstChild()
{
this.IncrementNodeCount();
return this.navigator.MoveToFirstChild();
}
public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
{
this.IncrementNodeCount();
return this.navigator.MoveToFirstNamespace(namespaceScope);
}
public override bool MoveToAttribute(string localName, string namespaceURI)
{
this.IncrementNodeCount();
return this.navigator.MoveToAttribute(localName, namespaceURI);
}
public override bool MoveToNext()
{
this.IncrementNodeCount();
return this.navigator.MoveToNext();
}
public override bool MoveToFirst()
{
this.IncrementNodeCount();
return this.navigator.MoveToFirst();
}
}
/// <summary>
/// The filter engine works with seekable navigators. This class takes a generic XPathNavigator implementation
/// and transforms it into a seekable navigator. Seekable navigators associate a 'position' to every node in a DOM.
///
/// This class maintains a (position, navigator) map. Cloning navigators is unavoidable - XPathNavigator offers
/// no other way to snapshot its current position. However, caching allows memory allocations to be avoided - but
/// only once the navigator is warmed up.
/// </summary>
internal class GenericSeekableNavigator : SeekableXPathNavigator
{
QueryBuffer<XPathNavigator> nodes;
long currentPosition;
XPathNavigator navigator;
GenericSeekableNavigator dom;
#if NO
internal GenericSeekableNavigator()
{
this.nodes = new QueryBuffer<XPathNavigator>(4);
this.currentPosition = -1;
}
#endif
internal GenericSeekableNavigator(XPathNavigator navigator)
{
this.navigator = navigator;
this.nodes = new QueryBuffer<XPathNavigator>(4);
this.currentPosition = -1;
this.dom = this;
}
internal GenericSeekableNavigator(GenericSeekableNavigator navigator)
{
this.navigator = navigator.navigator.Clone();
this.nodes = default(QueryBuffer<XPathNavigator>);
this.currentPosition = navigator.currentPosition;
this.dom = navigator.dom;
}
public override string BaseURI
{
get
{
return this.navigator.BaseURI;
}
}
public override bool HasAttributes
{
get
{
return this.navigator.HasAttributes;
}
}
public override bool HasChildren
{
get
{
return this.navigator.HasChildren;
}
}
#if NO
internal XPathNavigator InternalNavigator
{
get
{
return this.navigator;
}
}
#endif
public override bool IsEmptyElement
{
get
{
return this.navigator.IsEmptyElement;
}
}
public override string LocalName
{
get
{
return this.navigator.LocalName;
}
}
public override string Name
{
get
{
return this.navigator.Name;
}
}
public override string NamespaceURI
{
get
{
return this.navigator.NamespaceURI;
}
}
public override XmlNameTable NameTable
{
get
{
return this.navigator.NameTable;
}
}
public override XPathNodeType NodeType
{
get
{
return this.navigator.NodeType;
}
}
public override string Prefix
{
get
{
return this.navigator.Prefix;
}
}
public override string Value
{
get
{
return this.navigator.Value;
}
}
public override string XmlLang
{
get
{
return this.navigator.XmlLang;
}
}
/// <summary>
/// Setting the current position moves this navigator to the location specified by the given position
/// </summary>
public override long CurrentPosition
{
get
{
if (-1 == this.currentPosition)
{
this.SnapshotNavigator();
}
return this.currentPosition;
}
set
{
this.navigator.MoveTo(this[value]);
this.currentPosition = value;
}
}
/// <summary>
/// Return the XPathNavigator that has the given position
/// </summary>
internal XPathNavigator this[long nodePosition]
{
get
{
int pos = (int)nodePosition;
Fx.Assert(this.dom.nodes.IsValidIndex(pos) && null != this.dom.nodes[pos], "");
return this.dom.nodes[pos];
}
}
#if NO
internal virtual void Clear()
{
this.navigator = null;
this.currentPosition = -1;
}
#endif
public override XPathNavigator Clone()
{
return new GenericSeekableNavigator(this);
}
public override XmlNodeOrder ComparePosition(XPathNavigator navigator)
{
if (navigator == null)
{
return XmlNodeOrder.Unknown;
}
GenericSeekableNavigator nav = navigator as GenericSeekableNavigator;
if (nav != null)
{
return this.navigator.ComparePosition(nav.navigator);
}
return XmlNodeOrder.Unknown;
}
public override XmlNodeOrder ComparePosition(long x, long y)
{
XPathNavigator nodeX = this[x];
XPathNavigator nodeY = this[y];
return nodeX.ComparePosition(nodeY);
}
public override string GetLocalName(long nodePosition)
{
return this[nodePosition].LocalName;
}
public override string GetName(long nodePosition)
{
return this[nodePosition].Name;
}
public override string GetNamespace(long nodePosition)
{
return this[nodePosition].NamespaceURI;
}
public override XPathNodeType GetNodeType(long nodePosition)
{
return this[nodePosition].NodeType;
}
public override string GetValue(long nodePosition)
{
return this[nodePosition].Value;
}
public override string GetNamespace(string name)
{
return this.navigator.GetNamespace(name);
}
public override string GetAttribute(string localName, string namespaceURI)
{
return this.navigator.GetAttribute(localName, namespaceURI);
}
#if NO
internal void Init(XPathNavigator navigator)
{
Fx.Assert(null != navigator, "");
this.navigator = navigator;
this.currentPosition = -1;
}
#endif
public override bool IsDescendant(XPathNavigator navigator)
{
if (navigator == null)
{
return false;
}
GenericSeekableNavigator nav = navigator as GenericSeekableNavigator;
if (null != nav)
{
return this.navigator.IsDescendant(nav.navigator);
}
return false;
}
public override bool IsSamePosition(XPathNavigator other)
{
GenericSeekableNavigator nav = other as GenericSeekableNavigator;
if (null != nav)
{
return this.navigator.IsSamePosition(nav.navigator);
}
return false;
}
public override void MoveToRoot()
{
this.currentPosition = -1;
this.navigator.MoveToRoot();
}
public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
{
this.currentPosition = -1;
return this.navigator.MoveToNextNamespace(namespaceScope);
}
public override bool MoveToNextAttribute()
{
this.currentPosition = -1;
return this.navigator.MoveToNextAttribute();
}
public override bool MoveToPrevious()
{
this.currentPosition = -1;
return this.navigator.MoveToPrevious();
}
public override bool MoveToFirstAttribute()
{
this.currentPosition = -1;
return this.navigator.MoveToFirstAttribute();
}
public override bool MoveToNamespace(string name)
{
this.currentPosition = -1;
return this.navigator.MoveToNamespace(name);
}
public override bool MoveToParent()
{
this.currentPosition = -1;
return this.navigator.MoveToParent();
}
public override bool MoveTo(XPathNavigator other)
{
GenericSeekableNavigator nav = other as GenericSeekableNavigator;
if (null != nav)
{
if (this.navigator.MoveTo(nav.navigator))
{
this.currentPosition = nav.currentPosition;
return true;
}
}
return false;
}
public override bool MoveToId(string id)
{
this.currentPosition = -1;
return this.navigator.MoveToId(id);
}
public override bool MoveToFirstChild()
{
this.currentPosition = -1;
return this.navigator.MoveToFirstChild();
}
public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
{
this.currentPosition = -1;
return this.navigator.MoveToFirstNamespace(namespaceScope);
}
public override bool MoveToAttribute(string localName, string namespaceURI)
{
this.currentPosition = -1;
return this.navigator.MoveToAttribute(localName, namespaceURI);
}
public override bool MoveToNext()
{
this.currentPosition = -1;
return this.navigator.MoveToNext();
}
public override bool MoveToFirst()
{
this.currentPosition = -1;
return this.navigator.MoveToFirst();
}
internal void SnapshotNavigator()
{
this.currentPosition = this.dom.nodes.Count;
this.dom.nodes.Add(this.navigator.Clone());
/*
if (this.currentPosition < this.nodes.Count)
{
// Use a cached navigator
XPathNavigator clonedNavigator = this.nodes[(int)this.currentPosition];
Fx.Assert(null != clonedNavigator, "");
clonedNavigator.MoveTo(this);
}
else
{
this.nodes.Add(this.navigator.Clone());
}
*/
}
#region IQueryBufferPool Members
#if NO
/// <summary>
/// Reset the pool by deleting it entirely and starting it over
/// </summary>
public void Reset()
{
this.nodes.count = 0;
this.nodes.TrimToCount();
}
public void Trim()
{
this.nodes.TrimToCount();
}
#endif
#endregion
}
}