public SizedTcpReplyChannel(MessageEncoder encoder, BufferManager bufferManager, Uri localAddress, Socket socket, ChannelManagerBase channelManager) : base(encoder, bufferManager, channelManager) { this.localAddress = localAddress; this.socket = socket; this.InitializeSocket(socket); }
protected TransportOutputChannel(ChannelManagerBase channelManager, EndpointAddress to, Uri via, bool manualAddressing, System.ServiceModel.Channels.MessageVersion messageVersion) : base(channelManager) { this.manualAddressing = manualAddressing; this.messageVersion = messageVersion; this.to = to; this.via = via; if (!manualAddressing && (to != null)) { Uri anonymousUri; if (to.IsAnonymous) { anonymousUri = this.messageVersion.Addressing.AnonymousUri; } else if (to.IsNone) { anonymousUri = this.messageVersion.Addressing.NoneUri; } else { anonymousUri = to.Uri; } XmlDictionaryString dictionaryTo = new ToDictionary(anonymousUri.AbsoluteUri).To; this.toHeader = ToHeader.Create(anonymousUri, dictionaryTo, messageVersion.Addressing); this.anyHeadersToAdd = to.Headers.Count > 0; } }
public MockChannelBase(ChannelManagerBase manager, MessageEncoderFactory encoderFactory, EndpointAddress address) : base(manager) { _address = address; _manager = manager; _encoder = encoderFactory.CreateSessionEncoder(); OpenAsyncResult = new MockAsyncResult(); CloseAsyncResult = new MockAsyncResult(); GetEndpointPropertyOverride = DefaultGetEndpointProperty; // CommunicationObject overrides DefaultCloseTimeoutOverride = DefaultDefaultCloseTimeout; DefaultOpenTimeoutOverride = DefaultDefaultOpenTimeout; OnAbortOverride = DefaultOnAbort; OnOpenOverride = DefaultOnOpen; OnCloseOverride = DefaultOnClose; OnBeginOpenOverride = DefaultOnBeginOpen; OnEndOpenOverride = DefaultOnEndOpen; OnBeginCloseOverride = DefaultOnBeginClose; OnEndCloseOverride = DefaultOnEndClose; // All the virtuals OnOpeningOverride = DefaultOnOpening; OnOpenedOverride = DefaultOnOpened; OnClosingOverride = DefaultOnClosing; OnClosedOverride = DefaultOnClosed; OnFaultedOverride = DefaultOnFaulted; }
public MessageBusInputChannel( BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent, EndpointAddress localAddress, IBus bus) : base(bufferManager, encoder, parent) { _localAddress = localAddress; _bus = bus; _aLock = new object(); _tryReceiveDelegate = (TimeSpan timeout, out Message message) => { message = null; try { var requestMessage = _bus.Receive(true, null); if (requestMessage != null) { message = GetWcfMessageFromString(requestMessage.Content); OnAfterTryReceive(requestMessage); } } catch (Exception ex) { throw new CommunicationException(ex.Message, ex); } return true; }; _receiveDelegate = (TimeSpan timeout) => { var requestMessage = _bus.Receive(false, ChannelID); return GetWcfMessageFromString(requestMessage.Content); }; }
public LayeredDuplexChannel(ChannelManagerBase channelManager, IInputChannel innerInputChannel, EndpointAddress localAddress, IOutputChannel innerOutputChannel) : base(channelManager, innerInputChannel) { this.localAddress = localAddress; this.innerOutputChannel = innerOutputChannel; this.onInnerOutputChannelFaulted = new EventHandler(this.OnInnerOutputChannelFaulted); this.innerOutputChannel.Faulted += this.onInnerOutputChannelFaulted; }
public MessageBusReplySessionChannel( BufferManager bufferManager, MessageEncoderFactory encoderFactory, ChannelManagerBase parent, EndpointAddress localAddress, IBus bus) : base(bufferManager, encoderFactory, parent, localAddress, bus) { }
/// <summary> /// SerialChannel Base /// </summary> /// <param name="bufferManager"> /// Buffer manager created by factory and listener</param> /// <param name="encoderFactory"> /// Referece to encoder factory as returned by encoder element</param> /// <param name="address">Remote address</param> /// <param name="portNumber">COM port number</param> /// <param name="parent">reference to factory/listener</param> /// <param name="maxReceivedMessageSize"> /// Some settings for transport channel</param> public SerialChannelBase(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, string portNumber, ChannelManagerBase parent, long maxReceivedMessageSize) : base(parent) { this.address = address; this.bufferManager = bufferManager; this.encoder = encoderFactory.CreateSessionEncoder(); this.maxReceivedMessageSize = maxReceivedMessageSize; this.portNumber = portNumber; // Create port serialPort = new SerialPort(); // Set the appropriate properties. serialPort.PortName = this.portNumber; //TODO: Read these settings from configuration file serialPort.BaudRate = 9600; serialPort.Parity = Parity.None; serialPort.DataBits = 8; serialPort.StopBits = StopBits.One; serialPort.Handshake = Handshake.None; // Set the read/write timeouts serialPort.ReadTimeout = 500; serialPort.WriteTimeout = 500; }
public ProtoBufMetaDataReplyChannel(EndpointAddress address, ChannelManagerBase parent, IReplyChannel innerChannel) : base(parent, innerChannel) { this._localAddress = address; _innerChannel = innerChannel; }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="codec"> /// The channel message coder/decoder /// </param> public Channel( ChannelManagerBase manager, MessageCodec codec) : base(manager) { this.codec = codec; }
public InputChannel(ChannelManagerBase channelManager) : base(channelManager) { var listener = channelManager as InputChannelListener; if (listener == null) throw new ArgumentException("Invalid channel manager.", "channelManager"); this.LocalAddress = new EndpointAddress(listener.Uri); }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="session"> /// The current in-process session /// </param> /// <param name="address"> /// The server communication address /// </param> public Channel( ChannelManagerBase manager, Session session, EndpointAddress address) : base(manager, null, address, address) { this.session = session; }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="codec"> /// The channel message coder/decoder /// </param> /// <param name="localAddress"> /// The address of the local endpoint /// </param> /// <param name="remoteAddress"> /// The address of the remote endpoint /// </param> public DuplexSessionChannel( ChannelManagerBase manager, MessageCodec codec, EndpointAddress localAddress, EndpointAddress remoteAddress) : base(manager, codec, localAddress, remoteAddress) { }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="codec"> /// The channel message coder/decoder /// </param> /// <param name="localAddress"> /// The address of the local endpoint /// </param> public ReplyChannel( ChannelManagerBase manager, MessageCodec codec, EndpointAddress localAddress) : base(manager, codec) { this.localAddress = localAddress; }
public StreamedFramingRequestChannel(ChannelManagerBase factory, IConnectionOrientedTransportChannelFactorySettings settings, EndpointAddress remoteAddresss, Uri via, IConnectionInitiator connectionInitiator, ConnectionPool connectionPool) : base(factory, remoteAddresss, via, settings.ManualAddressing) { this.settings = settings; this.connectionInitiator = connectionInitiator; this.connectionPool = connectionPool; this.messageEncoder = settings.MessageEncoderFactory.Encoder; this.upgrade = settings.Upgrade; }
public OutputChannel(ChannelManagerBase channelManager, IQueue queue, EndpointAddress remoteAddress, Uri via) : base(channelManager) { this.queue = queue; this.RemoteAddress = remoteAddress; this.Via = via; }
protected ZMQReceivingChannelBase(ChannelManagerBase channelManager, BindingContext bindingContext, Context context, Socket socket, SocketMode socketMode) : base(channelManager, bindingContext, socket, socketMode) { _onReceiveHandler = Receive; _onTryReceiveHandler = TryReceive; _onWaitForMessageHandler = WaitForMessage; _context = context; }
public DurableInstanceContextReplyChannel(ChannelManagerBase channelManager, ContextType contextType, IReplyChannel innerChannel) : base(channelManager, innerChannel) { this.contextType = contextType; this.innerReplyChannel = innerChannel; }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="codec"> /// The channel message coder/decoder /// </param> /// <param name="remoteAddress"> /// The address of the remote endpoint /// </param> public OutputChannel( ChannelManagerBase manager, MessageCodec codec, EndpointAddress remoteAddress) : base(manager, codec) { this.remoteAddress = remoteAddress; }
protected MessageBusChannelBase(BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent) : base(parent) { _id = Guid.NewGuid(); _bufferManager = bufferManager; _encoder = encoder.CreateSessionEncoder(); }
public MessageBusRequestSessionChannel( BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent, EndpointAddress remoteAddress, Uri via, IBus bus) : base(bufferManager, encoder, parent, remoteAddress, via, bus) { _session = new MessageBusOutputSession((new UniqueId()).ToString()); }
protected ThreadlessInputChannel( ChannelManagerBase channelManager, IHasBindingElement bindingElement, EndpointAddress localAddress) : base(channelManager, bindingElement) { LocalAddress = localAddress; }
public MockRequestChannel(ChannelManagerBase manager, MessageEncoderFactory encoderFactory, EndpointAddress address, Uri via) : base(manager, encoderFactory, address) { this._via = via; RequestOverride = DefaultRequest; BeginRequestOverride = DefaultBeginRequest; EndRequestOverride = DefaultEndRequest; }
public MessageBusDuplexSessionChannel( BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent, EndpointAddress remoteAddress, Uri via, IBus bus, bool isClient) : base(bufferManager, encoder, remoteAddress, parent, via, bus, isClient) { _session = new MessageBusDuplexSession((new UniqueId()).ToString()); }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="codec"> /// The channel message coder/decoder /// </param> /// <param name="remoteAddress"> /// The output address /// </param> /// <param name="socket"> /// The UDP channel socket /// </param> public OutputChannel( ChannelManagerBase manager, MessageCodec codec, EndpointAddress remoteAddress, UdpSocket socket) : base(manager, codec, remoteAddress) { this.socket = socket; }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="codec"> /// The channel message coder/decoder /// </param> /// <param name="localAddress"> /// The input address /// </param> /// <param name="socket"> /// The datagram socket for this channel /// </param> public ReplyChannel( ChannelManagerBase manager, MessageCodec codec, EndpointAddress localAddress, UdpSocket socket) : base(manager, codec, localAddress) { this.socket = socket; }
public FileChannelBase(BufferManager bufferManager, MessageEncoderFactory encoderFactory, EndpointAddress address, ChannelManagerBase parent, long maxReceivedMessageSize) : base(parent) { this.address = address; this.bufferManager = bufferManager; this.encoder = encoderFactory.CreateSessionEncoder(); this.maxReceivedMessageSize = maxReceivedMessageSize; }
public DurableInstanceContextReplySessionChannel(ChannelManagerBase channelManager, ContextType contextType, IReplySessionChannel innerChannel) : base(channelManager, innerChannel) { this.contextType = contextType; this.innerReplySessionChannel = innerChannel; this.isFirstMessage = true; this.stateLock = new object(); }
protected ThreadlessOutputChannel( ChannelManagerBase channelManager, IHasBindingElement bindingElement, EndpointAddress remoteAddress, Uri via) : base(channelManager, bindingElement) { RemoteAddress = remoteAddress; Via = via; }
/// <summary> /// Initializes a new channel instance /// </summary> /// <param name="manager"> /// Containing channel listener/factory /// </param> /// <param name="codec"> /// The channel message coder/decoder /// </param> /// <param name="localAddress"> /// The address of the local endpoint /// </param> /// <param name="remoteAddress"> /// The address of the remote endpoint /// </param> public DuplexChannel( ChannelManagerBase manager, MessageCodec codec, EndpointAddress localAddress, EndpointAddress remoteAddress) : base(manager, codec) { this.localAddress = localAddress; this.remoteAddress = remoteAddress; }
public MessageBusOutputChannel( BufferManager bufferManager, MessageEncoderFactory encoder, ChannelManagerBase parent, EndpointAddress remoteAddress, Uri via, IBus bus) : base(bufferManager, encoder, parent) { _bus = bus; _via = via; _remoteAddress = remoteAddress; }
protected ContextInputChannelBase(ChannelManagerBase channelManager, TChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism) : base(channelManager, innerChannel) { this.contextExchangeMechanism = contextExchangeMechanism; this.contextProtocol = new ServiceContextProtocol(contextExchangeMechanism); }
protected DuplexChannel(ChannelManagerBase channelManager, EndpointAddress localAddress) : base(channelManager) { LocalAddress = localAddress; }
public ReplySessionChannelWrapper(ChannelManagerBase channelManager, IReplySessionChannel innerChannel, RequestContext firstRequest) : base(channelManager, innerChannel, firstRequest) { }
protected ContextRequestChannelBase(ChannelManagerBase channelManager, TChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism, Uri callbackAddress, bool contextManagementEnabled) : base(channelManager, innerChannel) { this.contextProtocol = new ClientContextProtocol(contextExchangeMechanism, innerChannel.Via, this, callbackAddress, contextManagementEnabled); }
protected OutputChannel(ChannelManagerBase manager) : base(manager) { }
public TransportReplyChannel(ChannelManagerBase channelManager, EndpointAddress localAddress) : base(channelManager, localAddress) { }
public SecurityOutputSessionChannel(ChannelManagerBase factory, SecurityProtocolFactory securityProtocolFactory, IOutputSessionChannel innerChannel, EndpointAddress to, Uri via) : base(factory, securityProtocolFactory, (IOutputChannel)innerChannel, to, via) { }
public ContextOutputChannel(ChannelManagerBase channelManager, IOutputChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism, Uri callbackAddress, bool contextManagementEnabled) : base(channelManager, innerChannel) { this.contextProtocol = new ClientContextProtocol(contextExchangeMechanism, base.InnerChannel.Via, this, callbackAddress, contextManagementEnabled); }
public ContextRequestChannel(ChannelManagerBase channelManager, IRequestChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism, Uri callbackAddress, bool contextManagementEnabled) : base(channelManager, innerChannel, contextExchangeMechanism, callbackAddress, contextManagementEnabled) { }
public LayeredInputChannel(ChannelManagerBase channelManager, IInputChannel innerChannel) : base(channelManager, innerChannel) { }
public SingletonChannelAcceptor(ChannelManagerBase channelManager) : base(channelManager) { }
public DuplexSessionOneWayInputChannel(ChannelManagerBase channelManager, EndpointAddress localAddress) : base(channelManager, localAddress) { }
protected LayeredChannel(ChannelManagerBase channelManager, TInnerChannel innerChannel) : base(channelManager) { this.innerChannel = innerChannel; this.onInnerChannelFaulted = new EventHandler(this.OnInnerChannelFaulted); this.innerChannel.Faulted += this.onInnerChannelFaulted; }
protected LayeredChannelAcceptor(ChannelManagerBase channelManager, IChannelListener <TInnerChannel> innerListener) : base(channelManager) { this.innerListener = innerListener; }
private FramingDuplexSessionChannel(ChannelManagerBase manager, IConnectionOrientedTransportFactorySettings settings, EndpointAddress localAddress, Uri localVia, EndpointAddress remoteAddresss, Uri via, bool exposeConnectionProperty) : base(manager, settings, localAddress, localVia, remoteAddresss, via) { _exposeConnectionProperty = exposeConnectionProperty; }
public PeerOutputChannel(PeerNodeImplementation peerNode, PeerNodeImplementation.Registration registration, ChannelManagerBase channelManager, EndpointAddress localAddress, Uri via, MessageVersion messageVersion) : base(channelManager, localAddress, via, false, messageVersion) { PeerNodeImplementation.ValidateVia(via); if (registration != null) { peerNode = PeerNodeImplementation.Get(via, registration); } this.peerNode = new PeerNode(peerNode); this.via = via; this.channelManager = channelManager; this.to = localAddress; }
public InputChannel(ChannelManagerBase channelManager, EndpointAddress localAddress) : base(channelManager) { this.localAddress = localAddress; }
protected ChannelBase(ChannelManagerBase manager) { this.manager = manager; }
public ServerUdpOutputChannel(ChannelManagerBase factory, MessageEncoder encoder, BufferManager bufferManager, UdpSocket[] sendSockets, UdpRetransmissionSettings retransmissionSettings, Uri via, bool isMulticast) : base(factory, encoder, bufferManager, sendSockets, retransmissionSettings, via, isMulticast) { }
public ReplyOverDuplexChannel(ChannelManagerBase channelManager, IDuplexChannel innerChannel) : base(channelManager, innerChannel) { }
public PeerDuplexChannelAcceptor(PeerNodeImplementation peerNode, PeerNodeImplementation.Registration registration, ChannelManagerBase channelManager, EndpointAddress localAddress, Uri via) : base(channelManager) { this.registration = registration; this.peerNode = peerNode; this.localAddress = localAddress; this.via = via; PeerMessageDispatcher <IDuplexChannel, PeerDuplexChannel> .PeerMessageQueueAdapter queueHandler = new PeerMessageDispatcher <IDuplexChannel, PeerDuplexChannel> .PeerMessageQueueAdapter(this); this.dispatcher = new PeerMessageDispatcher <IDuplexChannel, PeerDuplexChannel>(queueHandler, peerNode, base.ChannelManager, localAddress, via); }
protected InputQueueChannel(ChannelManagerBase channelManager) : base(channelManager) { this.inputQueue = TraceUtility.CreateInputQueue <TDisposable>(); }
protected override IInputSessionChannel CreateChannel(ChannelManagerBase channelManager, IInputSessionChannel innerChannel, Message firstMessage) { return(new InputSessionChannelWrapper(channelManager, innerChannel, firstMessage)); }
public ReliableOutputSessionChannelOverRequest(ChannelManagerBase factory, IReliableFactorySettings settings, IClientReliableChannelBinder binder, FaultHelper faultHelper, LateBoundChannelParameterCollection channelParameters) : base(factory, settings, binder, faultHelper, channelParameters) { this.binder = binder; }
public InputSessionChannelWrapper(ChannelManagerBase channelManager, IInputSessionChannel innerChannel, Message firstMessage) : base(channelManager, innerChannel, firstMessage) { }
public ReplySessionOverDuplexSessionChannel(ChannelManagerBase channelManager, IDuplexSessionChannel innerChannel) : base(channelManager, innerChannel) { this.session = new ReplySessionOverDuplexSession(innerChannel.Session); }
public SecurityRequestChannel(ChannelManagerBase factory, SecurityProtocolFactory securityProtocolFactory, IRequestChannel innerChannel, EndpointAddress to, Uri via) : base(factory, securityProtocolFactory, innerChannel, to, via) { }
public SecurityDuplexSessionChannel(ChannelManagerBase factory, SecurityProtocolFactory securityProtocolFactory, IDuplexSessionChannel innerChannel, EndpointAddress to, Uri via) : base(factory, securityProtocolFactory, innerChannel, to, via) { }
public ContextInputChannel(ChannelManagerBase channelManager, IInputChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism) : base(channelManager, innerChannel, contextExchangeMechanism) { }
public ContextReplySessionChannel(ChannelManagerBase channelManager, IReplySessionChannel innerChannel, ContextExchangeMechanism contextExchangeMechanism) : base(channelManager, innerChannel) { this.contextProtocol = new ServiceContextProtocol(contextExchangeMechanism); }