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);
}
