public void Test_GetContext_NoContext()
{
DeferredChannelMessageContext context;
context = DeferredChannelMessageContext.GetContext();
Assert.That(context, Has.Property("ContextType").EqualTo(ContextType.Detached));
}
/// <summary>
/// Flush any deferred messages.
/// </summary>
private void FlushDeferredMessageContextMessages()
{
if (!DeferredChannelMessageContext.IsSet())
{
return;
}
using (DeferredChannelMessageContext messageContext = DeferredChannelMessageContext.GetContext())
{
messageContext.FlushMessages();
}
}
/// <summary>
/// Publish_s the implementation.
/// </summary>
/// <param name="callback">The callback.</param>
/// <param name="message">The message.</param>
/// <param name="publishMethod">The publish method.</param>
/// <param name="options">The options.</param>
/// <param name="publishToOriginator">if set to <c>true</c> [publish to originator].</param>
/// <param name="mergeAction">The merge action.</param>
/// <returns></returns>
private Task <long> Publish_Impl(Func <T, PublishOptions, bool, Task <long> > callback, T message, PublishMethod publishMethod, PublishOptions options = PublishOptions.None, bool publishToOriginator = false, Action <T, T> mergeAction = null)
{
if (Equals(message, default(T)))
{
return(null);
}
if (Suppression.IsActive( ))
{
return(null);
}
DeferredChannelMessageContext deferredMessageContext = null;
try
{
/////
// If running in a delayed context, use the current message store.
/////
if (publishMethod == PublishMethod.Deferred)
{
deferredMessageContext = DeferredChannelMessageContext.GetContext( );
if (deferredMessageContext.ContextType != ContextType.Attached && !DeferredChannelMessageContext.SuppressNoContextWarning)
{
EventLog.Application.WriteWarning("Channel {0} has been created with PublishMethod.Deferred with no DeferredChannelMessageContext set. Messages will be sent immediately. Either set a DeferredChannelMessageContext or publish the message with PublishMethod.Immediate.", ChannelName);
}
}
if (deferredMessageContext != null &&
deferredMessageContext.ContextType == ContextType.Attached)
{
deferredMessageContext.AddOrUpdateMessage(ChannelName, message, mergeAction);
}
else
{
return(callback(message, options, publishToOriginator));
}
}
finally
{
if (deferredMessageContext != null)
{
deferredMessageContext.Dispose( );
}
}
return(null);
}
public void Test_GetContext()
{
Assert.That(DeferredChannelMessageContext.IsSet(), Is.False, "Set initially");
using (DeferredChannelMessageContext newContext = new DeferredChannelMessageContext())
{
using (DeferredChannelMessageContext attachedContext = DeferredChannelMessageContext.GetContext())
{
Assert.That(newContext.ContextType, Is.EqualTo(ContextType.New), "Incorrect context type");
Assert.That(attachedContext.ContextType, Is.EqualTo(ContextType.Attached), "Incorrect context type");
}
Assert.That(DeferredChannelMessageContext.IsSet(), Is.True, "Attached Dispose() removed context");
}
Assert.That(DeferredChannelMessageContext.IsSet(), Is.False, "New Dispose() did not remove context");
}
