public void UnregisterForQueueItemAvailable(IActivityEventListener<QueueEventArgs> eventListener)
{
if (eventListener == null)
throw new ArgumentNullException("eventListener");
lock (qService.SyncRoot)
{
ActivityExecutorDelegateInfo<QueueEventArgs> subscriber = new ActivityExecutorDelegateInfo<QueueEventArgs>(eventListener, qService.CallingActivity);
bool removed = qService.GetQueueState(this.queueName).AsynchronousListeners.Remove(subscriber);
if (!removed)
{
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "WorkflowQueue:QueueItemAvailable unsubscribe failed for activity '{0}' with context Id {1}", subscriber.ActivityQualifiedName, subscriber.ContextId);
}
}
}
public void SubscribeForCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener<CorrelationTokenEventArgs> dataChangeListener)
{
if (dataChangeListener == null)
{
throw new ArgumentNullException("dataChangeListener");
}
if (activity == null)
{
throw new ArgumentNullException("activity");
}
ActivityExecutorDelegateInfo<CorrelationTokenEventArgs> item = new ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>(dataChangeListener, ContextActivityUtils.ContextActivity(activity), true);
IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>> list = base.GetValue(SubscriptionsProperty) as IList<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>;
if (list == null)
{
list = new List<ActivityExecutorDelegateInfo<CorrelationTokenEventArgs>>();
base.SetValue(SubscriptionsProperty, list);
}
list.Add(item);
}
public void RegisterForQueueItemAvailable(IActivityEventListener<QueueEventArgs> eventListener, string subscriberQualifiedName)
{
if (eventListener == null)
throw new ArgumentNullException("eventListener");
lock (qService.SyncRoot)
{
EventQueueState qState = qService.GetQueueState(this.queueName);
ActivityExecutorDelegateInfo<QueueEventArgs> subscriber = new ActivityExecutorDelegateInfo<QueueEventArgs>(eventListener, qService.CallingActivity);
if (subscriberQualifiedName != null)
{
subscriber.SubscribedActivityQualifiedName = subscriberQualifiedName;
}
qState.AsynchronousListeners.Add(subscriber);
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "WorkflowQueue:QueueItemAvailable subscribe for activity '{0}' with context Id {1}", subscriber.ActivityQualifiedName, subscriber.ContextId);
if (qState.AsynchronousListeners.Count == 1)
qService.NotifyAsynchronousSubscribers(this.queueName, qState, qState.Messages.Count);
}
}
internal static bool Subscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener<QueueEventArgs> eventListener, Guid instanceId)
{
if (activity == null)
throw new ArgumentNullException("activity");
if (interfaceType == null)
throw new ArgumentNullException("interfaceType");
if (methodName == null)
throw new ArgumentNullException("methodName");
WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
IComparable queueName = ResolveQueueName(activity, interfaceType, methodName);
if (queueName != null)
{
// initializer
WorkflowQueue queue = null;
if (queueService.Exists(queueName))
{
queue = queueService.GetWorkflowQueue(queueName);
queue.Enabled = true;
}
else
{
queue = queueService.CreateWorkflowQueue(queueName, true);
}
if (eventListener != null)
{
queue.RegisterForQueueItemAvailable(eventListener, activity.QualifiedName);
WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "CorrelationService: activity '{0}' subscribing to QueueItemAvailable", activity.QualifiedName);
return true;
}
return false;
}
SubscribeForCorrelationTokenInvalidation(activity, interfaceType, methodName, eventListener, instanceId);
return false;
}
public void UnsubscribeFromCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener <CorrelationTokenEventArgs> dataChangeListener)
{
}
internal static bool Unsubscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener<QueueEventArgs> eventListener)
{
if (activity == null)
throw new ArgumentException("activity");
if (interfaceType == null)
throw new ArgumentNullException("interfaceType");
if (methodName == null)
throw new ArgumentNullException("methodName");
WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
IComparable queueName = ResolveQueueName(activity, interfaceType, methodName);
if (queueName != null)
{
if (queueService.Exists(queueName))
{
queueService.GetWorkflowQueue(queueName).UnregisterForQueueItemAvailable(eventListener);
return true;
}
}
return false;
}
public void UnregisterForQueueItemArrived(IActivityEventListener <QueueEventArgs> eventListener)
{
}
private static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener<ActivityExecutionStatusChangedEventArgs> statusChangeHandler, bool isimmediateCompensation)
{
SortedDictionary<int, CompensationInfo> sortedListOfCompensatableTargets = new SortedDictionary<int, CompensationInfo>();
if (targetActivity is CompositeActivity)
{
if (CollectCompensatableTargetActivities(targetActivity as CompositeActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
{
return true;
}
if (CollectCompensatableActiveContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
{
return true;
}
CollectCompensatableCompletedContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation);
if (sortedListOfCompensatableTargets.Count == 0)
{
CompleteRevokedExecutionContext(targetActivity, context);
return false;
}
int? nullable = targetActivity.GetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty) as int?;
int num = -1;
CompensationInfo info = null;
foreach (int num2 in sortedListOfCompensatableTargets.Keys)
{
if (nullable.HasValue)
{
int? nullable2 = nullable;
int num3 = num2;
if ((nullable2.GetValueOrDefault() < num3) && nullable2.HasValue)
{
break;
}
}
info = sortedListOfCompensatableTargets[num2];
num = num2;
}
if (info == null)
{
CompleteRevokedExecutionContext(targetActivity, context);
return false;
}
targetActivity.SetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty, num);
if ((info.TargetActivity != null) && (info.TargetActivity is ICompensatableActivity))
{
info.TargetActivity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
context.CompensateActivity(info.TargetActivity);
return true;
}
if ((info.TargetExecutionInfo != null) && (info.TargetExecutionContextManager != null))
{
ActivityExecutionContext context2 = info.TargetExecutionContextManager.DiscardPersistedExecutionContext(info.TargetExecutionInfo);
if (context2.Activity is ICompensatableActivity)
{
context2.Activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
context2.CompensateActivity(context2.Activity);
return true;
}
if (context2.Activity is CompositeActivity)
{
Activity lastCompensatableChild = GetLastCompensatableChild(context2.Activity as CompositeActivity);
if (lastCompensatableChild != null)
{
lastCompensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
context2.CompensateActivity(lastCompensatableChild);
return true;
}
return TryCompensateLastCompletedChildActivity(context2, context2.Activity, statusChangeHandler, false);
}
}
else if ((info.TargetExecutionContext != null) && (info.TargetExecutionContext.Activity is CompositeActivity))
{
Activity activity = GetLastCompensatableChild(info.TargetExecutionContext.Activity as CompositeActivity);
if (activity != null)
{
activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
info.TargetExecutionContext.CompensateActivity(activity);
return true;
}
return TryCompensateLastCompletedChildActivity(info.TargetExecutionContext, info.TargetExecutionContext.Activity, statusChangeHandler, false);
}
}
return false;
}
public void UnregisterForQueueItemArrived (IActivityEventListener<QueueEventArgs> eventListener)
{
}
public void RegisterForQueueItemAvailable (IActivityEventListener<QueueEventArgs> eventListener)
{
}
public void RegisterForQueueItemAvailable(IActivityEventListener <QueueEventArgs> eventListener)
{
RegisterForQueueItemAvailable(eventListener, null);
}
internal CorrelationTokenInvalidatedHandler(Type interfaceType, string operation, IActivityEventListener <QueueEventArgs> eventHandler, Guid instanceId)
{
this.eventHandler = eventHandler;
this.interfaceType = interfaceType;
this.followerOperation = operation;
this.instanceId = instanceId;
}
public void UnregisterForQueueItemArrived(IActivityEventListener<QueueEventArgs> eventListener)
{
if (eventListener == null)
throw new ArgumentNullException("eventListener");
lock (qService.SyncRoot)
{
qService.GetQueueState(this.queueName).SynchronousListeners.Remove(new ActivityExecutorDelegateInfo<QueueEventArgs>(eventListener, qService.CallingActivity));
}
}
public void UnsubscribeFromCorrelationTokenInitializedEvent(Activity activity, IActivityEventListener <CorrelationTokenEventArgs> dataChangeListener)
{
if (dataChangeListener == null)
{
throw new ArgumentNullException("dataChangeListener");
}
if (activity == null)
{
throw new ArgumentNullException("activity");
}
ActivityExecutorDelegateInfo <CorrelationTokenEventArgs> subscriber =
new ActivityExecutorDelegateInfo <CorrelationTokenEventArgs>(dataChangeListener,
ContextActivityUtils.ContextActivity(activity), true);
IList <ActivityExecutorDelegateInfo <CorrelationTokenEventArgs> > subscriptions = GetValue(SubscriptionsProperty) as IList <ActivityExecutorDelegateInfo <CorrelationTokenEventArgs> >;
if (subscriptions != null)
{
subscriptions.Remove(subscriber);
}
}
public void UnregisterForQueueItemAvailable(IActivityEventListener <QueueEventArgs> eventListener)
{
}
internal static bool Unsubscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener <QueueEventArgs> eventListener)
{
if (activity == null)
{
throw new ArgumentException("activity");
}
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
if (methodName == null)
{
throw new ArgumentNullException("methodName");
}
WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
IComparable queueName = ResolveQueueName(activity, interfaceType, methodName);
if (queueName != null)
{
if (queueService.Exists(queueName))
{
queueService.GetWorkflowQueue(queueName).UnregisterForQueueItemAvailable(eventListener);
return(true);
}
}
return(false);
}
public ActivityExecutorDelegateInfo(IActivityEventListener <T> eventListener, Activity contextActivity)
: this(false, eventListener, contextActivity)
{
}
private static void SubscribeForCorrelationTokenInvalidation(Activity activity, Type interfaceType, string followermethodName, IActivityEventListener <QueueEventArgs> eventListener, Guid instanceId)
{
CorrelationToken reference = GetCorrelationToken(activity);
CorrelationTokenInvalidatedHandler dataChangeEventListener = new CorrelationTokenInvalidatedHandler(interfaceType, followermethodName, eventListener, instanceId);
reference.SubscribeForCorrelationTokenInitializedEvent(activity, dataChangeEventListener);
}
public void RegisterForQueueItemAvailable (IActivityEventListener<QueueEventArgs> eventListener, string subscriberQualifiedName)
{
}
internal static bool Subscribe(IServiceProvider context, Activity activity, Type interfaceType, string methodName, IActivityEventListener <QueueEventArgs> eventListener, Guid instanceId)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
if (methodName == null)
{
throw new ArgumentNullException("methodName");
}
WorkflowQueuingService queueService = (WorkflowQueuingService)context.GetService(typeof(WorkflowQueuingService));
IComparable queueName = ResolveQueueName(activity, interfaceType, methodName);
if (queueName != null)
{
// initializer
WorkflowQueue queue = null;
if (queueService.Exists(queueName))
{
queue = queueService.GetWorkflowQueue(queueName);
queue.Enabled = true;
}
else
{
queue = queueService.CreateWorkflowQueue(queueName, true);
}
if (eventListener != null)
{
queue.RegisterForQueueItemAvailable(eventListener, activity.QualifiedName);
WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "CorrelationService: activity '{0}' subscribing to QueueItemAvailable", activity.QualifiedName);
return(true);
}
return(false);
}
SubscribeForCorrelationTokenInvalidation(activity, interfaceType, methodName, eventListener, instanceId);
return(false);
}
internal static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener<ActivityExecutionStatusChangedEventArgs> statusChangeHandler)
{
bool flag;
try
{
flag = TryCompensateLastCompletedChildActivity(context, targetActivity, statusChangeHandler, true);
}
catch (Exception)
{
if (targetActivity.Parent == null)
{
CompleteRevokedExecutionContext(targetActivity, context);
}
throw;
}
return flag;
}
private static void SubscribeForCorrelationTokenInvalidation(Activity activity, Type interfaceType, string followermethodName, IActivityEventListener<QueueEventArgs> eventListener, Guid instanceId)
{
CorrelationToken reference = GetCorrelationToken(activity);
CorrelationTokenInvalidatedHandler dataChangeEventListener = new CorrelationTokenInvalidatedHandler(interfaceType, followermethodName, eventListener, instanceId);
reference.SubscribeForCorrelationTokenInitializedEvent(activity, dataChangeEventListener);
}
public void UnsubscribeFromCorrelationTokenInitializedEvent (Activity activity, IActivityEventListener<CorrelationTokenEventArgs> dataChangeListener)
{
}
public void RegisterForQueueItemAvailable(IActivityEventListener <QueueEventArgs> eventListener, string subscriberQualifiedName)
{
}
