internal void Add(IChannelSender sender)
 {
     if (!this._senders.Contains(sender))
         lock (this._senders)
             if (!this._senders.Contains(sender))
                 this._senders.Add(sender);
 }

 private IClientChannel GetChannel(IChannelSender sender)
 {
     var channel = sender as IClientChannel;
     if (channel.OnMessage == null)
         channel.OnMessage = this._onMessage;
     return channel;
 }

 public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
 {
     IClientChannelSink nextSink = null;
     if (nextProvider != null)
         nextSink = nextProvider.CreateSink(channel, url, remoteChannelData);
     return new ClientChannelImpersonationSink(nextSink, username, password);
 }

 public ClientSinkData(SinkProviderData configurationData, IChannelSender channel, string url, object remoteChannelData)
 {
     this.Channel = channel;
     this.Url = url;
     this.RemoteChannelData = remoteChannelData;
     this.ConfigurationData = configurationData;
 }

        void Transmit(IChannelSender channelSender, Site targetSite, CallType callType, IDictionary<string,string> headers, Stream data)
        {
            headers[HeaderMapper.NServiceBus + HeaderMapper.CallType] = Enum.GetName(typeof(CallType), callType);
            headers[HttpHeaders.ContentMd5Key] = Hasher.Hash(data);

            Logger.DebugFormat("Sending message - {0} to: {1}", callType, targetSite.Address);

            channelSender.Send(targetSite.Address, headers, data);
        }

        private Sender m_Sender; // channel

        #endregion Fields

        #region Constructors

        public MSMQClientTransportSink(IChannelSender channel, string url)
        {
            // state
            m_Sender = channel as Sender;		// parent
            m_LogicalUri = url;					// url address trimed by channel name

            // echo
            Trace.WriteLine(string.Format("[{0}]MSMQClientTransportSink has been contructed", m_Sender.ChannelName));
        }

		public IClientChannelSink CreateSink( IChannelSender channel, 
		                                             string url, 
		                                             object remoteChannelData)
		{
			IClientChannelSink _nextSink = _nextClientChannelSinkProvider.CreateSink(channel, url, remoteChannelData);
			
			SoapClientFormatterSink scfs = new SoapClientFormatterSink(_nextSink); 
			scfs.SoapCore = _soapCore;
			return scfs;
		}

 public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
 {
     if (this.Next != null)
     {
         var nextChannelSink = Next.CreateSink(channel, url, remoteChannelData);
         if (nextChannelSink != null)
             return new JsonClientFormatterSink(nextChannelSink);
     }
     return null;
 }

        public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
        {
            IClientChannelSink nextSink = null;

            if (_nextProvider != null)
                // создаем следующий приемник в цепи
                nextSink = _nextProvider.CreateSink(channel, url, remoteChannelData);

            // добавляем наш приемник в цепь
            return new IpFixClientChannelSink(nextSink, _serverHostNameOrIp);
        }

		/// <summary>
		/// Creates a sink chain.
		/// </summary>
		public IClientChannelSink CreateSink (IChannelSender channel, string url, object remoteChannelData) {
			// Create next sink:
			IClientChannelSink nextSink = next.CreateSink(channel,url,remoteChannelData);
			// Return current sink chained to next sink:
			IMessageSink nextMessageSink = nextSink as IMessageSink;
			if (nextMessageSink != null) {
				return new RemotingMockingSink(nextMessageSink);
			} else {
				throw new RemotingException(String.Format("Remoting configuration error : the '{0}' provider should be defined as provider in the clientProviders section of the channel, before any formatter.", this.GetType()));
			}
		}

        void Transmit(IChannelSender channelSender, Site targetSite, CallType callType,
            IDictionary<string, string> headers, Stream data)
        {
            headers[GatewayHeaders.IsGatewayMessage] = Boolean.TrueString;
            headers["NServiceBus.CallType"] = Enum.GetName(typeof(CallType), callType);
            headers[HttpHeaders.ContentMD5] = Hasher.Hash(data);

            Logger.DebugFormat("Sending message - {0} to: {1}", callType, targetSite.Channel.Address);

            channelSender.Send(targetSite.Channel.Address, headers, data);
        }

 public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
 {
     TcpClientTransportSink sink = new TcpClientTransportSink(url, (TcpClientChannel) channel);
     if (this._prop != null)
     {
         foreach (object obj2 in this._prop.Keys)
         {
             sink[obj2] = this._prop[obj2];
         }
     }
     return sink;
 }

        public IClientChannelSink CreateSink(IChannelSender channel, String url, Object remoteChannelData)
        {
            IClientChannelSink nextSink = null;
            if (_next != null)
            {
                nextSink = _next.CreateSink(channel, url, remoteChannelData);
                if (nextSink == null)
                    return null;
            }

            return new ClientChannelSink(url, nextSink);
        }

 internal IDictionary<string, object> SendAndWait(EndpointProxy e
     , IChannelSender sender
     , Message message
     , int timeout)
 {
     SendCallback callback = new SendCallback(e);
     this.Send(message, sender, callback);
     callback.WaitReturn(timeout);
     if (callback.Error != null)
         throw callback.Error;
     return callback.Return;
 }

        public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
        {
            // create the Message Sink
            IClientChannelSink sink = new MSMQClientTransportSink(channel, url);

            // echo
            Trace.WriteLine(string.Format("[{0}]MSMQClientProvider.CreateSink has been initiated. url={1}",
                channel.ChannelName, url));

            // successful result
            return sink;
        }

 public void Send(Message message, IChannelSender sender, SendCallback callback)
 {
     if (callback != null)
     {
         message.Flag = System.Threading.Interlocked.Increment(ref this._flag);
         this._callbacks.Add(message.Flag, callback);
     }
     using (var s = new MemoryStream())
     {
         MessageIO.WriteMessage(s, message);
         this.GetChannel(sender).Send(s.ToArray());
     }
 }

		public IClientChannelSink CreateSink(
			IChannelSender channel_in,
			string url_in,
			object remoteChannelData_in
		) {
			IClientChannelSink _next = next_.CreateSink(
				channel_in,
				url_in,
				remoteChannelData_in
			);

			return new CompressionClientSink(_next);
		} 

        public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
        {
            IClientChannelSink nextSink = null;

            if (_next != null) {
                // Call CreateSink on the next sink provier in the chain.  This will return
                // to us the actual next sink object.  If the next sink is null, uh oh!
                if ((nextSink = _next.CreateSink(channel, url, remoteChannelData)) == null) return null;
            }

            // Create this sink, passing to it the previous sink in the chain so that it knows
            // to whom messages should be passed.
            return new CompressedClientChannelSink(nextSink);
        }

 // public methods
 /// <summary>
 /// 
 /// </summary>
 /// <param name="channel"></param>
 /// <param name="url"></param>
 /// <param name="remoteChannelData"></param>
 /// <returns></returns>
 public IClientChannelSink CreateSink(
   IChannelSender channel,
   string url,
   object remoteChannelData)
 {
     IClientChannelSink ccs = null;
     if (m_next != null)
     {
         ccs = m_next.CreateSink(channel, url, remoteChannelData);
         if (ccs == null)
             return null;
     }
     return new XmlRpcClientFormatterSink(ccs);
 }

 public IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData)
 {
     IClientChannelSink nextSink = null;
     if (this._next != null)
     {
         nextSink = this._next.CreateSink(channel, url, remoteChannelData);
         if (nextSink == null)
         {
             return null;
         }
     }
     SinkChannelProtocol protocol = CoreChannel.DetermineChannelProtocol(channel);
     return new SoapClientFormatterSink(nextSink) { IncludeVersioning = this._includeVersioning, StrictBinding = this._strictBinding, ChannelProtocol = protocol };
 }