PublishContext(T message) : base(message) { _wasEndpointAlreadySent = DefaultEndpointSent; _timer = Stopwatch.StartNew(); _notifySend = null; }
public void Publish <T>(IEnumerable <T> messages, IPublishContext context = null) { Guard.ArgumentNotNull(messages, "message"); Guard.InstanceOfType(context, "context", typeof(ServiceBrokerContext)); var serviceBrokerContext = (ServiceBrokerContext)context; // ReSharper disable once PossibleNullReferenceException using (var sqlConnection = new SqlConnection(serviceBrokerContext.ConnectionString)) { sqlConnection.Open(); using (var sqlTransaction = sqlConnection.BeginTransaction()) { var conversationHandle = ServiceBrokerWrapper.BeginConversation(sqlTransaction, serviceBrokerContext.InitiatorService, serviceBrokerContext.TargetService, serviceBrokerContext.MessageContract, false); foreach (var message in messages) { byte[] buffer; using (var stream = new MemoryStream()) { var formatter = new BinaryFormatter(); formatter.Serialize(stream, message); buffer = stream.GetBuffer(); stream.Close(); } ServiceBrokerWrapper.Send(sqlTransaction, conversationHandle, serviceBrokerContext.MessageType, buffer); } sqlTransaction.Commit(); } } }
public void Publish <T>(IEnumerable <T> messages, IPublishContext context = null) { Guard.ArgumentNotNull(messages, "messages"); Guard.InstanceOfType(context, "context", typeof(RabbitMqContext)); var rabbitMqContext = (RabbitMqContext)context; Debug.Assert(rabbitMqContext != null, "rabbitMqContext != null"); var connection = _connectionManager.GetConnection(rabbitMqContext); //using (var connection = new ConnectionFactory().CreateConnection(rabbitMqContext.HostName)) using (var channel = connection.CreateModel()) { channel.QueueDeclare(queue: rabbitMqContext.Queue, durable: rabbitMqContext.Durable, exclusive: false, autoDelete: false, arguments: null); foreach (var message in messages) { channel.BasicPublish(exchange: "", routingKey: rabbitMqContext.Queue, basicProperties: GetBasicProperties(rabbitMqContext), body: GetBytes(message)); } } }
public void ApplyContext(IPublishContext <TRequest> context, Uri responseAddress) { context.SetRequestId(_requestId); context.SendResponseTo(responseAddress); context.SendFaultTo(responseAddress); _contextActions.Each(x => x(context)); }
PublishContext(T message, ISendContext context) : base(message, context) { _notifySend = context as IPublishContext; _wasEndpointAlreadySent = DefaultEndpointSent; _timer = Stopwatch.StartNew(); }
/// <inheritdoc /> public async Task Handle(IPublishContext context, Func <Task> next) { var validationContext = new ValidationContext(context.Message); Validator.ValidateObject(context.Message, validationContext, true); await next(); }
public Task Handle(IPublishContext context, Func <Task> next) { var validationContext = new ValidationContext(context.Message); Validator.ValidateObject(context.Message, validationContext); return(next()); }
public void Publish <T>(T message, IPublishContext context = null) { var connectionProperties = new Hashtable { { MQC.HOST_NAME_PROPERTY, "gdcdevqamq01" }, { MQC.PORT_PROPERTY, 1420 }, { MQC.CHANNEL_PROPERTY, "GDC.SSL.DV1.INTERNAL" }, { MQC.TRANSPORT_PROPERTY, MQC.TRANSPORT_MQSERIES_MANAGED } }; try { var mqQMgr = new MQQueueManager("QMGR.GDCDV1", connectionProperties); } catch (MQException mqe) { return; } }
public PublishedMessageImpl(IPublishContext <T> context) { _context = context; }
public void OnException(Exception ex, IPublishContext <TMessage> context) { throw ex; }
public void NotifyPublish <T>(IPublishContext <T> publishContext) where T : class { _published.Add(new Published <T>(publishContext)); }
public Published(IPublishContext <T> context) { _timestamp = Stopwatch.GetTimestamp(); _context = context; }
public void OnPublish(IPublishContext context) { context.SetHeader(CorrelationContext.CorrelationIdName, CorrelationContext.CorrelationId.Value.ToString()); }
public void NotifyPublish <T>(IPublishContext <T> publishContext) where T : class { _context.NotifyPublish(publishContext); }
public bool ShouldExecute(IPublishContext <TMessage> context) { return(_shouldExecute == null || _shouldExecute()); }
static void DefaultCallback(TScenario scenario, IPublishContext <TMessage> context) { }
public static IPublishContext UsePublishConfiguration(this IPublishContext context, Action <IPublisherConfigurationBuilder> configuration) { context.Properties.Add(PipeKey.ConfigurationAction, configuration); return(context); }
public void SetCommandMessageHeaders<TCommand>(CommandMessage<TCommand> message, IPublishContext<TCommand> context) where TCommand : class, ICommand { PersistCorrelationId(context, message.CorrelationId); PersistMessageSentTime(context, message.SentOn); }
public void Publish <T>(IEnumerable <T> messages, IPublishContext context = null) { throw new NotImplementedException(); }
public async Task ExecuteAfterConnect(IPublishContext <TMessage> context) { await _bus.Publish(context.Message, context.Message.GetType()); }
public async Task ExecuteBeforeConnect(IPublishContext <TMessage> context) { await Task.FromResult(0); }
void NoContext <T>(IPublishContext <T> context) where T : class { }
public void SetEventMessageHeaders<TEvent>(EventMessage<TEvent> message, IPublishContext<TEvent> context) where TEvent : class, IEvent { PersistCorrelationId(context, message.CorrelationId); PersistMessageSentTime(context, message.SentOn); }