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();
}
