public virtual void RegisterTask(Func <AsyncCallback, IAsyncResult> beginDelegate,
Action <IAsyncResult> endDelegate)
{
Precondition.Require(beginDelegate, () => Error.ArgumentNull("beginDelegate"));
Precondition.Require(endDelegate, () => Error.ArgumentNull("endDelegate"));
AsyncCallback callback = ar => {
lock (_taskLock)
{
}
if (!ar.CompletedSynchronously)
{
Sync(() => endDelegate(ar));
OutstandingOperations.Decrement();
}
};
OutstandingOperations.Increment();
IAsyncResult asyncResult;
lock (_taskLock)
{
asyncResult = beginDelegate(callback);
}
if (asyncResult.CompletedSynchronously)
{
endDelegate(asyncResult);
OutstandingOperations.Decrement();
}
}
void ExecuteActionsAgainstRabbitMq(object sender, TransactionEventArgs transactionEventArgs)
{
var transactionInfo = transactionEventArgs.Transaction.TransactionInformation;
if (transactionInfo.Status != TransactionStatus.Committed)
{
OutstandingOperations.Clear();
return;
}
var transactionId = transactionInfo.LocalIdentifier;
if (!OutstandingOperations.ContainsKey(transactionId))
{
return;
}
var actions = OutstandingOperations[transactionId];
if (!actions.Any())
{
return;
}
ExecuteRabbitMqActions(actions);
OutstandingOperations.Clear();
}
private void CommitTransaction(object sender, TransactionEventArgs e)
{
var transactionInfo = e.Transaction.TransactionInformation;
if (transactionInfo.Status != TransactionStatus.Committed)
{
OutstandingOperations.Clear();
return;
}
var transactionId = transactionInfo.LocalIdentifier;
if (!OutstandingOperations.ContainsKey(transactionId))
{
return;
}
var messages = OutstandingOperations[transactionId];
if (!messages.Any())
{
return;
}
var result = connectionManager.GetConnection()
.AppendToStream(EndpointAddress.GetIntermediateOutgoingQueue(), ExpectedVersion.Any, messages);
OutstandingOperations.Clear();
}
public void Add(Action <IModel> action)
{
var transaction = Transaction.Current;
if (transaction == null)
{
ExecuteRabbitMqActions(new[]
{
action
});
return;
}
var transactionId = transaction.TransactionInformation.LocalIdentifier;
OutstandingOperations.AddOrUpdate(transactionId, s =>
{
transaction.TransactionCompleted += ExecuteActionsAgainstRabbitMq;
return(new List <Action <IModel> >
{
action
});
}, (s, list) =>
{
list.Add(action);
return(list);
});
}
private IAsyncResult RegisterTaskInternal(Func <AsyncCallback, IAsyncResult> beginDelegate, AsyncCallback endDelegate)
{
AsyncCallback callback = ar => {
Send(() => {
if (endDelegate != null)
{
endDelegate(ar);
}
OutstandingOperations.Decrement();
});
};
OutstandingOperations.Increment();
return(beginDelegate(callback));
}
public void Send(EventData message)
{
var transaction = Transaction.Current;
var transactionId = transaction.TransactionInformation.LocalIdentifier;
IList <EventData> messages;
if (!OutstandingOperations.TryGetValue(transactionId, out messages))
{
messages = new List <EventData>();
transaction.TransactionCompleted += CommitTransaction;
OutstandingOperations.Add(transactionId, messages);
}
messages.Add(message);
}
void ExecuteActionsAgainstRabbitMq(object sender, TransactionEventArgs transactionEventArgs)
{
transactionEventArgs.Transaction.TransactionCompleted -= ExecuteActionsAgainstRabbitMq;
var transactionInfo = transactionEventArgs.Transaction.TransactionInformation;
var transactionId = transactionInfo.LocalIdentifier;
if (transactionInfo.Status != TransactionStatus.Committed)
{
return;
}
IList <Action <IModel> > actions;
OutstandingOperations.TryRemove(transactionId, out actions);
if (!actions.Any())
{
return;
}
ExecuteRabbitMqActions(actions);
}
public void Add(Action <IModel> action)
{
var transaction = Transaction.Current;
if (transaction == null)
{
ExecuteRabbitMqActions(new[] { action });
return;
}
var transactionId = transaction.TransactionInformation.LocalIdentifier;
if (!OutstandingOperations.ContainsKey(transactionId))
{
transaction.TransactionCompleted += ExecuteActionsAgainstRabbitMq;
OutstandingOperations.Add(transactionId, new List <Action <IModel> > {
action
});
return;
}
OutstandingOperations[transactionId].Add(action);
}
