/// <summary> Method executed in parallel </summary>
/// <param name="exceptionHandler"> Method which will be called in case of any thread raise an exception </param>
public void Execute(Action <Exception> exceptionHandler)
{
Guard.NotNull(exceptionHandler, $"{nameof(exceptionHandler)}");
try
{
while (_taskQueue.NotEmpty())
{
_taskQueue.TryDequeue(out var task);
if (task == null)
{
return;
}
_taskProcessLogic.ProcessTask(task);
TaskSequenceNumber++;
ResetEvent.Set();
}
}
catch (ThreadInterruptedException ex)
{
Log.Information($"Exception thrown {ex}");
}
catch (Exception ex)
{
Log.Information($"Exception thrown {ex}");
exceptionHandler?.Invoke(ex);
}
}
public override void HandleMessage(INetPacket packet)
{
Debug.WriteLine($"Message received: \"{packet.GetType().Name}\" ({BattleId})");
if (Socket == null || ResetEvent.SafeWaitHandle.IsClosed)
{
return;
}
ResetEvent.Set();
if (BattleId < 2)
{
var ser = (BattleServer)Server;
switch (packet)
{
case PBEActionsResponsePacket arp:
{
ser.ActionsSubmitted(this, arp.Actions);
break;
}
case PBEPartyResponsePacket prp:
{
Party = prp.Party;
ser.PartySubmitted(this);
break;
}
case PBESwitchInResponsePacket sirp:
{
ser.SwitchesSubmitted(this, sirp.Switches);
break;
}
}
}
}
public void SendMask(string strMask)
{
if (CurState == OptStatus.RUNNING_HAVEMASK)
{
ShowData.GetInstance().MaskCode = strMask;
ResetEvent.Set();
}
}
private void StreamOutput()
{
string output = JsonConvert.SerializeObject(_account.Loans);
Console.WriteLine(output);
ResetEvent.Set();
}
private void StreamOutput()
{
foreach (var account in _accounts)
{
string output = JsonConvert.SerializeObject(account);
Console.WriteLine(output);
}
ResetEvent.Set();
}
#pragma warning disable 1998
public async Task HandleAsync(TestEvent args)
#pragma warning restore 1998
{
Thread.Sleep(50);
HandleGotCalled = true;
if (ResetEvent != null)
{
ResetEvent.Set();
}
}
public override void Initialize()
{
base.Initialize();
Watcher = new PhysicalFileSystemWatcher(FileSystem, FileSystemPath.Root);
Watcher.Changed += (sender, e) =>
{
Count++;
ResetEvent.Set();
};
Watcher.EnableRaisingEvents = true;
}
#pragma warning disable 1998
public async Task HandleAsync(TestEvent args)
#pragma warning restore 1998
{
Console.WriteLine("Sleeping...");
Thread.Sleep(50);
Console.WriteLine("Awake again...");
HandleGotCalled = true;
Console.WriteLine("HandleGotCalled = true");
ResetEvent?.Set();
Console.WriteLine("Event set...");
}
public void NotifyOtherThreads()
{
lock (_testLock)
{
if (IsCheckComplete)
{
return;
}
IsCheckComplete = true;
ResetEvent.Set();
}
}
private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs args)
{
var e = args.ExceptionObject as Exception;
Log.WriteError("Unhandled Exception", "{0}\n{1}", e?.Message, e?.StackTrace);
if (args.IsTerminating)
{
AppDomain.CurrentDomain.UnhandledException -= OnUnhandledException;
ResetEvent.Set();
}
}
public void NotifyOtherThreads()
{
lock (_testLock)
{
if (IsCheckComplete)
{
return;
}
CapturedTestMessage = ViewModel.Messages.FirstOrDefault(a => a.Text == TestMessage);
IsCheckComplete = true;
ResetEvent.Set();
}
}
void autoResetCompetition()
{
var rst = new ResetEvent();
var retries = retry(rst, 10);
for (int i = 0; i < 10; i++)
{
Task.Delay(4000).ContinueWith((x) => rst.Set(64));
Task.Delay(4000).ContinueWith((x) => rst.Set(32));
Task.Delay(4000).ContinueWith((x) => rst.Set(16));
}
var rs = retries.Result.s;
if (rs != 16 && rs != 32 && rs != 64)
{
Passed = false;
FailureMessage = $"autoResetCompetition fails with mutated state: {rs}";
}
else
{
$"autoReset retries: {retries.Result.r} reset value: {rs}".AsInfo();
}
}
public void NotifyOtherThreads()
{
lock (_testLock)
{
if (IsCheckComplete)
{
return;
}
Map.InitiatorLatitude = "498";
Map.InitiatorLongitude = "498";
IsCheckComplete = true;
ResetEvent.Set();
}
}
public override void Initialize()
{
base.Initialize();
Paths = new List <FileSystemPath>();
Watcher = new PhysicalFileSystemWatcher(FileSystem, FileSystemPath.Root);
Watcher.Changed += (sender, e) =>
{
if (e.ChangeType == WatcherChangeTypes.Created)
{
Paths.Add(e.NewPath);
ResetEvent.Set();
}
};
Watcher.EnableRaisingEvents = true;
}
// Define the event handlers.
private void FileChange(object source, FileSystemEventArgs e)
{
//Special handling when some files are not touched themselves, but have an ~something.tmp appended
var changedFile = e.Name.Split('~')[0];
if (changedFile.EndsWith(".js") || changedFile.EndsWith(".css") || changedFile.EndsWith(".txt") ||
changedFile.EndsWith(".html") || changedFile.EndsWith(".webpart") || changedFile.EndsWith(".png"))
{
if (!ChangedFilesInIteration.Contains(changedFile))
{
Log.InfoFormat("File {0} changed and a new upload is starting", changedFile);
ChangedFilesInIteration.Add(changedFile);
ResetEvent.Set();
}
}
}
public static void Main(string[] args)
{
Task.Factory.StartNew
(
() =>
{
// Imagine sleep is a long task which ends in 10 seconds
Thread.Sleep(10000);
// We release the whole AutoResetEvent
ResetEvent.Set();
}
);
// Once other thread sets the AutoResetEvent, the program ends
ResetEvent.WaitOne();
}
private void StartCheckHostIsAliveThread()
{
CheckAlive = new Task(() => {
try {
while (Interlocked.Read(ref StopCheckAlive) == 0)
{
Thread.Sleep(1000);
Settings = Server.GetSettings();
}
}
catch {
ResetEvent.Set();
}
});
CheckAlive.Start();
}
public void HandleError(int errno)
{
if (Error != null)
{
Util.StartThread(() =>
{
Error(this, new MegaResponseError {
Error = errno
});
ResetEvent.Set();
}, "request_error_handler");
}
else
{
ResetEvent.Set();
}
}
private static void Worker_WorkCompleted(object sender, EventArgs e)
{
// Expected
const bool expectedCompletionState = true;
// Actual
var actualCompletionState = Worker.IsWorkCompleted();
// Assert Hour Count
Debug.WriteLine($"Expected Hour Count = {WorkHours}. Actual Hour Count = {HourCount}.");
Assert.AreEqual(WorkHours, HourCount, "Unexpected hour count.");
// Assert Completion State
Debug.WriteLine($"Expected Completion State = {expectedCompletionState}. Actual Completion State = {actualCompletionState}.");
Assert.AreEqual(expectedCompletionState, actualCompletionState, "Unexpected completion state.");
// Release Waiting Thread
ResetEvent.Set();
}
public override void HandleMessage(INetPacket packet)
{
Debug.WriteLine($"Message received: \"{packet.GetType().Name}\" ({BattleId})");
if (Socket == null || ResetEvent.SafeWaitHandle.IsClosed)
{
return;
}
ResetEvent.Set();
if (BattleId < 2)
{
var ser = (BattleServer)Server;
switch (packet)
{
case PBEActionsResponsePacket arp:
{
ser.ActionsSubmitted(this, arp.Actions);
break;
}
case PBEPartyResponsePacket prp:
{
Console.WriteLine($"Received team from {TrainerName}!");
if (TeamShell == null)
{
TeamShell = prp.TeamShell;
ser.PartySubmitted(this);
}
else
{
Console.WriteLine("Team submitted multiple times!");
}
break;
}
case PBESwitchInResponsePacket sirp:
{
ser.SwitchesSubmitted(this, sirp.Switches);
break;
}
}
}
}
public void ThreadLifestyleTest()
{
ServiceRegistry.Current.Register <IPerson, Person>("person", LifestyleFlags.Thread);
IPerson person = null,
person2 = null, person3 = null, person4 = null;
PopulatePerThreadLifestyle(ref person, ref person2);
var mre = new ResetEvent(false);
ThreadPool.QueueUserWorkItem((s) =>
{
PopulatePerThreadLifestyle(ref person3, ref person4);
mre.Set();
});
mre.Wait();
Assert.AreSame(person, person2);
Assert.AreSame(person3, person4);
Assert.AreNotSame(person, person3);
}
public void GenericThreadLifestyleTest()
{
ServiceRegistry.Current.Register(new ComponentInfo(null, typeof(IList <>), typeof(List <>), LifestyleFlags.Thread));
IList <int> coll = null,
coll2 = null, coll3 = null, coll4 = null;
PopulatePerThreadLifestyle(ref coll, ref coll2);
var mre = new ResetEvent(false);
ThreadPool.QueueUserWorkItem((s) =>
{
PopulatePerThreadLifestyle(ref coll3, ref coll4);
mre.Set();
});
mre.Wait();
Assert.AreSame(coll, coll2);
Assert.AreSame(coll3, coll4);
Assert.AreNotSame(coll, coll3);
}
public void Start()
{
var factory = GetConnectionFactory();
// Create connection for both requests and responses
_connection = factory.CreateConnection();
// Open the connection
_connection.Start();
// Create session for both requests and responses
_session = _connection.CreateSession(AcknowledgementMode.IndividualAcknowledge);
// Create a message consumer
IDestination sourceQueue = _session.GetQueue(QueueName);
_consumer = _session.CreateConsumer(sourceQueue);
_consumer.Listener += async message =>
{
await Task.Delay(500);
var content = Encoding.UTF8.GetString(message.Content);
Console.WriteLine($" [{Thread.CurrentThread.ManagedThreadId}] {content}");
message.Acknowledge();
lock ( _sync )
{
_noOfreceivedMessages++;
if (_noOfreceivedMessages >= NoOfMessages)
{
ResetEvent.Set();
}
}
};
}
public void EnqueueOperation(ChunkCoordinates coords, BoundingBox box, bool skyLight, bool initial = false)
{
var op = new LightingOperation
{
SkyLight = skyLight, Box = box, Initial = initial, Coordinates = coords
};
CheckResult result = CheckResult.HighPriority;
if (!op.Initial)
{
result = CheckDistance(coords);
if (result == CheckResult.Cancel)
{
return;
}
}
FixPriority(op, result);
ResetEvent.Set();
}
private void OnSessionClosed()
{
IsClosed = true;
StopCheckAlive = 1;
ResetEvent.Set();
}
private static void Host_LostConnectionToChrome(object sender, EventArgs e)
{
ChromeConnectionStable = false;
ResetEvent.Set();
}
public static void Startfight(User player1, User player2)
{
int count_of_rounds = 0;
int count_cards_player1 = 0;
int count_cards_player2 = 0;
var rand = new Random();
int selected_card_player1 = 0;
int selected_card_player2 = 0;
double card1_damage = 0;
double card2_damage = 0;
while (true)
{
count_cards_player1 = player1.Deck.Count;
count_cards_player2 = player2.Deck.Count;
count_of_rounds++;
if (count_cards_player1 == 0 || count_cards_player2 == 0 || count_of_rounds == 100)
{
if (count_cards_player1 == 0)
{
Log += player1.Username + " doesn't have any more Cards in his Deck to play!\r\n";
Log += player2.Username + " won this Battle\r\nCongrats!\r\n";
looser = player1.Username;
winner = player2.Username;
DBManagmentFight.UpdatePlayerStats(player1.Username, "looser");
DBManagmentFight.UpdatePlayerStats(player2.Username, "winner");
}
else if (count_cards_player2 == 0)
{
Log += player2.Username + " doesn't have any more Cards in his Deck to play!\r\n";
Log += player1.Username + " won this Battle\r\nCongrats!\r\n";
looser = player2.Username;
winner = player1.Username;
DBManagmentFight.UpdatePlayerStats(player1.Username, "winner");
DBManagmentFight.UpdatePlayerStats(player2.Username, "looser");
}
else if (count_of_rounds == 100)
{
Log += "The Fight is been going on for 100 rounds now!\r\nIts a draw gerara here!";
draw = true;
DBManagmentFight.UpdatePlayerStats(player1.Username, "draw");
DBManagmentFight.UpdatePlayerStats(player2.Username, "draw");
}
break;
}
selected_card_player1 = rand.Next(0, count_cards_player1);
selected_card_player2 = rand.Next(0, count_cards_player2);
Card card1 = player1.Deck[selected_card_player1];
Card card2 = player2.Deck[selected_card_player2];
card1_damage = card1.Damage;
card2_damage = card2.Damage;
Log += "Round " + count_of_rounds + "\r\n" + card1.Name + " vs " + card2.Name + "\r\n";
if (card1.Type != "spell" && card2.Type != "spell")
{
Log += "Both Cards are monster. The elements don't have any effect!\r\n";
if (card1.Type == "goblin" && card2.Type == "dragon")
{
Log += player1.Username + "s " + card1.Name + " is too afraid of " + player2.Username + "s " + card2.Name + " and can't attack him\r\n";
card1.Damage = 0;
}
if (card2.Type == "goblin" && card1.Type == "dragon")
{
Log += player2.Username + "s " + card2.Name + " is too afraid of " + player1.Username + "s " + card1.Name + " and can't attack him\r\n";
card2.Damage = 0;
}
if (card1.Type == "wizzard" && card2.Type == "ork")
{
Log += player1.Username + "s " + card1.Name + " can controll " + player2.Username + "s " + card2.Name + " and controls him\r\n";
card2.Damage = 0;
}
if (card2.Type == "wizzard" && card1.Type == "ork")
{
Log += player2.Username + "s " + card2.Name + " can controll " + player1.Username + "s " + card1.Name + " and controls him\r\n";
card1.Damage = 0;
}
if (card1.Name == "FireElves" && card2.Type == "dragon")
{
Log += player1.Username + "s " + card1.Name + " knows " + player2.Username + "s " + card2.Name + " since over a thousand years nad can evade his attacks!\r\n";
card2.Damage = 0;
}
if (card2.Name == "FireElves" && card1.Type == "dragon")
{
Log += player2.Username + "s " + card2.Name + " knows " + player1.Username + "s " + card1.Name + " since over a thousand years nad can evade his attacks!\r\n";
card1.Damage = 0;
}
}
else
{
if (card1.Type == "knight" && card2.Name == "WaterSpell")
{
Log += player1.Username + "s " + card1.Name + " is drowning because of " + player2.Username + "s " + card2.Name + " since his armor is too heavy!\r\n";
card1.Damage = 0;
}
if (card2.Type == "knight" && card1.Name == "WaterSpell")
{
Log += player2.Username + "s " + card2.Name + " is drowning because of " + player1.Username + "s " + card1.Name + " since his armor is too heavy!\r\n";
card2.Damage = 0;
}
if (card1.Type == "kraken" && card2.Type == "spell")
{
Log += player1.Username + "s " + card1.Name + " is immune against " + player2.Username + "s " + card2.Name + "!\r\n";
card2.Damage = 0;
}
if (card2.Type == "kraken" && card1.Type == "spell")
{
Log += player2.Username + "s " + card2.Name + " is immune against " + player1.Username + "s " + card1.Name + "!\r\n";
card1.Damage = 0;
}
if (card1.Type == "fire" && card2.Type == "normal")
{
card1.Damage = card1.Damage * 2;
card2.Damage = card2.Damage / 2;
}
else if (card2.Type == "fire" && card1.Type == "normal")
{
card2.Damage = card2.Damage * 2;
card1.Damage = card1.Damage / 2;
}
if (card1.Type == "water" && card2.Type == "fire")
{
card1.Damage = card1.Damage * 2;
card2.Damage = card2.Damage / 2;
}
else if (card2.Type == "water" && card1.Type == "fire")
{
card2.Damage = card2.Damage * 2;
card1.Damage = card1.Damage / 2;
}
if (card1.Type == "normal" && card2.Type == "water")
{
card1.Damage = card1.Damage * 2;
card2.Damage = card2.Damage / 2;
}
else if (card2.Type == "normal" && card1.Type == "water")
{
card2.Damage = card2.Damage * 2;
card1.Damage = card1.Damage / 2;
}
}
if (card1.Damage > card2.Damage)
{
Log += card1.Name + " (" + card1.Damage + ")" + " does more damage than " + card2.Name + " (" + card2.Damage + ")" + "\r\n";
Log += player1.Username + " wins round " + count_of_rounds + "\r\n";
player2.Deck.Remove(card2);
player1.Deck.Add(card2);
Log += card2.Name + " has been removed from " + player2.Username + " deck and added to " + player1.Username + "s Deck\r\n";
}
else if (card1.Damage < card2.Damage)
{
Log += card2.Name + " (" + card2.Damage + ")" + " does more damage than " + card1.Name + " (" + card1.Damage + ")" + "\r\n";
Log += player2.Name + " wins round " + count_of_rounds + "\r\n";
player1.Deck.Remove(card1);
player2.Deck.Add(card1);
Log += card1.Name + " has been removed from " + player1.Username + " deck and added to " + player2.Username + "s Deck\r\n";
}
else if (card1.Damage == card2.Damage)
{
Log += card2.Name + " (" + card2.Damage + ")" + " does equal damage to " + card1.Name + " (" + card1.Damage + ")" + "\r\n";
Log += "No one wins round " + count_of_rounds + "\r\n";
}
card1.Damage = card1_damage;
card2.Damage = card2_damage;
}
ResetEvent.Set();
}
public void SetResult(T result)
{
Result = result;
ResetEvent.Set();
}
public void Handles(ExampleEvent exampleEvent)
{
_service.PerformAction();
ResetEvent.Set();
ExampleEvent = exampleEvent;
}
public void WakeUp()
{
WakeUpCalled = true;
ResetEvent.Set();
}
