C# IClientChannel类代码示例

		public IAsyncResult BeginDisplayInitializationUI (
			IClientChannel channel,
			AsyncCallback callback,
			object state)
		{
			throw new NotImplementedException ();
		}

 public PokerServer(ICommandBus cmdBus, ITableProjection tableProjection, IPlayerConnectionMap playerConnectionMap, IClientChannel clientChannel)
 {
     _cmdBus = cmdBus;
     _tables = tableProjection;
     _playerConnectionMap = playerConnectionMap;
     _clientChannel = clientChannel;
 }

        /// <summary>
        /// Add token message at header to using NHibernate cache
        /// </summary>
        /// <param name="request"></param>
        /// <param name="channel"></param>
        /// <returns></returns>
        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            // add trace log for debug and performance tuning
            if (null != (request.Headers).MessageId && (request.Headers).MessageId.IsGuid)
            {
                ServiceStopWatch = Stopwatch.StartNew();
                Guid messageId;
                (request.Headers).MessageId.TryGetGuid(out messageId);

                CurrentTraceInfo = new TraceInfo()
                {
                    SessionId = (HttpContext.Current != null && HttpContext.Current.Session != null) ? HttpContext.Current.Session.SessionID : "",
                    TraceType = TraceType.WcfActionClientCall,
                    TraceName = request.Headers.Action,
                    TraceUniqueId = messageId.ToString()
                };

                TraceLogger.Instance.TraceServiceStart(CurrentTraceInfo, true);

                // Add a message header with sessionid
                MessageHeader<string> messageHeader = new MessageHeader<string>(CurrentTraceInfo.SessionId);
                MessageHeader untyped = messageHeader.GetUntypedHeader("sessionid", "ns");
                request.Headers.Add(untyped);
            }
            return null;
        }

 public ConversationViewModel(IClientChannel clientChannel,
                              IForegroundUpdateService foregroundUpdateService,
                              IVoipChannel voipChannel)
 {
     _clientChannel = clientChannel;
     _voipChannel = voipChannel;
     _foregroundUpdateService = foregroundUpdateService;
     foregroundUpdateService.OnRelayMessagesUpdated += OnRelayMessagesUpdated;
     foregroundUpdateService.OnVoipStateUpdate += OnVoipStateUpdate;
     foregroundUpdateService.OnFrameFormatUpdate += OnFrameFormatUpdate;
     foregroundUpdateService.OnFrameRateUpdate += OnFrameRateUpdate;
     SendInstantMessageCommand = new DelegateCommand(OnSendInstantMessageCommandExecute,
         OnSendInstantMessageCommandCanExecute);
     AudioCallCommand = new DelegateCommand(OnCallCommandExecute, OnCallCommandCanExecute);
     VideoCallCommand = new DelegateCommand(OnVideoCallCommandExecute, OnVideoCallCommandCanExecute);
     HangupCommand = new DelegateCommand(OnHangupCommandExecute, OnHangupCommandCanExecute);
     AnswerCommand = new DelegateCommand(OnAnswerCommandExecute, OnAnswerCommandCanExecute);
     RejectCommand = new DelegateCommand(OnRejectCommandExecute, OnRejectCommandCanExecute);
     CloseConversationCommand = new DelegateCommand(OnCloseConversationCommandExecute, () => _canCloseConversation);
     MuteMicrophoneCommand = new DelegateCommand(MuteMicCommandExecute, MicCommandCanExecute);
     UnMuteMicrophoneCommand = new DelegateCommand(UnMuteCommandExecute, MicCommandCanExecute);
     SwitchVideoCommand = new DelegateCommand(SwitchVideoCommandExecute, SwitchVideoCommandCanExecute);
     LayoutService.Instance.LayoutChanged += LayoutChanged;
     LayoutChanged(LayoutService.Instance.LayoutType);
     SetVideoPresenters();
 }

		public object BeforeSendRequest(ref Message request, IClientChannel channel)
		{
			var tokenInjector = ServiceLocator.Current.GetInstance<ISecurityTokenInjector>();

			if (tokenInjector != null)
			{
				object httpRequestMessageObject;

				if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
				{
					var httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;

					if (httpRequestMessage != null)
						tokenInjector.InjectToken(httpRequestMessage.Headers);
				}
				else
				{
					var httpRequestMessage = new HttpRequestMessageProperty();
					tokenInjector.InjectToken(httpRequestMessage.Headers);
					request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
				}
			}

			return null;
		}

 public object BeforeSendRequest(ref Message request, IClientChannel channel)
 {
     MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue);
     request = buffer.CreateMessage();
     Console.WriteLine("Sending:\n{0}", buffer.CreateMessage().ToString());
     return request;
 }

        /// <summary>
        /// Gets a remote host service using the specified channel.
        /// </summary>
        /// <param name="channel">The channel.</param>
        /// <returns>The remote host service.</returns>
        public static IRemoteHostService GetRemoteHostService(IClientChannel channel)
        {
            if (channel == null)
                throw new ArgumentNullException("channel");

            return (IRemoteHostService)channel.GetService(typeof(IRemoteHostService), ServiceName);
        }

        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            if (!request.IsEmpty)
            {
                XmlReader bodyReader = request.GetReaderAtBodyContents().ReadSubtree();

                MemoryStream stream = new MemoryStream();
                XmlWriter writer = XmlWriter.Create(stream);

                if (transform == null)
                {
                    transform = new XslCompiledTransform(true);
                    var reader = XmlReader.Create(new StringReader(Properties.Resources.XmlCleaner));
                    transform.Load(reader);
                }
                transform.Transform(bodyReader, writer);

                stream.Flush();
                stream.Seek(0, SeekOrigin.Begin);

                bodyReader = XmlReader.Create(stream);

                Message changedMessage = Message.CreateMessage(request.Version, null, bodyReader);
                changedMessage.Headers.CopyHeadersFrom(request.Headers);
                changedMessage.Properties.CopyProperties(request.Properties);
                request = changedMessage;
            }

            return null;
        }

        public object AfterReceiveRequest(ref Message request,
		                                  IClientChannel channel,
		                                  InstanceContext instanceContext)
        {
            OperationContext.Current.Extensions.Add(new WorkerContext());
            return request.Headers.MessageId;
        }

        public object AfterReceiveRequest(ref Message request,
               IClientChannel channel,
               InstanceContext instanceContext)
        {
            // Extract Cookie (name=value) from messageproperty
            var messageProperty = (HttpRequestMessageProperty)
                OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name];
            string cookie = messageProperty.Headers.Get("Set-Cookie");
            if (string.IsNullOrWhiteSpace(cookie))
                return null;

            string[] nameValue = cookie.Split('=', ',');
            string userName = string.Empty;

            // Set User Name from cookie
            int pos = nameValue.ToList().IndexOf(".ASPXAUTH");
            if (pos == -1)
                return null;

            userName = nameValue[pos + 1];

            // Set Thread Principal to User Name
            EnterpriseIdentity enterpriseIdentity = new EnterpriseIdentity();
            GenericPrincipal threadCurrentPrincipal =
                   new GenericPrincipal(enterpriseIdentity, new string[] { });
            enterpriseIdentity.IsAuthenticated = true;
            enterpriseIdentity.Name = userName;
            System.Threading.Thread.CurrentPrincipal = threadCurrentPrincipal;

            return null;
        }

        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            var header = MessageHeader.CreateHeader(Constants.ProtocolVersion, Constants.Namespace, Constants.SupportedProtocolVersion);
            request.Headers.Add(header);

            return null;
        }

 public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, IClientChannel channel, InstanceContext instanceContext)
 {
     /* Add request Logging code here
      *  Message contents in request.ToString()
      */
     return null;
 }

 public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
 {
     var logger = ObjectFactory.GetInstance<ILogger>();
     logger.StartAction(request.Headers.To.ToString());
     logger.Write("Incoming Message", request.ToString());
     return null;
 }

 public object BeforeSendRequest(ref Message request, IClientChannel channel)
 {
     object httpRequestMessageObject;
     if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject))
     {
         HttpRequestMessageProperty httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty;
         if (httpRequestMessage != null)
         {
             httpRequestMessage.Headers[SERVICE_KEY_HTTP_HEADER] = (ServiceKey ?? string.Empty);
         }
         else
         {
             httpRequestMessage = new HttpRequestMessageProperty();
             httpRequestMessage.Headers.Add(SERVICE_KEY_HTTP_HEADER, (ServiceKey ?? string.Empty));
             request.Properties[HttpRequestMessageProperty.Name] = httpRequestMessage;
         }
     }
     else
     {
         HttpRequestMessageProperty httpRequestMessage = new HttpRequestMessageProperty();
         httpRequestMessage.Headers.Add(SERVICE_KEY_HTTP_HEADER, (ServiceKey ?? string.Empty));
         request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage);
     }
     return null;
 }

        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            if (!request.IsFault && !request.IsEmpty)
                LogRequest(ref request);

            return null;
        }