C# Messaging.LogicalCallContext类代码示例

 internal ADAsyncWorkItem(IMessage reqMsg, IMessageSink nextSink, IMessageSink replySink)
 {
     this._reqMsg = reqMsg;
     this._nextSink = nextSink;
     this._replySink = replySink;
     this._callCtx = CallContext.GetLogicalCallContext();
 }

 public void Read(__BinaryParser input)
 {
     this.messageEnum = (MessageEnum) input.ReadInt32();
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.NoReturnValue))
     {
         this.returnValue = null;
     }
     else if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueVoid))
     {
         this.returnValue = instanceOfVoid;
     }
     else if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ReturnValueInline))
     {
         this.returnValue = IOUtil.ReadWithCode(input);
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInline))
     {
         this.scallContext = (string) IOUtil.ReadWithCode(input);
         LogicalCallContext context = new LogicalCallContext {
             RemotingData = { LogicalCallID = this.scallContext }
         };
         this.callContext = context;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInline))
     {
         this.args = IOUtil.ReadArgs(input);
     }
 }

 internal AsyncWorkItem(IMessage reqMsg, IMessageSink replySink, Context oldCtx, ServerIdentity srvID)
 {
     this._reqMsg = reqMsg;
     this._replySink = replySink;
     this._oldCtx = oldCtx;
     this._callCtx = CallContext.GetLogicalCallContext();
     this._srvID = srvID;
 }

 // Sets the given logical call context object on the thread.
 // Returns the previous one.
 internal static LogicalCallContext SetLogicalCallContext(
     LogicalCallContext callCtx)
 {
     ExecutionContext ec = Thread.CurrentThread.GetMutableExecutionContext();
     LogicalCallContext prev = ec.LogicalCallContext;
     ec.LogicalCallContext = callCtx;
     return prev;
 }

	public ReturnMessage(Object ret, Object[] outArgs, int outArgsCount,
						 LogicalCallContext callCtx, IMethodCallMessage mcm)
			{
				this.ret = ret;
				this.outArgs = outArgs;
				this.outArgsCount = outArgsCount;
				this.callCtx = callCtx;
				this.mcm = mcm;
			}

 /// <summary>
 /// Extracts and interprets fields from "IMessage"
 /// 
 /// Samle IMassage when the method "ToString" is called:
 ///     msg.Properties["__Uri"]	
 ///         null	
 ///         object
 ///     msg.Properties["__MethodName"]	
 ///         "ToString"	
 ///         object {string}
 ///     msg.Properties["__MethodSignature"]	
 ///         {System.Type[0]}	
 ///         object {System.Type[]}
 ///     msg.Properties["__TypeName"]	
 ///         "System.Object, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"	
 ///         object {string}
 ///     msg.Properties["__Args"]	
 ///         {object[0]}	
 ///         object {object[]}
 ///     msg.Properties["__CallContext"]	
 ///         {System.Runtime.Remoting.Messaging.LogicalCallContext}	
 ///         object {System.Runtime.Remoting.Messaging.LogicalCallContext}
 ///     Type.GetType((string)msg.Properties["__TypeName"]) == typeof(object)	
 ///         true	
 ///         bool
 /// </summary>
 /// <param name="msg"></param>
 public MessageMethodInvocation(IMessage msg)
     : base(msg.Properties["__TypeName"] as string,
          msg.Properties["__MethodName"] as string,
          msg.Properties["__MethodSignature"] as Type[],
          msg.Properties["__Args"] as object[])
 {
     _message = msg;
     _callContext = _message.Properties["__CallContext"] as LogicalCallContext;
 }

		public ReturnMessage (Exception e, IMethodCallMessage mcm)
		{
			_exception = e;
			
			if (mcm != null) {
				_methodBase = mcm.MethodBase;
				_callCtx = mcm.LogicalCallContext;
			}
			_args = new object[0];	// .NET does this
		}

		private ExecutionContext (ExecutionContext ec)
		{
#if !MOBILE
			if (ec._sc != null)
				_sc = new SecurityContext (ec._sc);
#endif
			if (ec._lcc != null)
				_lcc = (LogicalCallContext) ec._lcc.Clone ();

			_suppressFlow = ec._suppressFlow;
			_capture = true;
		}

	internal MethodResponse(IMethodReturnMessage mrm)
			{
				outArgs = mrm.OutArgs;
				methodName = mrm.MethodName;
				typeName = mrm.TypeName;
				uri = mrm.Uri;
				hasVarArgs = mrm.HasVarArgs;
				context = mrm.LogicalCallContext;
				method = mrm.MethodBase;
				exception = mrm.Exception;
				returnValue = mrm.ReturnValue;
			}

 private ExecutionContext(SerializationInfo info, StreamingContext context)
 {
     SerializationInfoEnumerator enumerator = info.GetEnumerator();
     while (enumerator.MoveNext())
     {
         if (enumerator.Name.Equals("LogicalCallContext"))
         {
             this._logicalCallContext = (System.Runtime.Remoting.Messaging.LogicalCallContext) enumerator.Value;
         }
     }
     this.Thread = System.Threading.Thread.CurrentThread;
 }

 internal MethodMessage(Type interfaceType, string methodName, object[] args, string identity, bool responseRequired)
 {
     this.interfaceType = interfaceType;
     this.methodName = methodName;
     this.args = args;
     this.callContext = GetLogicalCallContext();
     if (responseRequired)
     {
         this.returnValueSignalEvent = new ManualResetEvent(false);
     }
     this.PopulateIdentity(this.callContext, identity);
     this.Clone();
 }

		public ReturnMessage (object ret, object [] outArgs,
			       int outArgsCount, LogicalCallContext callCtx,
			       IMethodCallMessage mcm)
		{
			// outArgCount tells how many values of outArgs are valid

			_returnValue = ret;
			_args = outArgs;
			_callCtx = callCtx;
			if (mcm != null) {
				_uri = mcm.Uri;
				_methodBase = mcm.MethodBase;
			}
			if (_args == null) _args = new object [outArgsCount];
		}

 internal void Read(__BinaryParser input)
 {
     this.messageEnum = (MessageEnum) input.ReadInt32();
     this.methodName = (string) IOUtil.ReadWithCode(input);
     this.typeName = (string) IOUtil.ReadWithCode(input);
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ContextInline))
     {
         this.scallContext = (string) IOUtil.ReadWithCode(input);
         LogicalCallContext context = new LogicalCallContext {
             RemotingData = { LogicalCallID = this.scallContext }
         };
         this.callContext = context;
     }
     if (IOUtil.FlagTest(this.messageEnum, MessageEnum.ArgsInline))
     {
         this.args = IOUtil.ReadArgs(input);
     }
 }

 private void SerializeContextElements(CdrOutputStream targetStream,
                                       LogicalCallContext callContext,
                                       Serializer contextElementSer) {
     // if no context elements specified, don't serialise a context sequence.
     if (m_contextElementKeys.Length > 0) {
         string[] contextSeq = new string[m_contextElementKeys.Length * 2];
         for (int i = 0; i < m_contextElementKeys.Length; i++) {
             string contextKey =
                 m_contextElementKeys[i];
             contextSeq[i * 2] = contextKey;
             if (callContext.GetData(contextKey) != null) {
                 contextSeq[i * 2 + 1] = callContext.GetData(contextKey).ToString();
             } else {
                 contextSeq[i * 2 + 1] = "";
             }
         }
         contextElementSer.Serialize(contextSeq, targetStream);
     }
 }

        internal BinaryMethodCallMessage(String uri, String methodName, String typeName, Object[] args, Object methodSignature, LogicalCallContext callContext, Object[] properties)
        {
            _methodName = methodName;
            _typeName = typeName;
            //_uri = uri;
            if (args == null)
                args = new Object[0];

            _inargs = args;
            _args = args;
            _methodSignature = methodSignature;
            if (callContext == null)
                _logicalCallContext = new LogicalCallContext();
            else
                _logicalCallContext = callContext;

            _properties = properties;

        }