public void EventQueue_Dequeue()
{
var queue = new EventQueue();
queue.Enqueue(new Event("id", "value"));
Assert.IsTrue(queue.TryDequeue(out var dequeued));
}
/// <summary>
/// Moves to the next event.
/// </summary>
/// <returns>Returns true if there are more events available, otherwise returns false.</returns>
public bool MoveNext()
{
// No events after the end of the stream or error.
if (state == ParserState.StreamEnd)
{
Current = null;
return false;
}
else if (pendingEvents.Count == 0)
{
// Generate the next event.
pendingEvents.Enqueue(StateMachine());
}
Current = pendingEvents.Dequeue();
return true;
}
protected BaseEventQueueTester()
{
// 1) arrange
queue = new EventQueue();
pluginName = "TeoVincent";
e = new Event_Mock();
queue.Enqueue(pluginName, e);
}
public async Task TestReceiveEventWithoutWaiting()
{
int notificationCount = 0;
var tcs = new TaskCompletionSource <bool>();
var logger = new TestOutputLogger(this.TestOutput, false);
var machineStateManager = new MockMachineStateManager(logger,
(notification, evt, _) =>
{
notificationCount++;
if (notificationCount == 3)
{
Assert.Equal(MockMachineStateManager.Notification.ReceiveEventWithoutWaiting, notification);
tcs.SetResult(true);
}
});
var queue = new EventQueue(machineStateManager);
var enqueueStatus = queue.Enqueue(new E4(false), Guid.Empty, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(1, queue.Size);
enqueueStatus = queue.Enqueue(new E4(true), Guid.Empty, null);
Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus);
Assert.Equal(2, queue.Size);
var receivedEvent = await queue.ReceiveAsync(typeof(E4), evt => (evt as E4).Value);
Assert.IsType <E4>(receivedEvent);
Assert.True((receivedEvent as E4).Value);
Assert.Equal(1, queue.Size);
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E4>(e);
Assert.False((e as E4).Value);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
await Task.WhenAny(tcs.Task, Task.Delay(500));
Assert.True(tcs.Task.IsCompleted);
}
/// <summary>
/// 投遞事件
/// </summary>
/// <param name="e"></param>
internal void PostEvent(Event e)
{
eventLock.WaitOne();
{
eventQueue.Enqueue(e);
}
eventLock.ReleaseMutex();
}
public void EventQueue_Enqueue()
{
var queue = new EventQueue();
queue.Enqueue(new Event("id", "value"));
Assert.AreEqual(queue.Count, 1);
}
/// <summary>
/// Queues an action to be run on the UI thread
/// </summary>
/// <param name="action"></param>
public void QueueAction(Action action)
{
if (action is null)
{
throw new ArgumentNullException(nameof(action));
}
EventQueue.Enqueue(action);
}
public static void SendFill(this Strategy strategy, Order order)
{
var report = new ExecutionReport(order);
report.ExecType = ExecType.ExecTrade;
report.DateTime = DateTime.Now;
report.OrdStatus = OrderStatus.Filled;
report.CumQty = order.Qty;
report.LeavesQty = 0;
report.LastPx = order.Type == OrderType.Limit ? order.Price : order.Instrument.Trade?.Price ?? 0;
report.LastQty = order.Qty;
var queue = new EventQueue(size: 10);
queue.Enqueue(report);
queue.Enqueue(new OnQueueClosed(queue));
strategy.GetFramework().EventBus.ExecutionPipe.Add(queue);
}
public async Task TestEnqueueReceiveEventsAlternateType()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var machineStateManager = new MockMachineStateManager(logger,
(notification, evt, _) => { });
var queue = new EventQueue(machineStateManager);
int numMessages = 10000;
var enqueueTask = Task.Run(() =>
{
for (int i = 0; i < numMessages; i++)
{
if (i % 2 == 0)
{
queue.Enqueue(new E1(), Guid.Empty, null);
}
else
{
queue.Enqueue(new E2(), Guid.Empty, null);
}
}
});
var receiveTask = Task.Run(async() =>
{
for (int i = 0; i < numMessages; i++)
{
if (i % 2 == 0)
{
var e = await queue.ReceiveAsync(typeof(E1));
Assert.IsType <E1>(e);
}
else
{
var e = await queue.ReceiveAsync(typeof(E2));
Assert.IsType <E2>(e);
}
}
});
await Task.WhenAny(Task.WhenAll(enqueueTask, receiveTask), Task.Delay(3000));
Assert.True(enqueueTask.IsCompleted);
Assert.True(receiveTask.IsCompleted);
}
private void AddProviderEventReminder(XProviderEventType type)
{
_logger.Debug($"{AgentId}, status={type}");
TradingStatus = type;
var reminder = new Reminder(OnMarketStatusEvent, DateTime.Now, type);
reminder.SetClock(_eventClock);
_eventQueue.Enqueue(reminder);
}
private Token GetCurrentToken()
{
if (currentToken == null)
{
while (scanner.MoveNextWithoutConsuming())
{
currentToken = scanner.Current;
YamlDotNet.Core.Tokens.Comment comment = currentToken as YamlDotNet.Core.Tokens.Comment;
if (comment == null)
{
break;
}
pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
scanner.ConsumeCurrent();
}
}
return(currentToken);
}
private void InitAccoutQueue()
{
if (IsExecutionProvider)
{
_accountQueue = new EventQueue(2, 0, 2, 100, framework.EventBus);
_accountQueue.Enqueue(new OnQueueOpened(_accountQueue));
framework.EventBus.ExecutionPipe.Add(_accountQueue);
}
}
public void EventQueue_Dequeue_All()
{
var queue = new EventQueue();
queue.Enqueue(new Event("id", "value"));
queue.TryDequeue(out var dequeued);
Assert.AreEqual(queue.Count, 0);
}
public void Post(string eventName,
object context = null)
{
var @event = _eventFactory.CreateEvent(eventName, context);
lock (_lockObject)
{
_eventQueue.Enqueue(@event);
}
}
private EventQueue GetEventQueue(Framework framework)
{
if (!_queues.TryGetValue(framework, out var queue))
{
queue = new EventQueue(size: 10, bus: framework.EventBus);
queue.Enqueue(new OnQueueOpened(queue));
framework.EventBus.ExecutionPipe.Add(queue);
}
return(queue);
}
void CreateTables()
{
for (var i = 0; i < DefaultParams.TablesPosition.Length; i++)
{
Tables[i] = new Table(DefaultParams.TablesPosition[i], TableState.EmptyTable);
EventQueue.Enqueue(new EventData(Event.CreatedTable, new List <object> {
DefaultParams.TablesPosition[i]
}));
}
}
#pragma warning restore IDE0044, CS0649
public void Execute(int index)
{
Events.Enqueue(new EcsTestData
{
value = _threadIndex
});
ThreadIds[index] = _threadIndex;
ThreadUsages[_threadIndex]++;
}
public void EventQueue_Dequeue_Same()
{
var queue = new EventQueue();
var @event = new Event("id", "value");
queue.Enqueue(@event);
queue.TryDequeue(out var dequeued);
Assert.AreSame(@event, dequeued);
}
//void Subscribe(Instrument instrument, DateTime dateTime1, DateTime dateTime2)
//{
// Console.WriteLine("{0} {1}::Subscribe {2}", DateTime.Now, this.Name, instrument.Symbol);
// var info = new SubscribeInfo();
// info.DatePath = Path.Combine(DataPath, instrument.Symbol);
// info.DateTime1 = dateTime1;
// info.DateTime2 = dateTime2;
// info.InstrumentId = instrument.Id;
// info.SubscribeBidAsk = SubscribeBid && SubscribeAsk;
// info.SubscribeTrade = SubscribeTrade;
// var queue = new EventQueue(1, 0, 2, 0x61a8) {
// IsSynched = true
// };
// queue.Enqueue(new OnQueueOpened(queue));
// framework.EventBus.DataPipe.Add(queue);
// _dataSeries.Add(new DataSeriesObject(info, queue));
//}
void Subscribe(Instrument instrument, DateTime dateTime1, DateTime dateTime2)
{
Console.WriteLine("{0} {1}::Subscribe {2}", DateTime.Now, this.Name, instrument.Symbol);
// 在这里一开始就加载完，需要一点时间，后期考虑将数据与回测结合起来使用
ProtobufDataZeroReader reader = new ProtobufDataZeroReader();
reader.DataPath_Instrument = DataPath_Instrument;
reader.DataPath_Realtime = DataPath_Realtime;
reader.SubscribeExternData = SubscribeExternData;
reader.SubscribeAsk = SubscribeAsk;
reader.SubscribeBid = SubscribeBid;
reader.GetDataSeries(instrument, dateTime1, dateTime2);
IDataSeries Trades = null;
IDataSeries Bids = null;
IDataSeries Asks = null;
if (SubscribeTrade || SubscribeBid || SubscribeAsk)
{
reader.OutputSeries(out Trades, out Bids, out Asks);
}
if (SubscribeTrade && Trades != null && Trades.Count > 0)
{
var queue = new EventQueue(1, 0, 2, 0x61a8)
{
IsSynched = true
};
queue.Enqueue(new OnQueueOpened(queue));
framework.EventBus.DataPipe.Add(queue);
_dataSeries.Add(new DataSeriesObject(Trades, dateTime1, dateTime2, queue, this.Processor));
}
if (SubscribeBid && Bids != null && Bids.Count > 0)
{
var queue = new EventQueue(1, 0, 2, 0x61a8)
{
IsSynched = true
};
queue.Enqueue(new OnQueueOpened(queue));
framework.EventBus.DataPipe.Add(queue);
_dataSeries.Add(new DataSeriesObject(Bids, dateTime1, dateTime2, queue, this.Processor));
}
if (SubscribeAsk && Asks != null && Asks.Count > 0)
{
var queue = new EventQueue(1, 0, 2, 0x61a8)
{
IsSynched = true
};
queue.Enqueue(new OnQueueOpened(queue));
framework.EventBus.DataPipe.Add(queue);
_dataSeries.Add(new DataSeriesObject(Asks, dateTime1, dateTime2, queue, this.Processor));
}
}
public void TestDequeueEvent()
{
var logger = new TestOutputLogger(this.TestOutput, false);
var mockActorManager = new MockActorManager(logger,
(notification, evt, _) => { });
using (var queue = new EventQueue(mockActorManager))
{
var(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
queue.Enqueue(new E1(), Guid.Empty, null);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
queue.Enqueue(new E3(), Guid.Empty, null);
queue.Enqueue(new E2(), Guid.Empty, null);
queue.Enqueue(new E1(), Guid.Empty, null);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E3>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(2, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E2>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(1, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.IsType <E1>(e);
Assert.Equal(DequeueStatus.Success, deqeueStatus);
Assert.Equal(0, queue.Size);
(deqeueStatus, e, opGroupId, info) = queue.Dequeue();
Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus);
Assert.Equal(0, queue.Size);
}
}
public void Attach(EventBus bus)
{
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 25600, null)
{
IsSynched = true,
Name = $"attached {bus.framework.Name}"
};
q.Enqueue(new OnQueueOpened(q));
bus.DataPipe.Add(q);
this.attached[this.attachedCount++] = q;
}
public void ThenTheCounterReflectsTheNumberOfEvents()
{
var eventQueue = new EventQueue();
eventQueue.Enqueue(new TestEvent());
eventQueue
.Count
.Should()
.Be(1);
}
private static void PlayerVsCpu()
{
var player = new Player {
Name = GetInput("Enter player name", ".+")
};
var cpu = new Player {
Name = "CPU"
};
var options = new GameConfig
{
Players = new[]
{
player,
cpu
}
}
.WithMapHeight(10)
.WithMapWidth(10);
var gameState = new Game(options);
//Init
Draw(player.Map, cpu.Map, true);
var shipCountPerPlayer = GetInput <uint>("Enter number of ships for this game", "10|[1-9]");
for (var i = 0; i < shipCountPerPlayer; i++)
{
SetPlayerAndCpuShip(player, cpu);
}
while (player.Map.HasActiveShips || cpu.Map.HasActiveShips)
{
EventQueue.Enqueue(Console.Clear);
EventQueue.Enqueue(() => Draw(player.Map, cpu.Map, true));
if (!cpu.Map.Fire(player, GetCoordinate()))
{
EventQueue.Enqueue(() => Info($"{player.Name} miss"));
}
//Cpu fire
var availableShots = player.Map.TileDictionary.Where(t => t.Value.Status == TileStatus.OpenOcean || t.Value.Status == TileStatus.Ship).ToArray();
var coordinate = availableShots[new Random().Next(0, availableShots.Length - 1)].Key;
if (!player.Map.Fire(cpu, coordinate))
{
EventQueue.Enqueue(() => Info($"{cpu.Name} miss"));
}
DoEvents();
}
}
public async Task DeliverAsync(HubClientEvent hubClientEvent)
{
var endpointIds = hubClientEvent.RecipientId.HasValue
? new[] { hubClientEvent.RecipientId.Value }
: GetEndpointIds(hubClientEvent.Event.TypeId);
var hubEvent = new HubEvent(hubClientEvent.Event, endpointIds);
await _hubEventRepository.UpdateAsync(hubEvent);
_queue.Enqueue(hubEvent);
}
public void PumpAutoStopsOnRunFinished()
{
EventQueue q = new EventQueue();
EventPump pump = new EventPump( NullListener.NULL, q, true );
Assert.IsFalse( pump.Pumping, "Should not be pumping initially" );
StartPump( pump, 1000 );
Assert.IsTrue( pump.Pumping, "Pump failed to start" );
q.Enqueue( new RunFinishedEvent( new Exception() ) );
WaitForPumpToStop( pump, 1000 );
Assert.IsFalse( pump.Pumping, "Pump failed to stop" );
}
public void Run(bool predictive)
{
foreach (var evt in Events)
{
EventQueue.Enqueue(evt);
}
Events.Clear();
HetNet.Instance.Reset();
ServeEventQueue(predictive);
}
private void QueueReceivedMessages()
{
while (!_token.IsCancellationRequested)
{
try
{
_eventQueue.Enqueue(new InteractorMessageEventArgs(this, ReceiveMessage()));
}
catch (OperationCanceledException)
{
break;
}
catch (Exception error)
{
_eventQueue.Enqueue(new InteractorErrorEventArgs(this, error));
break;
}
}
Log.Debug($"Exited read loop for {this}");
}
/// <summary>
/// 异步的连接过程完成了。
/// </summary>
/// <param name="result"></param>
private void FinishConnect(IAsyncResult result)
{
Log(Name, string.Format("结束连接服务器，时间：{0}", DataTime2String(DateTime.Now)));
var client = result.AsyncState as TcpClient;
if (EnableConnectTimeOut)
{
if (DateTime.Now.Ticks - ConnectStartTime.Ticks > ConnectTimeOut * 1000 * 10000)
{
LogError(Name, "连接超时，无法连上服务器");
EventQueue.Enqueue(new Event {
Type = EventType.CanNotConnect
});
return;
}
}
if (client == null)
{
LogError(Name, "TcpClient == null 连接失败！");
}
else
{
try
{
client.EndConnect(result);
}
catch (Exception exception)
{
LogError(Name, string.Format("{0},{1}", exception.Message, exception.StackTrace));
}
if (client.Connected)
{
Log(Name, string.Format("连上服务器了，时间：{0}", DataTime2String(DateTime.Now)));
HasConnectedToServer = true;
LastClientHeartBeat = DateTime.Now;
LastServerHeartBeat = DateTime.Now;
IsWriting = false;
IsReading = false;
EventQueue.Enqueue(new Event {
Type = EventType.Connected
});
}
else
{
LogError(Name, "本次连接失败，等3秒，我再尝试连接");
Thread.Sleep(3 * 1000);
Connect();
}
}
}
public void PumpAutoStopsOnRunFinished()
{
EventQueue q = new EventQueue();
EventPump pump = new EventPump(NullListener.NULL, q, true);
Assert.IsFalse(pump.Pumping, "Should not be pumping initially");
StartPump(pump, 1000);
Assert.IsTrue(pump.Pumping, "Pump failed to start");
q.Enqueue(new RunFinishedEvent(new Exception()));
WaitForPumpToStop(pump, 1000);
Assert.IsFalse(pump.Pumping, "Pump failed to stop");
}
public void PumpAutoStopsOnRunFinished()
{
EventQueue q = new EventQueue();
EventPump pump = new EventPump(NullListener.NULL, q, true);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
StartPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Pumping));
q.Enqueue(new RunFinishedEvent(new Exception()));
WaitForPumpToStop(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
// public static async Task<GameScript> LoadAsync(
// IEnumerable<ScriptFile> sources,
// IScriptCompiler compiler)
// {
// // TODO Dispose ScriptRunner
// using var scriptRunner = compiler.Compile<Game>(sources);
// EventQueue eventQueue = new();
// var game = new Game(eventQueue);
// await scriptRunner.RunAsync(game);
// return new GameScript(game, eventQueue);
// }
public Task RunAsync(IMediator mediator, GameState?gameState = null)
{
// Filter event queue while setting up the game. Only ProtagonistChanged
// and RoomEntered should be sent to the UI when the game starts.
_eventQueue.IgnoreAll();
// Runs the OnGameStart callback in the game script.
_game.Start();
// From this point on, allow all events to go to the UI.
_eventQueue.AllowAll();
// We do need to make sure that the startup script has at least set
// a protagonist and room.
if (_game.Protagonist is null)
{
throw new InvalidOperationException(
"Startup script must set a protagonist.");
}
if (_game.CurrentRoom is null)
{
throw new InvalidOperationException(
"Startup script must enter a room.");
}
// Save the initial state so we've got something to compare to when
// saving the game.
_initialState = _game.Save();
if (gameState is not null)
{
_game.Load(gameState);
}
_eventQueue.Enqueue(new GameStarted(_game));
_eventQueue.Enqueue(new ProtagonistChanged(_game.Protagonist !));
_eventQueue.Enqueue(new RoomEntered(_game.CurrentRoom !));
return(_eventQueue.FlushAsync(mediator));
}
private void IncrementInitialisationState()
{
if (InitialisationCount == INITIALISATION_COUNT_MAX)
{
return;
}
InitialisationCount++;
if (InitialisationCount == INITIALISATION_COUNT_MAX)
{
EventQueue.Enqueue(new ManagerEvent(ManagerEventType.ConnectionComplete));
}
}
protected override void OnConnected()
{
foreach (var s in Series)
{
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 25600, null)
{
IsSynched = true,
Name = s.Name
};
q.Enqueue(new OnQueueOpened(q));
this.framework.EventBus.DataPipe.Add(q);
this.emitters.Add(new DataSeriesObject(s, DateTime1, DateTime2, q, Processor));
}
}
private DataSeriesObject CreateDataSeriesEmitter(DataSeries series, DateTime dateTime1, DateTime dateTime2)
{
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 25600, null)
{
IsSynched = true,
Name = series.Name
};
q.Enqueue(new OnQueueOpened(q));
this.framework.EventBus.DataPipe.Add(q);
return new DataSeriesObject(series, dateTime1, dateTime2, q, Processor);
}
protected virtual EventQueueNode DoSchedule(DateTime date, Event @event) {
if (ScheduleQ.MaxSize == ScheduleQ.Count) {
// the capacity has to be adjusted, there are more events in the queue than anticipated
var oldSchedule = ScheduleQ;
ScheduleQ = new EventQueue(ScheduleQ.MaxSize * 2);
foreach (var e in oldSchedule) ScheduleQ.Enqueue(e.Priority, e.Event);
}
return ScheduleQ.Enqueue(date, @event);
}
public void PumpSynchronousAndAsynchronousEvents()
{
EventQueue q = new EventQueue();
using (EventPump pump = new EventPump(NullListener.NULL, q, false))
{
pump.Name = "PumpSynchronousAndAsynchronousEvents";
pump.Start();
int numberOfAsynchronousEvents = 0;
int sumOfAsynchronousQueueLength = 0;
const int Repetitions = 2;
for (int i = 0; i < Repetitions; i++)
{
foreach (Event e in events)
{
q.Enqueue(e);
if (e.IsSynchronous)
{
Assert.That(q.Count, Is.EqualTo(0));
}
else
{
sumOfAsynchronousQueueLength += q.Count;
numberOfAsynchronousEvents++;
}
}
}
Console.WriteLine("Average queue length: {0}", (float)sumOfAsynchronousQueueLength / numberOfAsynchronousEvents);
}
}
public void PumpPendingEventsAfterAutoStop()
{
EventQueue q = new EventQueue();
EnqueueEvents(q);
Event[] eventsAfterStop =
{
new OutputEvent(new TestOutput("foo", TestOutputType.Out)),
new OutputEvent(new TestOutput("bar", TestOutputType.Trace)),
};
foreach (Event e in eventsAfterStop)
{
q.Enqueue(e);
}
QueuingEventListener el = new QueuingEventListener();
using (EventPump pump = new EventPump(el, q, true))
{
pump.Name = "PumpPendingEventsAfterAutoStop";
pump.Start();
int tries = 10;
while (--tries > 0 && q.Count > 0)
{
Thread.Sleep(100);
}
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
Assert.That(el.Events.Count, Is.EqualTo(events.Length + eventsAfterStop.Length));
}
public void PumpAutoStopsOnRunFinished()
{
EventQueue q = new EventQueue();
using (EventPump pump = new EventPump(NullListener.NULL, q, true))
{
pump.Name = "PumpAutoStopsOnRunFinished";
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
StartPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Pumping));
q.Enqueue(new RunFinishedEvent(new Exception()));
WaitForPumpToStop(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
}
private static void EnqueueEvents(EventQueue q)
{
foreach (Event e in events)
q.Enqueue(e);
}
public void Run()
{
this.thread = new Thread(() =>
{
Console.WriteLine($"{DateTime.Now} Data simulator thread started");
if (!IsConnected)
Connect();
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 16, null)
{
Name = "Data Simulator Start Queue",
IsSynched = true
};
q.Enqueue(new OnQueueOpened(q));
q.Enqueue(new OnSimulatorStart(DateTime1, DateTime2, 0));
q.Enqueue(new OnQueueClosed(q));
this.framework.EventBus.DataPipe.Add(q);
this.running = true;
this.exit = false;
while (!this.exit)
{
LinkedListNode<DataSeriesObject> lastNode = null;
var node = this.emitters.First;
while (node != null)
{
var emitter = node.Data;
if (!emitter.Done)
{
if (emitter.Enqueue())
this.objCount++;
lastNode = node;
}
else
{
if (lastNode == null)
this.emitters.First = node.Next;
else
lastNode.Next = node.Next;
this.emitters.Count--;
emitter.dataQueue.Enqueue(new OnQueueClosed(emitter.dataQueue));
}
node = node.Next;
}
}
this.exit = false;
this.running = false;
Console.WriteLine($"{DateTime.Now} Data simulator thread stopped");
})
{
Name = "Data Simulator Thread",
IsBackground = true
};
this.thread.Start();
}
