Part 98 Anonymous methods in c# Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming

about 98 of c-sharp tutorial in this
video we'll discuss what anonymous
methods are a bit an example so what is
an anonymous method in simple terms
anonymous method is a method without a
name they are introduced in c-sharp too
they provide us a way of creating
delegate instances without having to
write a separate method now let's
understand what we mean by the statement
they provide us a way of creating
delegate instances without having to
write a separate method let's flip to
visual studio the moment I have this
employee class with two properties that
is ID and name and within the main
method we are creating a list of
employees and this list at the moment
contains three employee objects with IDs
1 0 1 1 0 2 and 1 0 3 now let's say we
want to find the employee who has got an
idea of 1 0 2 within this list and in
order to achieve that we have find
method and if you look at this find
method what is what is it expecting as a
parameter predicate of employee let's
right click on this find method and go
to the definition on that so it is
expecting predicate of T so let's see
what this predicate of T is so let's
right click on that and go to the
definition on that look at that this
predicate of T is actually a delegate
and look at the signature of this
delegate it returns boolean and expects
an object of type T as a parameter in
our case T is employee because we are
invoking the find method on list of
employees look at this the intelligence
tells us that it is expecting a
predicate of employee so we are going to
give an employee object to the predicate
and that predicate is going to return a
boolean okay so basically this is the
delegate instance that we need to pass
as an argument to this find method now
what are delegates delegates are nothing
but function pointers meaning the point
a function now in order for a delegate
to be able to point to a function when
we create an instance of a delegate to
its constructor we pass the name of the
function okay so first we need to create
a function that we want the
two point okay so and the important
decision that we have to make it this
time as what should be the signature of
that method the signature of the that
method should match with the signature
of this delegate okay otherwise we'll
get a compiler error that's the reason
why delegates are called as type save
function pointers
okay so delegates are type save function
pointers because the signature of the
function to which they are pointing to
should match with the signature of the
delegate okay so let's go ahead and
create a delegate which we are sorry a
function which returns a boolean and
expects an object of type employee so
let's write that method here
so public let's make it static and this
is going to return boolean and let's
call it find employee and then to this
we give an employee object let's call it
EMP okay now what logic should be have
here now our initial requirement is we
should be able to find an employee who
has got an ID of 1 0 1 or 1 0 2 within
this list ok so what we are going to do
is return m p-- dot ID equals 1 0 2 so
basically this expression is going to
return true or false right so this
method returns a boolean and this
expression if the passed an employee
object ID matches with 1:02 it returns
true otherwise false ok now let's go
ahead and create an instance of you know
the predicate delegate so predicate and
in our case it's predicate of employee
and let's call this actually employee
predicate you can give it any meaningful
name you want now to the constructor of
the delegate what we need to pass we
need to pass the name of the function
that we want this delegate to point to
in our case the function is find
employee look at that the function you
know that we passed returns boolean and
it expects an object of type employee
and if you look at this method it
returns boolean X
an object of type employee so let's go
ahead and pass this as an argument okay
and the next step is to actually pass
this you know delegate to this list okay
now you know this list contains employee
object so I'm going to say employee goes
to now we are going to pass each
employee object to this method so find
the employee that's the method we want
to invoke and then pass the employee
object okay so basically what are we
doing here you know the first step is we
have created this function so that's our
step 1 and step 2 we created an instance
of a delegate and that delegate is
pointing to this function and step 3 we
passed the delegate instance as a
parameter to this find method and then
obviously what is this fine method going
to return it's going to return an
employee object so let's store it in an
object of type employee let's call it
employee equals that and then let's
print out the employee ID and name just
to make sure that we have got the right
employee so ID equals and name equals
okay so employee dot ID and employee dot
name alright let's go ahead and run this
and see if we get the output that we
expect look at that we got the object
that we expect so basically you know
what have we done we have created a
function and then we have created a
delegate instance this delegate is going
to point to that function and then we
have passed that function as a parameter
I mean that delegate is a parameter to
the find function okay now let's see how
we can make use of an anonymous method
here okay so what did we discuss what is
an anonymous method anonymous methods
are introduced in c-sharp too and they
provide us a way of creating delegate
instances without having to write
method now what did we do here we wrote
a separate method first and then we
created an instance of a delegate that
delegate is pointing to that method and
then we are passing this delegate as an
argument to this fine method instead of
having all the step one two and three we
can write this code in one line and
eliminate you know all these steps okay
so let's see how to achieve that using
an anonymous method and you have that
here look at that
you know this fine method is actually
expecting a delegate to be passed and we
do that by using a delegate keyword so
this one right here is an anonymous
function so we want to return an
employee object which has got an ID of 1
0 2 and look at that we are using
delegate keyword here and then we have
employee X and then we are basically
saying return X dot ID you know equal to
1 0 2 so this is an anonymous method so
we create anonymous methods using
delegate keyword okay and you know let's
actually look at that in action
so let's comment out this part we don't
require that anymore let's comment out
step 2 as well we don't have to
explicitly create an instance of a
delegate and within step 3 what are we
going to do we are going to make use of
the delegate keyword so delegate and
this delegate what does it expects it
expects an employee object so we are
going to pass that and here what are we
going to do so this is like a method
body we are implementing you know the
logic here so what do we want to do we
want to return employees such that
employee ID must be equal to 1 0 2 and
done so all that code is gone so here
this one is an anonymous function notice
that it doesn't have any name it just
has the body okay it's just like a
function so if we knock this out and
look at that this is a function
right let's go and run this and see if
we get the same output look at that the
same output okay so basically anonymous
methods provide us a way of creating
delegate instances without having to
write a separate method alright they're
also useful if we are subscribing for an
event handler now to understand that I
have a Windows forms application here so
I have just created a new windows forms
application I have formed one here now
let's view the code of this form one and
within form one load even what we're
gonna do is create control dynamically
let's create a button control so let's
call it button one okay so button one
equals new button and button one dot
text equals let's say the text on my on
that button we want it as click me and
when we click the button something
should happen so button one dot click so
look at this now you know when we click
the button you know there should be an
even handler so to this click even
handler when we click the button you
know this is what is the even handler
method that gets executed okay and let's
say all we want to do is display hello
within a message box so message box dot
show let's say hello you just clicked me
all right so let's go ahead and run this
and make sure it works as expected
and by the way we need to add that
button to the form controls collection
so this this refers to in this case form
one so two its controls collection
property add our button one control so
we are dynamically adding the button one
control here so let's go and run this
click the button look at that hello you
just clicked me now again look at this
here we are creating an instance of a
delegate and this delegate constructor
is you know taking a method name here as
a parameter
so this delegate is pointing to this
function now do we really have to do
that now you can make use of anonymous
method if you want to if if you don't
plan to use this method let's say for
example anywhere then you know you can
you know create that as an anonymous
method here if you want to okay so let's
go ahead and see how we can replace you
know this with an anonymous method so
this stuff you do it button 1 dot click
again look at that we are using the
delegate keyword and then you know
obviously if you look at this event
handler delegate here if we right-click
on that and go to the signature so this
even handler delegate is returning wired
and expecting two parameters of type
object and eventargs
so what we're gonna do is and we create
a delegate we specify the parameters are
going to be these two so right here will
simply say delegate and then pass these
two as the parameters and then they're
they're going to have this code and you
know we got a compilation error here
that's basically because you know with
this form load event we already have
parameters with similar names
so let's actually call this send and
let's call this event args for example
okay so that we don't have that
compilation error all right now we can
get rid of this button one underscore
click method all together now so let's
go and run this click the button notice
that it still works the same way okay
now again here we are using anonymous
methods now look at this this delegate
now is expecting two parameters okay now
do we really have to pass these
parameters here because if you look at
the implementation we are not making use
of those parameters so it doesn't really
make sense to pass them there so what's
gonna happen if I get rid of these
parameters
let's run this and see if it works look
at that it still works okay so basically
the delegate parameters are optional and
that's what is described here so with
with anonymous methods delegate
parameters are optional okay which means
this code can be returned like this
that's it for today thank you for
listening have a great day