C# Dispatcher.ProcessingContext类代码示例

 internal override Opcode Eval(ProcessingContext context)
 {
     if (!context.LoadVariable(this.expr.Variable))
     {
         context.PushSequenceFrame();
         NodeSequence seq = context.CreateSequence();
         seq.Add(context.Processor.ContextNode);
         context.PushSequence(seq);
         int counterMarker = context.Processor.CounterMarker;
         try
         {
             this.expr.Eval(context);
         }
         catch (XPathNavigatorException exception)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception.Process(this));
         }
         catch (NavigatorInvalidBodyAccessException exception2)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception2.Process(this));
         }
         context.Processor.CounterMarker = counterMarker;
         context.PopSequenceFrame();
         context.PopSequenceFrame();
         context.LoadVariable(this.expr.Variable);
     }
     return base.next;
 }

 internal static void BooleanLang(ProcessingContext context)
 {
     StackFrame topArg = context.TopArg;
     StackFrame topSequenceArg = context.TopSequenceArg;
     Value[] sequences = context.Sequences;
     while (topSequenceArg.basePtr <= topSequenceArg.endPtr)
     {
         NodeSequence sequence = sequences[topSequenceArg.basePtr++].Sequence;
         for (int i = 0; i < sequence.Count; i++)
         {
             string strA = context.PeekString(topArg.basePtr).ToUpperInvariant();
             QueryNode node = sequence.Items[i].Node;
             long currentPosition = node.Node.CurrentPosition;
             node.Node.CurrentPosition = node.Position;
             string strB = node.Node.XmlLang.ToUpperInvariant();
             node.Node.CurrentPosition = currentPosition;
             if ((strA.Length == strB.Length) && (string.CompareOrdinal(strA, strB) == 0))
             {
                 context.SetValue(context, topArg.basePtr++, true);
             }
             else if (((strB.Length > 0) && (strA.Length < strB.Length)) && (strB.StartsWith(strA, StringComparison.Ordinal) && (strB[strA.Length] == '-')))
             {
                 context.SetValue(context, topArg.basePtr++, true);
             }
             else
             {
                 context.SetValue(context, topArg.basePtr++, false);
             }
         }
         topSequenceArg.basePtr++;
     }
 }

 internal override void InvokeInternal(ProcessingContext context, int argCount)
 {
     context.PushFrame();
     int iterationCount = context.IterationCount;
     if (iterationCount > 0)
     {
         string messageId = context.Processor.MessageId;
         if (messageId == null)
         {
             Message contextMessage = context.Processor.ContextMessage;
             if (contextMessage == null)
             {
                 SeekableXPathNavigator contextNode = context.Processor.ContextNode;
                 long currentPosition = contextNode.CurrentPosition;
                 messageId = ExtractFromNavigator(contextNode);
                 contextNode.CurrentPosition = currentPosition;
             }
             else
             {
                 UniqueId id = contextMessage.Headers.MessageId;
                 if (id == null)
                 {
                     messageId = string.Empty;
                 }
                 else
                 {
                     messageId = id.ToString();
                 }
             }
             context.Processor.MessageId = messageId;
         }
         context.Push(messageId, iterationCount);
     }
 }

 public SafeNodeSequenceIterator(NodeSequence seq, ProcessingContext context) : base(seq)
 {
     this.context = context;
     this.seq = seq;
     Interlocked.Increment(ref this.seq.refCount);
     this.context.Processor.AddRef();
 }

 internal override void Eval(ProcessingContext context)
 {
     StackFrame[] frameArray = new StackFrame[this.argCount];
     for (int i = 0; i < this.argCount; i++)
     {
         frameArray[i] = context[i];
     }
     StringBuilder builder = new StringBuilder();
     while (frameArray[0].basePtr <= frameArray[0].endPtr)
     {
         builder.Length = 0;
         for (int k = 0; k < this.argCount; k++)
         {
             builder.Append(context.PeekString(frameArray[k].basePtr));
         }
         context.SetValue(context, frameArray[this.argCount - 1].basePtr, builder.ToString());
         for (int m = 0; m < this.argCount; m++)
         {
             frameArray[m].basePtr++;
         }
     }
     for (int j = 0; j < (this.argCount - 1); j++)
     {
         context.PopFrame();
     }
 }

 internal override void InvokeInternal(ProcessingContext context, int argCount)
 {
     StackFrame topArg = context.TopArg;
     SeekableXPathNavigator contextNode = context.Processor.ContextNode;
     long currentPosition = contextNode.CurrentPosition;
     while (topArg.basePtr <= topArg.endPtr)
     {
         string str = context.PeekString(topArg.basePtr);
         NodeSequence val = context.CreateSequence();
         if (XPathMessageFunction.MoveToHeader(contextNode) && contextNode.MoveToFirstChild())
         {
             do
             {
                 long num2 = contextNode.CurrentPosition;
                 string str2 = XPathMessageFunctionActor.ExtractFromNavigator(contextNode);
                 contextNode.CurrentPosition = num2;
                 if (str2 == str)
                 {
                     val.Add(contextNode);
                 }
             }
             while (contextNode.MoveToNext());
         }
         context.SetValue(context, topArg.basePtr, val);
         topArg.basePtr++;
     }
     contextNode.CurrentPosition = currentPosition;
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     StackFrame topSequenceArg = context.TopSequenceArg;
     Value[] sequences = context.Sequences;
     bool sequenceStackInUse = context.SequenceStackInUse;
     context.PushSequenceFrame();
     for (int i = topSequenceArg.basePtr; i <= topSequenceArg.endPtr; i++)
     {
         NodeSequence sequence = sequences[i].Sequence;
         if (sequence.Count == 0)
         {
             if (!sequenceStackInUse)
             {
                 context.PushSequence(NodeSequence.Empty);
             }
         }
         else
         {
             NodeSequenceItem[] items = sequence.Items;
             for (int j = 0; j < sequence.Count; j++)
             {
                 SeekableXPathNavigator contextNode = items[j].GetNavigator();
                 NodeSequence destSequence = context.CreateSequence();
                 destSequence.StartNodeset();
                 base.criteria.Select(contextNode, destSequence);
                 destSequence.StopNodeset();
                 context.PushSequence(destSequence);
             }
         }
     }
     return base.next;
 }

 internal override Opcode Eval(ProcessingContext context)
 {
     StackFrame topArg = context.TopArg;
     bool flag = false;
     if (1 == topArg.Count)
     {
         flag = context.Values[topArg.basePtr].ToBoolean();
     }
     else
     {
         context.Processor.Result = false;
         for (int i = topArg.basePtr; i <= topArg.endPtr; i++)
         {
             if (context.Values[i].ToBoolean())
             {
                 flag = true;
                 break;
             }
         }
     }
     if (flag)
     {
         ICollection<MessageFilter> matchSet = context.Processor.MatchSet;
         int num2 = 0;
         int count = this.results.Count;
         while (num2 < count)
         {
             matchSet.Add((MessageFilter) this.results[num2]);
             num2++;
         }
     }
     context.PopFrame();
     return base.next;
 }

        internal override Opcode Eval(ProcessingContext context)
        {
            XPathResult result;
            StackFrame topArg = context.TopArg;
            switch (context.Values[topArg.basePtr].Type)
            {
                case ValueDataType.Boolean:
                    result = new XPathResult(context.Values[topArg.basePtr].GetBoolean());
                    break;

                case ValueDataType.Double:
                    result = new XPathResult(context.Values[topArg.basePtr].GetDouble());
                    break;

                case ValueDataType.Sequence:
                {
                    SafeNodeSequenceIterator nodeSetResult = new SafeNodeSequenceIterator(context.Values[topArg.basePtr].GetSequence(), context);
                    result = new XPathResult(nodeSetResult);
                    break;
                }
                case ValueDataType.String:
                    result = new XPathResult(context.Values[topArg.basePtr].GetString());
                    break;

                default:
                    throw Fx.AssertAndThrow("Unexpected result type.");
            }
            context.Processor.QueryResult = result;
            context.PopFrame();
            return base.next;
        }

 internal override void InvokeInternal(ProcessingContext context, int argCount)
 {
     context.PushFrame();
     int iterationCount = context.IterationCount;
     if (iterationCount > 0)
     {
         string toHeader = context.Processor.ToHeader;
         if (toHeader == null)
         {
             Message contextMessage = context.Processor.ContextMessage;
             if (contextMessage == null)
             {
                 SeekableXPathNavigator contextNode = context.Processor.ContextNode;
                 long currentPosition = contextNode.CurrentPosition;
                 toHeader = ExtractFromNavigator(contextNode);
                 contextNode.CurrentPosition = currentPosition;
             }
             else
             {
                 Uri to = contextMessage.Headers.To;
                 if (to == null)
                 {
                     toHeader = contextMessage.Version.Addressing.Anonymous;
                 }
                 else
                 {
                     toHeader = to.AbsoluteUri;
                 }
             }
             context.Processor.ToHeader = toHeader;
         }
         context.Push(toHeader, iterationCount);
     }
 }

 internal override void InvokeInternal(ProcessingContext context, int argCount)
 {
     int iterationCount = context.IterationCount;
     context.PushSequenceFrame();
     if (iterationCount > 0)
     {
         NodeSequence seq = context.CreateSequence();
         seq.StartNodeset();
         SeekableXPathNavigator contextNode = context.Processor.ContextNode;
         long currentPosition = contextNode.CurrentPosition;
         if (XPathMessageFunction.MoveToAddressingHeader(contextNode, "RelatesTo"))
         {
             seq.Add(contextNode);
             while (XPathMessageFunction.MoveToAddressingHeaderSibling(contextNode, "RelatesTo"))
             {
                 seq.Add(contextNode);
             }
         }
         seq.StopNodeset();
         context.PushSequence(seq);
         for (int i = 1; i < iterationCount; i++)
         {
             seq.refCount++;
             context.PushSequence(seq);
         }
         contextNode.CurrentPosition = currentPosition;
     }
 }

 internal override void InvokeInternal(ProcessingContext context, int argCount)
 {
     context.PushFrame();
     int iterationCount = context.IterationCount;
     if (iterationCount > 0)
     {
         string soapUri = context.Processor.SoapUri;
         if (soapUri == null)
         {
             Message contextMessage = context.Processor.ContextMessage;
             if (contextMessage == null)
             {
                 SeekableXPathNavigator contextNode = context.Processor.ContextNode;
                 long currentPosition = contextNode.CurrentPosition;
                 soapUri = ExtractFromNavigator(contextNode);
                 contextNode.CurrentPosition = currentPosition;
             }
             else
             {
                 soapUri = contextMessage.Version.Envelope.Namespace;
             }
             context.Processor.SoapUri = soapUri;
         }
         context.Push(soapUri, iterationCount);
     }
 }

        internal override Opcode Eval(ProcessingContext context)
        {
            XPathResult result;
            StackFrame topArg = context.TopArg;
            switch (context.Values[topArg.basePtr].Type)
            {
                case ValueDataType.Boolean:
                    result = new XPathResult(context.Values[topArg.basePtr].GetBoolean());
                    break;

                case ValueDataType.Double:
                    result = new XPathResult(context.Values[topArg.basePtr].GetDouble());
                    break;

                case ValueDataType.Sequence:
                {
                    SafeNodeSequenceIterator nodeSetResult = new SafeNodeSequenceIterator(context.Values[topArg.basePtr].GetSequence(), context);
                    result = new XPathResult(nodeSetResult);
                    break;
                }
                case ValueDataType.String:
                    result = new XPathResult(context.Values[topArg.basePtr].GetString());
                    break;

                default:
                    throw Fx.AssertAndThrow("Unexpected result type.");
            }
            context.Processor.ResultSet.Add(new KeyValuePair<MessageQuery, XPathResult>((MessageQuery) this.results[0], result));
            for (int i = 1; i < this.results.Count; i++)
            {
                context.Processor.ResultSet.Add(new KeyValuePair<MessageQuery, XPathResult>((MessageQuery) this.results[i], result.Copy()));
            }
            context.PopFrame();
            return base.next;
        }

 internal override Opcode Eval(ProcessingContext context)
 {
     if (!context.LoadVariable(base.expr.Variable))
     {
         base.expr.Eval(context);
     }
     return base.next;
 }

 internal static void BooleanNot(ProcessingContext context)
 {
     StackFrame topArg = context.TopArg;
     Value[] values = context.Values;
     while (topArg.basePtr <= topArg.endPtr)
     {
         values[topArg.basePtr++].Not();
     }
 }