public ReceiveEndpoint(IReceiveTransport receiveTransport, ReceiveEndpointContext context)
{
_context = context;
_receiveTransport = receiveTransport;
_handle = receiveTransport.ConnectReceiveTransportObserver(new Observer(this, context.EndpointObservers));
}
public ReceiveEndpoint(IReceiveTransport receiveTransport, ReceiveEndpointContext context)
{
_context = context;
_receiveTransport = receiveTransport;
_started = TaskUtil.GetTask <ReceiveEndpointReady>();
_handle = receiveTransport.ConnectReceiveTransportObserver(new Observer(this, context.EndpointObservers));
}
public void Apply(IInMemoryBusBuilder builder)
{
IReceiveTransport transport = builder.ReceiveTransportProvider.GetReceiveTransport(_queueName, _transportConcurrencyLimit);
var receivePipe = CreateReceivePipe(builder, consumePipe => new InMemoryReceiveEndpointBuilder(consumePipe));
builder.AddReceiveEndpoint(_queueName, new ReceiveEndpoint(transport, receivePipe));
}
public void Apply(IInMemoryBusBuilder builder)
{
IReceiveTransport transport = builder.ReceiveTransportProvider.GetReceiveTransport(_queueName);
IPipe <ReceiveContext> receivePipe = CreateReceivePipe(builder, consumePipe => new InMemoryReceiveEndpointBuilder(consumePipe));
builder.AddReceiveEndpoint(new ReceiveEndpoint(transport, receivePipe));
}
public override IReceiveEndpoint CreateReceiveEndpoint(string endpointName, IReceiveTransport receiveTransport, IReceivePipe receivePipe,
ReceiveEndpointContext topology)
{
var receiveEndpoint = new ReceiveEndpoint(receiveTransport, receivePipe, topology);
_hostConfiguration.Host.AddReceiveEndpoint(endpointName, receiveEndpoint);
return(receiveEndpoint);
}
public ReceiveEndpoint(IReceiveTransport receiveTransport, IReceivePipe receivePipe)
{
_receiveTransport = receiveTransport;
_receivePipe = receivePipe;
_observers = new ReceiveEndpointObservable();
_handle = receiveTransport.ConnectReceiveTransportObserver(new Observer(this));
}
public ReceiveEndpoint(IReceiveTransport transport, ReceiveEndpointContext context)
{
_context = context;
_transport = transport;
_started = Util.TaskUtil.GetTask <ReceiveEndpointReady>();
_startObserver = new StartObserver();
ConnectReceiveEndpointObserver(_startObserver);
transport.ConnectReceiveTransportObserver(new Observer(this, context.EndpointObservers));
}
public EndpointHandle(ReceiveEndpoint endpoint, IReceiveTransport transport, StartObserver startObserver, CancellationToken cancellationToken)
{
_endpoint = endpoint;
_transport = transport;
_cancellationToken = cancellationToken;
_ready = Util.TaskUtil.GetTask <ReceiveEndpointReady>();
if (cancellationToken.CanBeCanceled)
{
_registration = cancellationToken.Register(() =>
{
if (_faulted != null)
{
_handle?.Disconnect();
_ready.TrySetException(_faulted.Exception);
}
_registration.Dispose();
});
}
_handle = startObserver.ConnectEndpointHandle(this);
}
protected virtual IReceiveEndpoint CreateReceiveEndpoint(string endpointName, IReceiveTransport receiveTransport,
ReceiveEndpointContext receiveEndpointContext)
{
var receiveEndpoint = new ReceiveEndpoint(receiveTransport, receiveEndpointContext);
_hostConfiguration.Host.AddReceiveEndpoint(endpointName, receiveEndpoint);
return(receiveEndpoint);
}
protected override IReceiveEndpoint CreateReceiveEndpoint(string endpointName, IReceiveTransport receiveTransport,
ReceiveEndpointContext topology)
{
throw new NotImplementedException();
}
public abstract IReceiveEndpoint CreateReceiveEndpoint(string endpointName, IReceiveTransport receiveTransport, IReceivePipe receivePipe,
ReceiveEndpointContext receiveEndpointContext);
public ReceiveEndpoint(IReceiveTransport receiveTransport, IPipe <ReceiveContext> receivePipe)
{
_receiveTransport = receiveTransport;
_receivePipe = receivePipe;
}
public ReceiveEndpoint(IReceiveTransport receiveTransport, IReceivePipe receivePipe)
{
_receiveTransport = receiveTransport;
_receivePipe = receivePipe;
}
public ReceiveEndpoint(IReceiveTransport receiveTransport, IPipe<ReceiveContext> receivePipe)
{
_receiveTransport = receiveTransport;
_receivePipe = receivePipe;
}
