public static void Close() { try { _threadedLineQueue.Clear(); foreach (var pair in _instances) { pair.Value.TextWriter.Flush(); pair.Value.TextWriter.Close(); pair.Value.TextWriter.Dispose(); pair.Value.Clean(); _logPool.Return(pair.Value); } _instances.Clear(); _logPool.Clean(); _logPool = null; _instances = null; _threadedLineQueue = null; _defaultInstance = null; } catch (Exception e) { } }
/// <summary> /// PeopleDie /// </summary> /// <param name="data"></param> /// <returns></returns> public async Task PeopleDie(IEnumerable <GameRoom> data) { _GameRoom.TryGetValue(data.ToList()[0].RoomId, out var result); var newResult = new List <GameRoom>(); newResult = result; var target = new GameRoom(); target = newResult.Find(o => data.ToList()[0].Account == o.Account); target.IsAlive = false; if (data.Count() == 2) { var target2 = newResult.Find(o => data.ToList()[1].Account == o.Account); target2.IsAlive = false; } _GameRoom.TryUpdate(data.ToList()[0].RoomId, newResult, result); await Clients.Group(data.ToList()[0].RoomId.ToString()).PeopleDie(data.ToList()[0].Account); await Clients.Caller.PeopleDie(data.ToList()[0].Account); var newTarget = result; newTarget.ForEach(o => o.Voteticket = 0); _GameRoom.TryUpdate(data.ToList()[0].RoomId, newTarget, result); _svotePlayer.Clear(); _votePlayers.TryRemove(data.ToList()[0].RoomId, out _); li.Clear(); }
public void TestConcurrentQueueMethods() { this.Test(() => { var concurrentQueue = new ConcurrentQueue <int>(); Assert.True(concurrentQueue.IsEmpty); concurrentQueue.Enqueue(1); Assert.Single(concurrentQueue); bool peekResult = concurrentQueue.TryPeek(out int peek); Assert.True(peekResult); Assert.Equal(1, peek); concurrentQueue.Enqueue(2); int[] expectedArray = { 1, 2 }; var actualArray = concurrentQueue.ToArray(); Assert.Equal(2, concurrentQueue.Count); Assert.Equal(expectedArray, actualArray); bool dequeueResult = concurrentQueue.TryDequeue(out int dequeueValue); Assert.True(dequeueResult); Assert.Equal(1, dequeueValue); Assert.Single(concurrentQueue); #if !NETSTANDARD2_0 && !NETFRAMEWORK concurrentQueue.Clear(); Assert.Empty(concurrentQueue); #endif }, configuration: this.GetConfiguration().WithTestingIterations(100)); }
public static void OnLogHandler(string level, string message) { if (level == nameof(LogLevel.Info)) { if (message?.Contains("Session resumed") ?? false) { DisconnectTimestamps.Clear(); } } else if (level == nameof(LogLevel.Warn)) { if (message?.Contains("Dispatch:PRESENCES_REPLACE") ?? false) { BotStatusMonitor.RefreshAsync(discordClient).ConfigureAwait(false).GetAwaiter().GetResult(); } else if (message?.Contains("Pre-emptive ratelimit triggered") ?? false) { Config.TelemetryClient?.TrackEvent("preemptive-rate-limit"); } } else if (level == nameof(LogLevel.Fatal)) { if ((message?.Contains("Socket connection terminated") ?? false) || (message?.Contains("heartbeats were skipped. Issuing reconnect.") ?? false)) { DisconnectTimestamps.Enqueue(DateTime.UtcNow); } } }
public void ClearError() { var value = Connecting; if (value > 0) { Interlocked.Exchange(ref _totalConnectTimes, value); } else { Interlocked.Exchange(ref _totalConnectTimes, 0); } Interlocked.Exchange(ref _totalDisconnectTimes, 0); Interlocked.Exchange(ref _errorConnectTimes, 0); Interlocked.Exchange(ref _errorTimeoutTimes, 0); Interlocked.Exchange(ref _errorDecodeTimes, 0); Interlocked.Exchange(ref _errorEmptyTimes, 0); Interlocked.Exchange(ref _errorContinuousTimes, 0); _errList.Clear(); OnPropertyChanged(nameof(Connecting)); OnPropertyChanged(nameof(TotalConnectTimes)); OnPropertyChanged(nameof(TotalDisconnectTimes)); OnPropertyChanged(nameof(ConnectError)); OnPropertyChanged(nameof(ErrorConnectTimes)); OnPropertyChanged(nameof(ErrorTimeoutTimes)); OnPropertyChanged(nameof(ErrorDecodeTimes)); OnPropertyChanged(nameof(ErrorEmptyTimes)); OnPropertyChanged(nameof(ErrorContinuousTimes)); OnPropertyChanged(nameof(ErrorPercent)); }
/// <summary> /// Disposes of any resources /// </summary> public virtual void Dispose() { if (_disposed) { return; } _disposed = true; PendingParameterSet.Clear(); lock (RunningParameterSetForBacktest) { foreach (var backtestId in RunningParameterSetForBacktest.Keys) { ParameterSet parameterSet; if (RunningParameterSetForBacktest.TryRemove(backtestId, out parameterSet)) { try { AbortLean(backtestId); } catch { // pass } } } } }
public void Clear(CancellationTokenSource cancelToken) { cancelToken.Cancel(); _concurrentQueueActions2.Clear(); _concurrentQueueActions.Clear(); Console.WriteLine("Задачи очищены"); }
public void ClearOrders() { OrdersOnExecution.Clear(); Orders.Clear(); TargetedOrders.Clear(); ConsistanceOrders.Clear(); }
public List <PseudoNotificationResponseItem> AllResponse() { var result = new List <PseudoNotificationResponseItem> (mSendMessageQueue.ToArray()); mSendMessageQueue.Clear(); return(result); }
public async Task CloseAsync() { ThrowIfNotStarted(); Logger.LogInformation("Closing socket connection."); try { State = ReadyState.Closing; //don't receive anything from underlying socket anymore _pingPongSubscription.Dispose(); _messageSubscription.Dispose(); _disconnectSubscription.Dispose(); //clean anything set during socket startup/run time _packetId = -1; _currentHandshake = null; _sentPingPackets.Clear(); //finally stop the socket await _socket.StopOrFail(WebSocketCloseStatus.NormalClosure, string.Empty); } catch (Exception ex) { Logger.LogError(ex, "Error while stopping socket."); throw; } finally { Logger.LogInformation("Socket connection closed."); State = ReadyState.Closed; } }
public void Cleanup() { _chunkBuilds.Clear(); _chunkLoads.Clear(); _importantChunkBuilds.Clear(); _importantChunkLoads.Clear(); }
protected override void OnDisconnect() { base.OnDisconnect(); incomingPackets.Clear(); outgoingPackets.Clear(); }
public static void Clear_DuringEnumeration_DoesntAffectEnumeration() { const int ExpectedCount = 100; var q = new ConcurrentQueue <int>(Enumerable.Range(0, ExpectedCount)); using (IEnumerator <int> beforeClear = q.GetEnumerator()) { q.Clear(); using (IEnumerator <int> afterClear = q.GetEnumerator()) { int count = 0; while (beforeClear.MoveNext()) { count++; } Assert.Equal(ExpectedCount, count); count = 0; while (afterClear.MoveNext()) { count++; } Assert.Equal(0, count); } } }
private void WriteOutEchoreplayFile() { lock (fileWritingLock) { if (dataCacheLines.IsEmpty) { return; } // Fail if the folder doesn't even exist if (!Directory.Exists(SparkSettings.instance.saveFolder)) { LogRow(LogType.Error, "Replay directory doesn't exist."); return; } string directoryPath = SparkSettings.instance.saveFolder; string filePath = Path.Combine(directoryPath, fileName + ".echoreplay"); StreamWriter streamWriter = new StreamWriter(filePath, true); foreach (string row in dataCacheLines) { streamWriter.WriteLine(row); } dataCacheLines.Clear(); dataCacheTimestamps.Clear(); streamWriter.Close(); } }
protected override void Dispose(bool disposing) { Terminated = true; Lengths.Clear(); InfoQueue.Clear(); base.Dispose(disposing); }
private void ClearCache() { // We clear this first because the process tolerates missing // content cache entries EntriesToCompress.Clear(); StaticContentCache.Clear(); }
public void Clear() { if (_cache) { _utQueue.Clear(); _utQueue = null; } }
public void Close() { writeQueue.Clear(); readQueue.Clear(); writeThread.Interrupt(); readThread.Interrupt(); client.Close(); }
public void Dispose() { if (!_currentBatch.IsEmpty) { Indexer.IndexAsync(_currentBatch); _currentBatch.Clear(); } }
public void ClearLogs() { Logs.Clear(); foreach (var logger in _loggers.Values) { logger.Logs.Clear(); } }
public void Disconnect() { manualStreamOpenedEvent?.Reset(); transporter.TransportDataReceived -= Dispatcher_DataReceivedEvent; transporter.TransportDataTimeout -= Dispatcher_TransportDataTimeout; transporter.Disconnect(); packetQueue.Clear(); }
public void Dispose() { #if NETCOREAPP3_0 References.Clear(); #endif ClassMapping.Clear(); DynamicDlls.Clear(); }
static void Main(string[] args) { GetFilesToProcess(args); if (FilesToProcessQueue.Count < 1) { return; } while (FilesToProcessQueue.TryDequeue(out string FileToConvert)) { TryConvert(FileToConvert); if (FilesToProcessQueue.Count > 0) { Console.WriteLine("Press C to cancel; " + "R to re-read file system; " + "G to keep going (will happen automatically in " + WaitBetweenConversionsSecs.ToString() + " seconds)"); DateTime beginWait = DateTime.Now; while (!Console.KeyAvailable && DateTime.Now.Subtract(beginWait).TotalSeconds < WaitBetweenConversionsSecs) { Thread.Sleep(250); } if (Console.KeyAvailable) { string keyPressed = Console.ReadKey().KeyChar.ToString(); Console.WriteLine(Environment.NewLine + "You pressed: {0}", keyPressed); if (keyPressed == "c" || keyPressed == "C") { Console.WriteLine("Cancelling all pending conversions ... " + Environment.NewLine); FilesToProcessQueue.Clear(); } else if (keyPressed == "r" || keyPressed == "R") { GetFilesToProcess(args); } } } } } // end of Main
protected IEnumerator movement(string AtkAnimStr, string walkAnimStr, float objectWaitingTime, float objectSpeed) { while (true) { bool move = true; if (movementPath.Count < 2) { if (isAttacking) { animator.SetBool(AtkAnimStr, true); if (targetObject.getAttacker()) { targetObject.getAttacker().attack(); move = false; yield return(new WaitForSeconds(objectWaitingTime)); } else { animator.SetBool(walkAnimStr, true); animator.SetBool(AtkAnimStr, false); isAttacking = false; } } if (move) { movementPath.Clear(); animator.SetBool(walkAnimStr, false); int endNode = findDestination(); List <Graph.Node> path = GameManager.getCurrentLevel().getGraphLiveObjects().getPath(actualNodeNumber, endNode); foreach (Graph.Node n in path) { movementPath.Enqueue(n); } yield return(new WaitForSeconds(objectWaitingTime)); animator.SetBool(walkAnimStr, true); } } if (move) { StartCoroutine(stepMovement(objectSpeed)); yield return(new WaitForSeconds(objectSpeed)); } } }
public override Task DeleteQueueAsync() { if (_logger.IsEnabled(LogLevel.Trace)) { _logger.LogTrace("Deleting queue: {Name}", _options.Name); } _queue.Clear(); _deadletterQueue.Clear(); _dequeued.Clear(); _enqueuedCount = 0; _dequeuedCount = 0; _completedCount = 0; _abandonedCount = 0; _workerErrorCount = 0; return(Task.CompletedTask); }
/// <summary> /// 启动子线程读取日志队列并且输出屏幕 /// </summary> public static void Start(this ListBox lbx) { LogQueue.Clear(); //启动线程 Thread thread = new Thread(() => { Run(lbx); }); thread.Start(); }
public void ConcurrentQueue_FunctionsAsNormalQueue_ForSingleThreadedAccess(params int[] numbersToAdd) { // Because we're not doing anything interesting with the queue itself, it seems reasonable to just wrap all of the basic queue API tests into one test // Enqueue foreach (var number in numbersToAdd) { _concurrentQueue.Enqueue(number); } // Peek var head = _concurrentQueue.Peek(); Assert.AreEqual(numbersToAdd.First(), head); // GetEnumerator<T> var index = 0; var genericEnumerator = _concurrentQueue.GetEnumerator(); while (index < numbersToAdd.Length && genericEnumerator.MoveNext()) { Assert.AreEqual(numbersToAdd[index++], genericEnumerator.Current); } Assert.AreEqual(numbersToAdd.Length, index); // GetEnumerator index = 0; var nongenericEnumerator = ((IEnumerable)_concurrentQueue).GetEnumerator(); while (index < numbersToAdd.Length && nongenericEnumerator.MoveNext()) { Assert.AreEqual(numbersToAdd[index++], nongenericEnumerator.Current); } Assert.AreEqual(numbersToAdd.Length, index); // Count Assert.AreEqual(_concurrentQueue.Count, numbersToAdd.Length); // CopyTo var destinationArray = new int[numbersToAdd.Length]; _concurrentQueue.CopyTo(destinationArray, 0); Assert.True(numbersToAdd.SequenceEqual(destinationArray)); // Contains Assert.True(numbersToAdd.All(_concurrentQueue.Contains)); // Dequeue head = _concurrentQueue.Dequeue(); Assert.AreEqual(numbersToAdd.First(), head); Assert.True(_concurrentQueue.SequenceEqual(numbersToAdd.Skip(1))); // Clear _concurrentQueue.Clear(); Assert.AreEqual(0, _concurrentQueue.Count); Assert.False(numbersToAdd.Any(_concurrentQueue.Contains)); }
static void UpdateCharts() { valuationsChart.AddRange(maxValuations, averageValuations); maxValuations.Clear(); averageValuations.Clear(); agesChart.AddRange(ages); ages.Clear(); }
public IEnumerable <HistoricTagValueRecord> GetAndCleanHistoricTagValues() { lock (historicValues) { historicValuesCache = new ConcurrentQueue <HistoricTagValueRecord>(historicValues); historicValues.Clear(); return(historicValuesCache); } }
public void Close() { lock (shouldStopWritingLock) { shouldStopWriting = true; } signal.Set(); writingThread.Join(10000); // wait for background thread termination, but not too long entries.Clear(); }