Part 91 Retrieving data from Thread function using callback method Video

part 91 of c-sharp tutorial in this
video we'll discuss retrieving data from
thread function using callback method
this is continuation to part 90 so
please watch part 90 before proceeding
in part 90 we discussed passing data to
the thread function in this video we'll
discuss retrieving data from thread
function using callback method this what
we want the program to do the program is
going to prompt the user to enter the
target number and let's say for example
the user enters number 5 we want this
program to compute the sum of numbers
from 1 till 5 and then print the assam
and this is how we want to achieve it
main thread should retrieve the target
number from the user main thread should
then create a chain thread and pass the
target number to the chain thread and
then it is the responsibility of the
tail thread to compute the sum of
numbers and then return the sum to the
main thread using a callback function
and that callback function is then going
to print the sum of numbers so let's see
how to achieve this and the first step
here is to create a delegate for the
purpose of callback okay and in a bit
we'll be creating the actual callback
function the signature of that callback
function must match with the signature
of this delegate so let's go and create
this delegate first we'll be working
with the same example that we worked
with in the previous session so let's
flip to visual studio so let's go ahead
and create a delegate so public delegate
and the delegate is going to return void
and let's call this sum of numbers
callback you can give it any meaningful
name you want and this is going to
return sum of numbers so that's the
signature of our delegate all right the
next step is to you know modify this
number class to support callback methods
so here you know this class already has
a private field underscore target so we
are going to have another private feel
and that is going to be of type you know
the delegate that we have just created
some of numbers call back so some of
numbers call back and let's call this
underscore callback method and then we
are going to use this constructor to
initialize this reference variable as
well so we are going to pass the
parameter of type sum of numbers call
back and let's call the parameter
callback method so this dot underscore
callback method equals whatever you know
is coming into the constructor okay
so pretty simple change until now and
what we want this function to do we want
to print the sum of numbers so we need
to change the implementation here so
first of all within the function let's
create a variable of type integer and
let's call it sum and let's initialize
that to zero okay and let's also change
the name of this function from print
numbers to print sum of numbers okay so
that it's meaningful alright
so instead of printing the numbers what
we want to do we want to actually
compute the sum so sum equals sum plus I
so whatever value that we have with an i
plus the result that is already present
in the psalm okay so you know by this
statement we have the son computed now
what should this class - this class
should call the callback method and then
hand the sum over to that callback
method and the way we do that is by
using this delegate notice that this
constructor is already initializing you
know this delegate okay and the actual
delegate will be pointing to a callback
method if this is not clear at the
moment don't worry it should be clear in
just a bit so now what we are going to
do we are going to check if this is not
null and then we are going to call that
callback method so f underscore callback
method if that is not equal to now
then go ahead and call the delegate and
then obviously we need to pass it the
sum of numbers and where do we have it
we have it in this field so pass that to
this delegate okay all right so we are
done with this number class right now
okay the final step is to actually
consume this number class within the
main method okay so obviously you know
it's this program is going to prompt the
user to enter the target number so we
are reading the target a number from the
console screen and then remember we need
to define a callback function within
this program okay so the callback
function signature that we are going to
right now should match with the
signature of the delegate that we have
created that is sum of numbers callback
delegate so basically here let's write a
program call it public and the method
has to return white and let's call it
print sum of numbers you can give it any
meaningful name you want and then you
know it should take a parameter of type
integer and you can again give it any
meaningful name you want so basically
this is going to be the function you
know which the thread will call into and
then hand over the sum and all this
function is going to do is print the sum
so console dot readline sum of numbers
equals whatever is coming into this
function okay so this is the callback
function okay right now let's go ahead
and create an instance of our sum of
numbers callback delegate so sum of
numbers callback let's call it maybe
callback equals new sum of numbers
callback now what is the delegate
delegate is a function pointer it should
point to a function now this is going to
point to our callback function so just
pass
you know the name of the function here
let's actually make this static so that
we don't have to create an instance of
this program class okay so this is our
callback delegate and this delegate is
pointing to you know this function
alright now look at this this number
class at the moment if you look at the
constructor if you remember this
constructor now has got two parameters
the the integer parameter and the
callback delegate parameter so now we
are going to pass the delegate instance
that we have just created and we are
going to create a thread and execute
remember we have changed the name of the
function it's now called print sum of
numbers actually to keep things clear
let's call this one to print print sum
so that there is a distinction
right now so the name of the function
within the number class is print sum of
numbers so let's go to end point to that
function all right
let's quickly run this look at the
output and then we'll go over this
entire program once more so let's run
this so please enter the target number
let's enter for example number five look
at that sum of numbers is 15 all right
so what's happening here now if you look
at what we are doing here first of all
look at this number class
when we create an instance of this
number class you know we are passing two
things the target number and an instance
of sum of numbers callback delegate now
the sum of numbers callback delegate
what is it pointing to it is pointing to
this print sum function and what is
print sum function doing it is simply
printing the sum of the numbers so this
way a parameter right here is going to
receive the sum from the thread function
okay because the thread will call into
this function once it completes
execution okay so this is how a callback
function so the point to keep in mind
here is at the moment we have a delegate
instance which is pointing to that
function and we are passing that
delegate instance you know to the number
class constructor so once we do that
what's going to happen that delegate you
know whatever we have passed here you
know this callback delegate it's now you
know assigned to this one and what are
we doing with that you know reference
variable of sum of numbers callback
delegate look at that to that we are
passing sum which means you know this
delegate right now is actually pointing
to this function right here right so
obviously when print sum of numbers you
know it has completed calculating the
sum it is going to handle to sum to this
delegate and this delegate is pointing
to this function so this function gets
called sum is handed over to this
function and this function is simply
going to
print that Sam so that's how it works so
we have this callback function and this
delegate is pointing to that function
and within the number class to that
delegate we are handing over the Sam
which is going to delegate as a function
pointer so obviously it is going to
invoke that callback function pass the
sum and that callback function within
our main class you know within the
program class is going to print the Sam
all right that's it for today thank you
for listening have a great day