예제 #1
0
            /// <summary>
            /// Creates the <see cref="NullClientChannelSink"/>.
            /// </summary>
            /// <param name="channel"><see cref="NullChannel"/> instance.</param>
            /// <param name="url">Object url.</param>
            /// <param name="remoteChannelData">Channel-specific data for the remote channel.</param>
            /// <returns><see cref="NullClientChannelSink"/> for the given url.</returns>
            public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
            {
                string objectUrl;
                string channelName = NullChannel.ParseUrl(url, out objectUrl);

                return(new NullClientChannelSink(channelName));
            }
예제 #2
0
        private void ProcessMessage(object waitCallbackState)
        {
            var requestMessage = (NullMessages.RequestMessage)waitCallbackState;

            // replace full url with object url
            var    url = requestMessage.RequestHeaders[CommonTransportKeys.RequestUri].ToString();
            string objectUri;

            NullChannel.ParseUrl(url, out objectUri);
            objectUri = objectUri ?? url;
            requestMessage.RequestHeaders[CommonTransportKeys.RequestUri] = objectUri;
            requestMessage.Message.Properties["__Uri"] = objectUri;

            // add client address property for compatibility
            var callContext = requestMessage.Message.Properties["__CallContext"] as LogicalCallContext;

            callContext.SetData(ClientAddressSink.CallContextSlotName, IPAddress.Loopback);

            IMessage          responseMsg;
            ITransportHeaders responseHeaders;
            Stream            responseStream;

            // create sink stack to process request message
            var stack = new ServerChannelSinkStack();

            stack.Push(this, null);

            // process request message
            ServerProcessing serverProcessing;

            if (NextChannelSink != null)
            {
                // full processing mode, with deserialization
                serverProcessing = NextChannelSink.ProcessMessage(stack, null,
                                                                  requestMessage.RequestHeaders, requestMessage.RequestStream,
                                                                  out responseMsg, out responseHeaders, out responseStream);
            }
            else
            {
                // fast processing mode, bypassing deserialization
                serverProcessing = ChannelServices.DispatchMessage(stack, requestMessage.Message, out responseMsg);
                responseHeaders  = null;
                responseStream   = null;
            }

            // send back the reply
            switch (serverProcessing)
            {
            case ServerProcessing.Complete:
                stack.Pop(this);
                NullMessages.AddResponse(requestMessage, new NullMessages.ResponseMessage
                {
                    Message         = responseMsg,
                    ResponseHeaders = responseHeaders,
                    ResponseStream  = responseStream
                });
                break;

            case ServerProcessing.Async:
                stack.StoreAndDispatch(NextChannelSink, null);
                break;

            case ServerProcessing.OneWay:
                stack.Pop(this);
                break;
            }
        }