Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 20 days ago.
Improve this question
Say I was making a game and let's pretend I was using a Console Application rather than using something like Unity etc etc.
And imagine I wanted to implement a game loop, the same concept would apply to a dedicated network server for the game.
This is usually how I would have done it, but is this a good option?
public void Start()
{
_isRunning = true;
var sw = new Stopwatch();
while (_isRunning)
{
sw.Start();
/* Update Game Logic */
sw.Stop();
var sleepDelta = Constants.Tickrate - (int)sw.ElapsedMilliseconds;
if (sleepDelta > 0)
Thread.Sleep(sleepDelta);
else
Console.WriteLine(
$"Server can't keep up!\nElapsed: {(int)sw.ElapsedMilliseconds}\nElapsed: {sleepDelta}");
sw.Reset();
}
}
What's the difference between doing that vs something like the Timer and using the OnElapsed event
This is usually how I would have done it, but is this a good option?
Something like this might very well be good enough. I would not expect a high accuracy from the Thread.Sleep, so it might depend on how tight timing requirements you have. For a console based game I would suspect this is not super critical. If you do need high accuracy timers you might want to read this question.
What's the difference between doing that vs something like the Timer and using the OnElapsed event
A timer would do more or less the same thing, but the Threading.Timer/Timers.Timer classes allow ticks to overlap each other if you are not careful, so you either need to be careful with how you are using it, or use something like PeriodicTimer.
You also need a bit careful since the console process will exit when the main method returns, at least for normal non-async main methods.
Timers are in some sense more useful for UI programs where you cannot have a 'main loop', and have specialized timers that run on the UI thread.
But if your method works, then leave it be. If you do not have any problems, chances are that changes will introduce new issues without actually improving anything.
Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 3 years ago.
Improve this question
Consider a server with a performance-sensitive, highly-parallel, C# processing pipeline where we want to raise an event if something stops happening, e.g. the flow of media.
One theorized approach is to create a timer that is delayed continuously by the pipeline. By way of a simplistic example:
const int IDLE_MILLIS = 1000; // 1 second
Timer timer = new Timer(IDLE_MILLIS, () =>
{
Console.WriteLine("Pipeline is idle.");
});
void ProcessMediaFrame(MediaFrame frame)
{
timer.Change(IDLE_MILLIS, Timeout.Infinite);
// pipeline is not idle
}
How expensive is the Change method here? (https://learn.microsoft.com/en-us/dotnet/api/system.threading.timer.change)
Does the Timer consume any resources while idle?
The performance note in the source code (thanks Codexer for linking the correct file) says your case is exactly what they've optimized for.
We assume that timers are created and destroyed frequently, but rarely actually fire.
...
timeouts for operations ... almost never fire, because the whole point is that the timer only fires if something has gone wrong.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
I am retrieving data of about 100k rows from a database into a datagridview.This process takes up to 5-6 seconds.however during these seconds the user can't move the mouse or click any other button.how can I use aysnc/multithreading to achieve smooth user interface.
Look into the Task library and async, there's a whole section of C# for doing exactly this.
Basically you wind up with things like . . .
var records = await GetRecordsFromDatabase();
MyDataGridView.ItemSource = records;
private Task<IEnumerable<Record>> GetRecordsFromDatabase(){
return Task.Run(() => {
//do stuff the return IEnumerable<Records>
});
}
Note that while you can use threads, Tasks are a much better option in C# for async support.
Edit - most databases should support some async operation. In that case you'd likely have an async method to transform things from the database to the format you need. You'd also likely want to follow the convention of marking your own method as async. Something like . . . .
private async Task<IEnumerable<Record>> GetRecordsFromDatabaseAsync(){
var dbRecords = await Database.GetRecordsAsync();
//transform the database records and return them
}
And call it as above.
Let's assume you are doing all of this processor intensive work as a result of a button click. Hopefully you already have the work in a separate method and are calling that method from the click event. If you actually have all of your work inside the click event, move it out into its own method and call it from the click event handler.
Now that is still on a single thread. I'll just address using a separate thread here, though you should look into tasks on your own as well. To use a separate thread for the hard work, write 2 lines of code like this:
Thread t = new Thread(nameOfTimeConsumingMethod);
t.Start();
And that will do it. If you need to write output to, say, textBox1, you cannot do so directly from the new thread (no cross thread calls). But you can still write to that box easily enough indirectly like so.
BeginInvoke(new Action(()=>textBox1.text = "Hello world!"));
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
I'm almost completely virgin in threading / backgroundworkers etc.
I am trying to do this:
New window shows status of a process (label) and has an ongoing
XAML-defined animation with a storyboard (three points representing
a process in the background).
Run some background intensive code, that requires some input and
returns no output.
When finished, update the UI with a message
Repeat 2 & 3 tens of times with different operations in the background each time.
While the background BL is operating I'd like the UI not to hang, but the continuation of the execution of the next BL method should only execute after the first one has ended and the UI has been updated with the message I'd like to present.
I'd like the slimmest, simplest way to do this. using .Net 4.5, so I believe we're talking Tasks, right?
I've read dozens of Stackoverflow articles and consulted uncle google and aunt MSDN, but it's overwhelming - there are many ways to do this, and I'm a bit lost.
Thanks in advance.
Whatever you're talking about are fairly simple to do with async/await. Since you said you're new to multithreading, I recommend you to read and make yourself familiarize with it. Here is a good start and this
I assume you can implement #1 yourself and you only need guidance in implementing rest. So, I'll not be talking about it in my post.
Theoretically you need a collection with the list of work needs to be done, then start one by one after the previous one is completed.
To give some code sample
List<WorkItem> workItems = ...;//Populate it somehow
private async Task DoWorkMain()
{
foreach (var item in workItems)
{
await DoWork(item);
//WorkItem completed, Update the UI here,
//Code here runs in UI thread given that you called the method from UI
}
}
private Task DoWork(WorkItem item)
{
//Implement your logic non blocking
}
Then somewhere from the UI call
await DoWorkMain();
WorkItem is a class which holds data about the work to be done.
You need to create a thread for processing the data in the background. You can go with parameterised threads and if you want to continue the second execution only after the first is completed, set a boolean variable in the while lop of the thread or write thread synchronization.
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance.
Closed 9 years ago.
I am new to threading in C# and despite reading much theory about threading it doesn't help me very much in practice.
I want to write AI function (minmax alphabeta) for a checkers game and execute it in a different thread.
There are 4 options for that: regular Tread, Thread Pool, Asynchronous delegate, BackgroundWorker.
BackgroundWorker seems to me ideal for this, it has delegate for finish so I can run the "makemove" function that will actually make the calculated move on the board and for updating progress bar.
I have 3 questions about this:
Is BackgroundWorker really the best solution for this case?
BackgroundWorker is executed in the Thread Pool, What are the benefits from that? It is always said that Thread Pool is good when you have many different threads, and this is not exactly my case.
All the code examples that I saw were too simple and showed how to create just one such thread. In my program, I need to run this function every time it's the computer's turn, so I probably need to kill the previous thread and start a new one. What is the proper way to implement all this?
Any help would be appreciated.
1) Any and all of those solutions will work; you just have to use somewhat different logic to deal with each one.
2) ThreadPool is also useful when you have a set of things that can be executed on multiple threads (for example, in a Chinese Checkers game, you could run 5 different AI simulations via ThreadPool and it would run optimally on a computer that has two cores whereas using Threads would slow the process down due to context switching). It certainly works for your case - you'd just queue a second AIEvaluation or whatever and it would start executing ASAP.
3) Well, not really. The computer can't really make its move until after running alphabeta (presumably with some cutoff depth :P) so the AI thread would be done with its work anyhow. You could just use ThreadPool/BackgroundWorker each time.
Some general info about BackgroundWorker: it runs when you have "extra" CPU time, so if your main thread is hogging CPU for some reason, it won't do a whole lot. It may be better to use normal ThreadPool.
Let's say your program calls AIAct() when it's the AI's turn on the main thread. Also, let timerTick be a timer of the sort that exists in Windows Forms. Moreover, let there be the classes AIState and GameBoard that encapsulate the functionality needed for alpha-beta.
using System.Threading;
const int CUTOFF_DEPTH = 6;//Maximum plys for alpha-beta
AIState state;
void AIAct()
{
state = new AIState( this.GameBoard.GetState() );
ThreadPool.QueueUserWorkItem(RunMinimax, state);
//assume that timerTick is a Timer (Windows Forms Timer) that ticks every 100 ms
timerTick.Enabled = true;
}
void timerTick_Tick(object sender, EventArgs e)
{
if (state.IsComplete)
{
ExecuteAction(state.Result);
timerTick.Enabled = false;
//whatever else you need to do
}
}
private static void RunMinimax(object args)
{
AIState state = args as AIState;
if (state == null)
{
//error handling of some sort
Thread.CurrentThread.Abort();
}
//run your minimax function up to max depth of CUTOFF_DEPTH
state.Result = Minimax( /* */ );
state.IsComplete = true;
}
private class AIState
{
public AIState(GameBoard board)
{
this.Board = board;
}
public readonly GameBoard Board;
public AIAction Result;
public volatile bool IsComplete;
}
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 9 years ago.
Improve this question
What is the Mutex and semaphore in C#? Where we need to implement?
How can we work with them in multithreading?
You should start at MSDN.
System.Threading.Mutex: A synchronization primitive that can also be used for interprocess synchronization.
System.Threading.Semaphore: Limits the number of threads that can access a resource or pool of resources concurrently.
Generally you only use a Mutex across processes, e.g. if you have a resource that multiple applications must share, or if you want to build a single-instanced app (i.e. only allow 1 copy to be running at one time).
A semaphore allows you to limit access to a specific number of simultaneous threads, so that you could have, for example, a maximum of two threads executing a specific code path at a time.
I'd start by reading this: http://www.albahari.com/threading/part2.aspx#_Synchronization_Essentials
and then bolster it with the MSDN links bobbymcr posted.
You might want to check out the lock statement. It can handle the vast majority of thread synchonization tasks in C#
class Test {
private static object Lock = new object();
public function Synchronized()
{
lock(Lock)
{
// Only one thread at a time is able to enter this section
}
}
}
The lock statement is implemented by calling Monitor.Enter and Monitor.Exit. It is equivalent to the following code:
Monitor.Enter(Lock);
try
{
// Only one thread at a time is able to enter this section
}
finally
{
Monitor.Exit(Lock);
}