protected virtual void UnregisterReceiver(ReceiverTask receiver)
{
lock (Store)
{
Store.RemoveReceiver(receiver);
}
}
public Interleave(TeardownReceiverGroup teardown, ExclusiveReceiverGroup mutex, ConcurrentReceiverGroup concurrent)
{
ReceiverTask[] branches = teardown._branches;
for (int i = 0; i < branches.Length; i++)
{
ReceiverTask receiverTask = branches[i];
receiverTask.ArbiterContext = new InterleaveReceiverContext(InterleaveReceivers.Teardown);
}
ReceiverTask[] branches2 = mutex._branches;
for (int j = 0; j < branches2.Length; j++)
{
ReceiverTask receiverTask2 = branches2[j];
receiverTask2.ArbiterContext = new InterleaveReceiverContext(InterleaveReceivers.Exclusive);
}
ReceiverTask[] branches3 = concurrent._branches;
for (int k = 0; k < branches3.Length; k++)
{
ReceiverTask receiverTask3 = branches3[k];
receiverTask3.ArbiterContext = new InterleaveReceiverContext(InterleaveReceivers.Concurrent);
}
_mutexBranches = new List <ReceiverTask>(teardown._branches);
ReceiverTask[] branches4 = mutex._branches;
for (int l = 0; l < branches4.Length; l++)
{
ReceiverTask item = branches4[l];
_mutexBranches.Add(item);
}
_concurrentBranches = new List <ReceiverTask>(concurrent._branches);
}
public void Shutdown()
{
sendQueue.ShutdownGracefully();
recvQueue.ShutdownGracefully();
socket.Shutdown(SocketShutdown.Send);
SenderTask.Wait();
ReceiverTask.Wait();
}
public bool Evaluate(ReceiverTask receiver, ref ITask deferredTask)
{
deferredTask = null;
if (ShouldCommit())
{
deferredTask = new Task(new Handler(Commit));
}
return(false);
}
private static ITask DequeuePendingItem(ReceiverTask receiver, int queueDepthMin)
{
Queue <Tuple <ITask, ReceiverTask> > pendingItems = ((InterleaveReceiverContext)receiver.ArbiterContext).PendingItems;
if (pendingItems.Count >= queueDepthMin)
{
return(pendingItems.Dequeue().Item0);
}
return(null);
}
protected virtual void RegisterReceiver(ReceiverTask receiver)
{
lock (Store)
{
if (!Store.IsElementListEmpty)
{
PortElement <T> portElement = Store.ElementListFirst;
int num = Store.ElementCount;
while (true)
{
PortElement <T> next = portElement._next;
ITask task = null;
bool flag2 = receiver.Evaluate(portElement, ref task);
if (task != null)
{
receiver.TaskQueue.Enqueue(task);
}
if (flag2)
{
Store.ElementListRemove(portElement);
}
if (receiver.State != ReceiverTaskState.Persistent)
{
if (flag2)
{
break;
}
if (task != null)
{
goto IL_88;
}
}
portElement = next;
num--;
if (num <= 0)
{
goto IL_88;
}
}
return;
}
IL_88:
if (_mode == PortMode.OptimizedSingleReissueReceiver && Store.ReceiverCount == 1)
{
throw new InvalidOperationException("PortMode.OptimizedSingleReissueReceiver allows only a single receiver");
}
Store.AddReceiver(receiver);
}
}
public bool Evaluate(ReceiverTask receiver, ref ITask deferredTask)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
Choice.ChoiceStage choiceStage = (Choice.ChoiceStage)Interlocked.Increment(ref _stage);
if (choiceStage == Choice.ChoiceStage.Commited)
{
Task <ITask> task = new Task <ITask>(deferredTask, new Handler <ITask>(Cleanup));
deferredTask = task;
return(true);
}
deferredTask = null;
return(false);
}
protected virtual ReceiverTask[] GetReceivers()
{
ReceiverTask[] result;
lock (Store)
{
if (Store.ReceiverCount == 0)
{
result = new ReceiverTask[0];
}
else
{
result = Store.ReceiverListAsObjectArray;
}
}
return(result);
}
void ReceiverTask_RisedEventSetsCorrectData_ArraysAreEqual()
{
var data = new byte[] { 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 62 };
var receivedData = new byte[22];
var streamResource = new Mock <IStreamResource>();
streamResource.Setup(x => x.Read(data, 0, 22)).Returns(22);
streamResource.Setup(x => x.BytesToRead()).Returns(22);
var receiverTask = new ReceiverTask(streamResource.Object);
receiverTask.DataReceived += (sender, args) => receivedData = args.Data;
receiverTask.Start();
Assert.Equal(receivedData.Length, data.Length);
}
internal void AddReceiver(ReceiverTask r)
{
if (ActiveReceiver == null && (Receivers == null || Receivers.Count == 0))
{
ActiveReceiver = r;
return;
}
if (Receivers == null)
{
Receivers = new List <ReceiverTask>();
}
if (ActiveReceiver != null)
{
Receivers.Add(ActiveReceiver);
ActiveReceiver = null;
}
Receivers.Add(r);
}
internal void RemoveReceiver(ReceiverTask r)
{
if (ActiveReceiver == r)
{
ActiveReceiver = null;
return;
}
if (Receivers == null)
{
return;
}
Receivers.Remove(r);
if (Receivers.Count == 1)
{
ActiveReceiver = Receivers[0];
Receivers.Clear();
}
}
public TeardownReceiverGroup(params ReceiverTask[] branches) : base(branches)
{
if (branches == null)
{
throw new ArgumentNullException("branches");
}
for (int i = 0; i < branches.Length; i++)
{
ReceiverTask receiverTask = branches[i];
if (receiverTask == null)
{
throw new ArgumentNullException("branches");
}
if (receiverTask.State == ReceiverTaskState.Persistent)
{
throw new ArgumentOutOfRangeException("branches", Resource1.TeardownBranchesCannotBePersisted);
}
}
}
public Choice(params ReceiverTask[] branches)
{
if (branches == null)
{
throw new ArgumentNullException("branches");
}
if (_stage != 0)
{
throw new InvalidOperationException(Resource1.ChoiceAlreadyActiveException);
}
for (int i = 0; i < branches.Length; i++)
{
ReceiverTask receiverTask = branches[i];
if (receiverTask.State == ReceiverTaskState.Persistent)
{
throw new ArgumentOutOfRangeException("branches", Resource1.ChoiceBranchesCannotBePersisted);
}
}
_branches = new List <ReceiverTask>(branches);
}
public override string ToString()
{
ICollection <ReceiverTask> receivers = GetReceivers();
int itemCount = ItemCount;
int count = receivers.Count;
string text = string.Format(CultureInfo.InvariantCulture, "Port Summary:\n Hash:{0}\n Type:{1}\n Elements:{2}\n ReceiveThunks:{3}\nReceive Arbiter Hierarchy:\n", new object[]
{
GetHashCode(),
base.GetType().GetGenericArguments()[0],
itemCount,
count
});
ReceiverTask[] receivers2 = GetReceivers();
for (int i = 0; i < receivers2.Length; i++)
{
ReceiverTask receiverTask = receivers2[i];
string str = receiverTask.ToString();
text = text + str + "\n";
}
return(text);
}
public void Disconnect()
{
CancellationSource.Cancel();
if (SenderTask != null)
{
SenderTask.Wait();
SenderTask = null;
}
if (ReceiverTask != null)
{
ReceiverTask.Wait();
ReceiverTask = null;
}
if (Socket != null)
{
Socket.Close();
Socket = null;
}
}
public ITask TryDequeuePendingTask(ReceiverTask receiver, int queueDepthMin)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
if (!(receiver.ArbiterContext is InterleaveReceiverContext))
{
throw new ArgumentException("receiver", Resource1.InterleaveInvalidReceiverTaskArgumentForTryDequeuePendingItems);
}
if (queueDepthMin <= 0)
{
throw new ArgumentOutOfRangeException("queueDepthMin");
}
ITask result;
lock (_mutexBranches)
{
result = Interleave.DequeuePendingItem(receiver, queueDepthMin);
}
return(result);
}
public void Disconnect()
{
CancellationSource.Cancel();
if (SenderTask != null)
{
// Remove this line and se if that fix the problem.
// SenderTask.Wait();
SenderTask = null;
}
if (ReceiverTask != null)
{
ReceiverTask.Wait();
ReceiverTask = null;
}
if (Socket != null)
{
// Socket.Close();
Socket = null;
}
}
void IPortReceive.UnregisterReceiver(ReceiverTask receiver)
{
UnregisterReceiver(receiver);
}
private void PostInternalFast(T item)
{
ReceiverTask activeReceiver = Store.ActiveReceiver;
activeReceiver.Consume(new PortElement <T>(item));
}
public bool Evaluate(ReceiverTask receiver, ref ITask deferredTask)
{
if (_state == ArbiterTaskState.Done)
{
deferredTask = null;
return(false);
}
lock (_mutexBranches)
{
if (((InterleaveReceiverContext)receiver.ArbiterContext).ReceiverGroup == InterleaveReceivers.Teardown && receiver.State == ReceiverTaskState.Onetime)
{
_state = ArbiterTaskState.Done;
object obj = Interlocked.CompareExchange(ref _final, deferredTask, null);
if (obj != null)
{
deferredTask = null;
return(false);
}
}
bool flag2 = ((InterleaveReceiverContext)receiver.ArbiterContext).ReceiverGroup != InterleaveReceivers.Concurrent;
bool flag3 = Arbitrate(flag2);
if (flag2)
{
if (flag3)
{
if (_final == deferredTask)
{
_final = null;
deferredTask = new Task <ITask>(deferredTask, new Handler <ITask>(Cleanup));
}
else
{
deferredTask.ArbiterCleanupHandler = new Handler(ExclusiveFinalizer);
}
}
else
{
if (deferredTask != _final)
{
((InterleaveReceiverContext)receiver.ArbiterContext).PendingItems.Enqueue(new Tuple <ITask, ReceiverTask>(deferredTask, receiver));
}
deferredTask = null;
}
if (deferredTask != null)
{
receiver.TaskQueue.Enqueue(deferredTask);
deferredTask = null;
}
}
else if (flag3)
{
deferredTask.ArbiterCleanupHandler = new Handler(ConcurrentFinalizer);
}
else
{
((InterleaveReceiverContext)receiver.ArbiterContext).PendingItems.Enqueue(new Tuple <ITask, ReceiverTask>(deferredTask, receiver));
deferredTask = null;
}
}
return(true);
}
void IPortReceive.RegisterReceiver(ReceiverTask receiver)
{
RegisterReceiver(receiver);
}
internal void PostInternal(bool insertAtHead, PortElement <T> node)
{
bool flag = false;
ITask task = null;
DispatcherQueue dispatcherQueue = null;
lock (Store)
{
if (insertAtHead)
{
Store.ElementListAddFirst(node);
}
else
{
Store.ElementListAddLast(node);
}
if (Store.ReceiverCount == 0)
{
return;
}
int num = 1;
if (Store.ActiveReceiver == null)
{
num = Store.ReceiverCount;
}
ReceiverTask receiverTask = Store.ActiveReceiver;
int i = 0;
while (i < num)
{
if (num != 1)
{
receiverTask = Store.GetReceiverAtIndex(i);
}
task = null;
flag = receiverTask.Evaluate(node, ref task);
dispatcherQueue = receiverTask.TaskQueue;
if (flag)
{
Store.ElementListRemove(node);
if (receiverTask.State != ReceiverTaskState.Persistent)
{
Store.RemoveReceiver(receiverTask);
if (i > 1)
{
i--;
}
else
{
receiverTask = Store.ActiveReceiver;
}
num = Store.ReceiverCount;
break;
}
break;
}
else
{
if (task != null)
{
dispatcherQueue.Enqueue(task);
}
i++;
}
}
}
if (flag && task != null)
{
dispatcherQueue.Enqueue(task);
}
}
