Part 89 ParameterizedThreadStart delegate Video Lecture - C sharp Enhance

this part 89 of c-sharp tutorial in this
video will discuss the purpose of
parameterize the thread start delegate
this is continuation to part 88 so
please watch but 88 before proceeding so
when do we use this parameterize that
thread start delegate use this delegate
if you want to pass data to the thread
function let us understand this with an
example let's flip to your studio this
is the same example that we worked with
in the previous session at the moment
this program is always going to print
numbers from 1 till 10 now let's say we
want to control this target number we
want to change this program in such a
way that we wanted to prompt the user to
enter a target number and if they enter
and user enter this number 30 as the
target number then we want this program
to print numbers from 1 till 30 now to
be able to control the target number we
need to pass a parameter to this
function so let's go ahead and pass it a
parameter let's call it target and
within the for loop we are going to
check the value of Phi against the
target variable so that's going to do
the trick for us but then notice that
the moment we have changed the signature
of this function we got a compiler error
here and why do we call that compiler
error that's because if you look at this
thread class constructor there are 4
overloaded versions but basically you
know a thread needs to point to a
function you know which we want the
thread to execute and there are two ways
we can do that one way is to use thread
start delegate we discussed using that
in the previous session and another way
used to use parametrized thread star
delegate now what's the difference
between the two when do we use one over
the other
now if you want to pass some data to the
thread function here print numbers is
the thread function because this thread
is going to execute that function so and
it is expecting a parameter to be passed
and so obviously we need to pass some
data to this thread function so if the
thread function expects some data to be
passed then use parametrized thread star
delegate if you don't have any data
to Pastor the thread function then huge
thread start delegate so let's go ahead
and create an instance of parameterize
the thread start delegate let's call it
parameterize the thread start equals new
parameterize thread start and what is
the delegate a delegate is a function
point it points to a function and for a
delegate to be able to do that to its
constructor we need to pass the name of
the function and the name of the
function is print numbers all right so
we have an instance of a parametrized
thread star delegate let's go ahead and
pass it to the constructor of the thread
class notice that we got rid of that
compiler error but here we still have a
compiler error and what is the error
saying no overload for print numbers
matches delegate parametrized thread
start let's look at the signature of
parametrize thread star delegate with
that it returns wired and it expects a
parameter of type object now let's look
at the signature of the function to
which this delegate is pointing to print
numbers it returns wide and look at the
parameter it is of type integer so the
signature of this function does not
match the signature of this delegate so
obviously that's why we have this
compiler error and why is that because
delegates are types a function pointers
meaning the signature of the delegate
must match with the signature of the
delegate with which I mean to which it
is pointing to in this case they don't
match and that's why we have that
compiler error so to get rid of this
compiler error we need to change the
data type of this parameter to object
and the moment we do that notice that
the compiler error goes away but then we
need to fix it here because I is going
to be an integer so you need to typecast
that to integer so let's create a
variable of type int here let's call it
number and initialize that to 0 and then
let's use try parse function to convert
this object type into
Lygia so try Pass expects that to be in
a string format so let's convert that to
a string and then we need to pass it an
output parameter and let's pass this
variable that we have created number now
look at this try parse function it's
going to return true if the conversion
is successful otherwise it's going to
return false so if the conversion is
successful then go ahead and print the
numbers and you know if the conversion
is successful this variable is going to
receive the converted value so I is less
than or equal to number go ahead and
print it now all that is left is to get
the target number from the end user so
let's use console dot write line and
let's prompt the user to enter the
target number and let's read the value
that the user has entered using console
dot read line function and then let's
store it in a variable of type object
let's call it target and now the
important thing is to pass this argument
to this function okay so how do we do
that you know
just pass that to the start function and
we are calling this start function on
the thread object so this thread is
pointing to this function so that value
gets automatically passed down to this
function okay so if you look at the
start function itself on the thread
object you know that's an instance
method there are two overloaded versions
one over load word version doesn't take
any parameters the other one expects a
parameter of type object and thus target
is of type object so we are passing it
there that gets passed down to the print
numbers function so let's quickly run
this and see if it works as expected so
please enter the target number let's
enter for example 14 and look at that
it's printing numbers one till 14 okay
so when do we use this parameterize
thread start delegate
use it if you want to pass data to the
thread function now we can also change
the code in the main function like this
if you look at the code at the moment
you know we are explicitly creating an
instance of parametrized thread start
delegate making it point to a function
and then we are passing that delegate
instance to the thread class constructor
do we really have to write this line of
code here not really we can just copy
this paste it right there and get rid of
this delegate altogether let's go ahead
and run this so please enter the target
number let's enter maybe 30 and look at
that it prints numbers 1 till 30 so it's
working so now here we are not
explicitly creating the parametrized
thread start delegate but how is it
working it's working because the
compiler implicitly does the conversion
for us automatically from this to this
one okay so that's what we have there
new thread of number the print numbers
the compiler is going to do the implicit
conversion for us you know to this
syntax so the obvious question is when
to use parametrized thread start
delegate over thread start delegate if
you have some data that you want to pass
down to the thread function then use
parameterize thread start otherwise use
thread start delegate so one thing to
keep in mind is that using parametrized
thread start delegate and thread that
start method to pass data to the thread
function is not safe type save as they
operate on object data type look at that
you know the start method it expects a
parameter of type object so meaning you
can pass any type of data to this
function okay and it's still going to
work but then the problem is we lose
this type safety that we get that
c-sharp programming as a result of that
okay but now you may think okay here we
are operating on object data type now I
easily change this to into data time but
the moment we do that we have seen we
get a compiler error why is that that's
because the signature of this function
doesn't match the signature of
parametrized thread start delegate thus
the reason we get that compiler error
right so there's not really good
practice to use parameterize thread
start delegate to pass data to the
thread function because we lose that
c-sharp type safety the programming
language feature so in our next video
will actually discuss passing data to
the thread function without losing the
type safety feature of this Esha
programming language that's it for today
thank you for listening have a great day