mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 4.6.0.125

Browse Source 
Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2016-08-03 10:59:49 +00:00
parent a569aebcfd
commit e79aa3c0ed
17047 changed files with 3137615 additions and 392334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
mcs/class/referencesource/System.Workflow.Runtime/WorkflowQueue.cs Normal file
View File

@ -0,0 +1,215 @@
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Workflow.ComponentModel;
namespace System.Workflow.Runtime
{
[Obsolete("The System.Workflow.* types are deprecated. Instead, please use the new types from System.Activities.*")]
public class WorkflowQueue
{
IComparable queueName;
WorkflowQueuingService qService;
internal WorkflowQueue(WorkflowQueuingService qService, IComparable queueName)
{
this.qService = qService;
this.queueName = queueName;
}
public event EventHandler<QueueEventArgs> QueueItemAvailable
{
add
{
if (value == null)
throw new ArgumentNullException("value");
lock (qService.SyncRoot)
{
EventQueueState qState = qService.GetQueueState(this.queueName);
ActivityExecutorDelegateInfo<QueueEventArgs> subscriber = new ActivityExecutorDelegateInfo<QueueEventArgs>(value, qService.CallingActivity);
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);
}
}
remove
{
lock (qService.SyncRoot)
{
ActivityExecutorDelegateInfo<QueueEventArgs> subscriber = new ActivityExecutorDelegateInfo<QueueEventArgs>(value, 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 RegisterForQueueItemAvailable(IActivityEventListener<QueueEventArgs> eventListener)
{
RegisterForQueueItemAvailable(eventListener, null);
}
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);
}
}
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 event EventHandler<QueueEventArgs> QueueItemArrived
{
add
{
if (value == null)
throw new ArgumentNullException("value");
lock (qService.SyncRoot)
{
qService.GetQueueState(this.queueName).SynchronousListeners.Add(new ActivityExecutorDelegateInfo<QueueEventArgs>(value, qService.CallingActivity));
}
}
remove
{
if (value == null)
throw new ArgumentNullException("value");
lock (qService.SyncRoot)
{
qService.GetQueueState(this.queueName).SynchronousListeners.Remove(new ActivityExecutorDelegateInfo<QueueEventArgs>(value, qService.CallingActivity));
}
}
}
public void RegisterForQueueItemArrived(IActivityEventListener<QueueEventArgs> eventListener)
{
if (eventListener == null)
throw new ArgumentNullException("eventListener");
lock (qService.SyncRoot)
{
qService.GetQueueState(this.queueName).SynchronousListeners.Add(new ActivityExecutorDelegateInfo<QueueEventArgs>(eventListener, qService.CallingActivity));
}
}
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 IComparable QueueName
{
get
{
return this.queueName;
}
}
public WorkflowQueuingService QueuingService
{
get
{
return this.qService;
}
}
public void Enqueue(object item)
{
lock (qService.SyncRoot)
{
qService.EnqueueEvent(this.queueName, item);
}
}
public object Dequeue()
{
lock (qService.SyncRoot)
{
object message = qService.Peek(this.queueName);
return qService.DequeueEvent(this.queueName);
}
}
public object Peek()
{
lock (qService.SyncRoot)
{
object message = qService.Peek(this.queueName);
return message;
}
}
public int Count
{
get
{
lock (qService.SyncRoot)
{
return this.qService.GetQueueState(this.queueName).Messages.Count;
}
}
}
public bool Enabled
{
get
{
lock (qService.SyncRoot)
{
return this.qService.GetQueueState(this.queueName).Enabled;
}
}
set
{
lock (qService.SyncRoot)
{
this.qService.GetQueueState(this.queueName).Enabled = value;
}
}
}
}
}