C# wait for thread to finish without blocking Video Lecture - C sharp Enhance

this is part 1 0 2 of c-sharp tutorial
in part 1 0 1 of this video series we
have discussed creating a simple
responsive windows forms application
using task async and evade keywords in
this video we'll discuss how to rewrite
that same example using a thread and
along the way we'll discuss how to wait
for the thread to finish without
blocking the UI here's the example that
we worked with in our previous video
notice but in this example we are using
a task async and evade keywords let's
see how to rewrite the same example
using a thread so let's flip to visual
studio now instead of using a task we
are going to make use of a thread let's
call the instance thread and we want
this thread to execute this count
characters function before we do that
let's create a variable called account
which is going to keep track of the
number of characters that we have in the
file so now let's make this thread
execute this count characters function
to do that we are going to specify a
lambda expression here so we want this
thread to execute count characters
function and if you notice what this
count characters function doing it's
returning an integer that is the number
of characters that we have in the file
and we want to store that return value
in our count variable and then let's
start our thread we don't need this
async keyword anymore so let's get rid
of that and we also don't need this line
right here so let's delete that as well
let's run our application by pressing
ctrl f5 there we go we have our
application running at this point when
we click this process file button we are
going to have two problems first problem
we will not see this message processing
file please wait at all and the second
problem is that it's going to display 0
as the number of characters in the file
let's look at that in action let's click
this process file button look at that we
didn't see processing file please wait
message at all and
is displaying zero as the number of
characters in the file so why is this
happening let's understand what's going
on here when we click this process file
button
look at this the main thread that is the
UI thread is creating a worker thread
which is responsible for executing count
characters function and we know this
count characters function is going to
take at least five seconds to complete
in the meantime the main thread that is
the UI thread will continue to execute
these two lines of code that we have
here and another question that comes to
our mind is then why is it not
displaying this message processing file
please wait within the label that's
because the UI thread executes these two
lines of code so fast
it overrides the first message with the
second message and at that speed it is
impossible for the human eye to spot
that overriding in fact to prove that it
is actually overwriting the first
message with the second message let's
append to the label what we already have
in it by using plus equals let's run our
application once again by pressing ctrl
f5 and at this point when we click the
button look at that to the first message
it is appending the second message so
the obvious question here is how to fix
this problems to fix these problems all
we have to do is make the main thread
that is the UI thread wait for this
worker thread to finish before we can
display the second message in the label
so when we wait for the worker thread to
finish the worker thread will count the
number of characters in the file and
then it's going to update this variable
with the number of characters and at
that point if we display we get the
correct count so to make the main thread
the UI thread wait for the worker thread
to finish we are going to call join
method on the worker thread so let's run
our application by pressing ctrl f5 at
this point when we click the process
file button the application works
as expected notice we see the status
message processing file please wait and
we also see the correct number of
characters that we have in the file well
we have solved both those problems we
have introduced a new problem and that
is blocking the UI while the application
is busy processing the file meaning we
cannot move this form around or we
cannot resize it let's actually look at
that in action look at this when the
application is busy processing the file
I cannot move it around and I also
cannot resize it after the application
finishes processing I am able to move it
around and I am able to resize it but we
cannot do both of those while the
application is busy processing the file
because it blocks the UI basically this
call to thread or join is going to block
the UI now one way to solve this is by
moving this code which updates the text
property of the label with a correct
number of characters that we have in the
file into the work a thread let's
actually do that and see what happens so
I'm going to cut this line of code and
move it inside the volca thread and
there is no need now to call thread or
join which is actually blocking the UI
now let's go ahead and run our
application one more time by pressing
ctrl f5 now when we click the process
file button notice I am able to resize I
am able to move the form around while
the application is still busy processing
the file and we also see the correct
number of characters as expected so the
application is working here as expected
but the question to ask is is this the
right way of doing things and the answer
is no that's because as far as
multi-threading is concerned one
important rule to keep in mind is that
the thread that has created a control
should only modify its properties no
other thread should be doing that in our
example it's the main thread that is the
UI thread which has created this label
control so only the UI thread
be modifying its text property and not
the worker thread if you look at what we
are doing here
it's the worker thread which is
modifying the text property but this
label control is created by the UI
thread which shouldn't be doing that now
if you ask what will happen if we do
that the behavior is undefined your
application may or may not work in our
case the application is only working by
blind luck so the rule to always keep in
mind is that the thread that has created
the control should only be modifying its
properties so the right way to do this
is by using beginning work method so the
beginning work method is going to ask
the UI thread to set the label controls
text property and let's see how to do
that so to use the beginning work method
the first thing that we are going to do
is create an action delegate and this
delegate is going to point to a piece of
code that we want to execute so the
piece of code that we want to execute is
this line so we want to set the text
property of the label control with the
number of characters that we have in the
file so the action delegate here is
pointing to this line of code and we are
going to pass this action delegate to
beginning work method so this dot
beginning work and to the method let's
pass the action delegate now this
beginning work method is going to ask
the UI thread to execute this line of
code asynchronously in a type safe
manner and if we look at what this code
is doing all it's doing is setting the
text property of the label with the
number of characters in the file so
let's run our application one more time
by pressing ctrl f5 when we click the
process file button notice we see the
status message as expected I am able to
move the form around resize it and we
also see the correct number of
characters in the file so the
application is working as expected now
to make this action delegate point to
the piece of code that we want to
execute we are making use of a lambda
expression here
if this code is confusing we can rewrite
this in another way remember a delegate
is a type save function pointer meaning
the signature of the method to which the
delegate points to must match with the
signature of the delegate itself
that's why delegates are called type
save function pointers so if you look at
the signature of this delegate it
returns white and it doesn't take any
parameters so what we are going to do is
create a separate method whose signature
matches with the signature of this
action delegate so that this action
delegate can point to that method so
let's create a private method here the
return type is going to be void and
let's call this method set label text
property because that's what this method
is essentially going to do and we are
going to move this piece of code inside
our private method and if you look at
the code right here we have got a
compliation error because we don't have
access to the account variable which is
defined inside the split command handler
method so what I'm going to do is move
this variable declaration outside of the
click event handler and I'm going to
rename this count variable because if
you look at this count characters
function we already have a private
variable here called count so let's
rename this to character count and let's
rename all the instances of count to
character count so we have a private
method here whose signature matches the
signature of the action delegate that we
have here so now what we are going to do
is create an instance of the action
delegate and to the delegate we are
going to pass the name of the function
that we want to execute in our case it
is set label text property so the
signature of this method matches the
signature of the delegate and we are
passing the delegate to begin invoke
method which is going to ask the UI
thread to execute this function
asynchronously in a type safe manner
alright so with all these changes let's
go
and run our application one more time by
pressing ctrl f5 notice when we click
the process file button the application
is still working as expected this is a
very simple application in spite of it
being a very simple application notice
the code is already getting complicated
when we use threads in our previous
video we have seen how to achieve
exactly the same thing by using task
async animate keywords so this code
turned into this code and this is a very
simple example now imagine what's going
to happen if we have got multiple worker
threads and we want to use the output of
one thread from another thread and so on
and so forth the code can get very
complicated and painful so the one
obvious difference between a task and
the thread is start a synchronous
implementation is very easy with tasks
when compared with threads there are
other differences as well which we will
discuss in our next video and here we
have the code snippets that we have used
in this video thank you for listening
and have a great day