Back-End Programming Exam > Back-End Programming Videos > C sharp: Enhance your Skills (English) > Part 39 C# Tutorial Multicast Delegates in C#
Part 39 C# Tutorial Multicast Delegates in C# Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming
FAQs on Part 39 C# Tutorial Multicast Delegates in C# Video Lecture - C sharp: Enhance your Skills (English) - Back-End Programming
| 1. What is a multicast delegate in C#? |  |
Ans. A multicast delegate is a delegate type that can hold references to multiple methods. When a multicast delegate is invoked, all the methods it holds are executed in the order they were added.
| 2. How do you declare and use a multicast delegate in C#? | |
Ans. To declare a multicast delegate, you need to define a delegate type that can hold multiple methods. For example:
```
delegate void MyDelegate(string message);
```
To use a multicast delegate, you can simply use the `+=` operator to add methods to the delegate, and use the `-= `operator to remove methods from the delegate. For example:
```
MyDelegate myDelegate = Method1;
myDelegate += Method2;
myDelegate += Method3;
// Invoking the delegate will execute all three methods
myDelegate("Hello");
```
| 3. Can a multicast delegate return a value in C#? | |
Ans. No, a multicast delegate cannot return a value in C#. The return type of a multicast delegate must always be `void`. If you need to return a value from multiple methods, you can either use `out` parameters or define a separate delegate for the return value.
| 4. What happens if an exception is thrown by one of the methods in a multicast delegate? | |
Ans. If an exception is thrown by one of the methods in a multicast delegate, the remaining methods in the delegate's invocation list will not be executed. The exception will propagate up the call stack as usual.
| 5. How do you ensure that all methods in a multicast delegate are executed, even if an exception is thrown? | |
Ans. To ensure that all methods in a multicast delegate are executed, even if an exception is thrown, you can wrap each method call in a try-catch block. This way, even if one method throws an exception, the delegate will continue to execute the remaining methods. Here's an example:
```
MyDelegate myDelegate = Method1;
myDelegate += Method2;
myDelegate += Method3;
foreach (MyDelegate method in myDelegate.GetInvocationList())
{
try
{
method("Hello");
}
catch (Exception ex)
{
// Handle the exception or log it
}
}
```
Text Transcript from Video
- welcome to prism technologies I am
venket this is part 39 multicast
delegates if you want to learn the
basics around delegates then I would
strongly recommend you to watch parts 36
37 and 38 of this video tutorial in this
session we will be talking about
multicast delegates so what is a
multicast delegate a multicast delegate
is a delegate that has a references to
more than one function meaning a
delegate that is pointing to more than
one function when you invoke a multicast
delegate all the functions the delegate
is pointing to or invoked okay let's
look at an example and understand this
better so to create a delegate we use
the delegate keyword so first let's go
ahead and create a sample delegate so
let's say public delegate and the
written type delegate is void and let's
call it as a sample delegate and this
delegate doesn't take any parameters so
we are creating a very simple delegate
okay which has wide return type and
doesn't take any parameters now we know
that if we want this delegate to point
to a function that function needs to
have the same signature you know as this
delegate so let's go ahead and create
that function so let's say public void
and let's call this sample method one
and all this function does is go Ahead's
and prints a message to the console
saying that sample method invoked okay
so if you look at what we have done
until now we have just created a
delegate with wide return type and no
parameters and we created another method
you know with wide return type no
parameter the signatures match so this
delegate can point to this function so
how do we do that we create an instance
of this delegate and to the constructor
of the delegate we pass in the name
function and just a change we will call
the static function so that we don't
have to create an instance of the fridge
in class to invoke that function so now
we will create an instance of our sample
delegate let's say delegate is equal to
new sample delegate and to the
constructor we pass in the name of the
function to which we want our delegate
to be pointing to so in this case we
want this delegate to point to this
function so we will copy that and we
pass in that so now if we go ahead and
run this function let's invoke the
delegate okay so if we go ahead and run
this function now what what is going to
happen this delegate is invoked and we
know that this delegate is pointing to
this function so this method will be
invoked okay now how do we convert this
delegate into a multicast delegate
actually there are two ways to do it
so we look at approach one first and
then we will later examine approach to
in approach one what we will do is
instead of directly pointing you know to
a method like this we will create
several instances of delegates let's say
delegate one delegate to delegate three
and maybe delegate four as well okay
from the definition if you look at the
slide a multicast delegate is a delegate
that has references or pointers to more
than one function so if a delegate
points to more than one function then it
is called as a multicast delegate okay
so we want our delegate to be pointing
to more than one function so obviously
we need to create you know more than one
function which confirms to the signature
of this delegate so let's go ahead and
copy
you know this method and make three
copies so let's call the sample method
two
and the same is the message here sample
method too involved and sample method
three and we will call the sample method
three in volton okay so we have three
functions now and if you look at all
these three functions you know their
signature is the same as that of or
delegate so an instance of any instance
of this delegate del 1 del 2 del 3 or
del 4
okay any instance of the sample delegate
can actually point to any of these
methods now let's see how to do that so
what I'm doing is you know we have
sample delegate 1 so we will say
delegate 1 is equal to new sample
delegate and we'll make that point to
sample the sample method 1 and similarly
what we do we make delegate to point to
sample method 2 and delegate three point
two sample method 3 okay so what we are
doing here is assigning you know del 1
to sample method 1 Delta to sample
method 2 del 3 to sample with the 3 and
now what we will do is we will make
delegate 4 is equal to delegate 1 plus
delegate 2 plus delegate 3 okay now
there's a lot of code here but if you
understand that it's pretty simple what
we are doing is you're making delegate 1
point 2 sample method 1 delegate to 2
sample method 2 and delegate 3 to sample
method 3 and we're making delegate for
you know we're assigning delegate for
with by adding all these three delegates
together
you know what actually this does is
since delegate one delegate to and
delegate 3 points to sample one sample
to sample 3 respectively
and when you
Chane these delegates together using
this plus sign and assign it to delegate
for what you're doing effectively is
your delegate for now is pointing to all
of these three methods so now if we go
ahead and invoke delegate for what will
happen is it will invoke all these three
methods so if I go ahead and run this
sample method one invoke sample method
to invoke sample method three in book
now since this delegate now is pointing
to three other functions three different
functions this Dell four is called as a
multicast delegate so now a delegate
pointing to more than one function is
always a multicast delegate okay and how
do we make this delegate a multicast
delegate by chaining the delegates
together with the plus sign so if you
want to chain delegates together we use
the plus sign actually we can also use
plus equals we'll see that in just a bit
okay now let's say I don't want method
two to be invoked for example okay now
you can unchain or you can remove the
references using the minus key but now
let's say when I do del 2 minus del 2
okay so what we are effectively doing is
we are adding delegate two and removing
it so effectively delegate four is now
pointing to just delegate 1 and delegate
3 meaning it's pointing to delegate I
mean sample method 1 and sample method 3
but not sample method 2 because we are
removing it using the minus sign so if
we run this now we will only see the
output as sample method 1 and worked and
sample method 3 in worked ok so the
point to keep in mind here is if you
want to change the delegates together we
use the plus sign if you want to remove
those you use the minus sign ok and what
is the multicast delegate I delegate
that points to more than one function is
called as multigate multicast delegating
all right so now there is another way to
actually create a multicast delegate you
don't have to create so many instances
what you can actually do is let's say I
have a delegate te l is equal to new
sample delegate and
let's make this point to sample method
one so now our delegate is pointing to
sample method one not only to that one
we can also say by using plus equal
symbol okay this delegate now is
pointing to one function but I want this
delegate to point to sample method two
and sample method three as well so how
do we do that we can use the plus equal
sign with the same delegate instance
okay and then here you say sample method
two what is happening here is we are
using the plus equal sign to register
this method with this delegate okay so
in the previous example we have seen we
can use plus symbol when we use
different instances of the delegate but
if you want to use the same instance and
you still want you to delegate to point
to multiple functions then you use plus
equals okay to register you know when we
do this when we use this syntax what we
are technically saying is we are
registering this method with this
delegate and similarly the same is the
case if you pass it to the constructor
you are registering this delegate I mean
this method with this delegate okay so
if you want to register the fourth
method as well I mean the third method
as well you can do exactly the same
thing so sample method three and then if
you go ahead and invoke the delegate now
it's going to invoke method one method
to method three the same effect but we
are just using a slightly different
approach to do this okay so if you want
to use the same instance and register
multiple functions with this delegate
then we can use plus equals if you want
to make use of different instances then
you just use the plus sign so you can
either use plus or if you go back to the
slides you know you can either use plus
or plus equals to register a method with
a delegate now when you register a
method with the delegate those methods
are said to be in some kind of a list
called as delegates invocation list so
when you n walk the delegate okay I mean
specifically multicast delegate
a multicast delegate it works the
methods in its invocation list in the
same order in which they are added if
you look at this one we have added this
example method one sample method to and
sample method 3 so these these functions
will be invoked in that same order and
this is a multicast delegate why because
it's pointing to more than one function
right now alright and to remove a
delegate you can use minus equals in the
previous example we have seen we used
just a minus sign ok so now it's like
effectively our sample delegate delegate
instance is pointing to just method two
and three or method one so if I run this
now you will say method to invoke and
Method 3 invoked so basically to create
a multicast delegate you have two
approaches either using different
instances of that delegate or using the
same instance and then using plus equals
to register and minus equals to
unregister
a function from a delegates invocation
list ok now there is a you know there
there is a small issue here now in our
example if you look at this methods
these are wide methods in the sense
these methods doesn't return anything
and when you invoke the delegate all of
them will be called in that order in
which they are registered but now let's
imagine if our function is going to
return a value ok if the function
returns a value then what's going to
happen let's look at that
let's say I have two functions now first
of all if a function has to return a
value the function needs to have a
return type so I'm going to say this
function is going to return an integer
and all this function dash is returned
in number so return let's say 1 since
the return type of this function is
integer it's going to written 1 and same
is the case here this is going to return
maybe 2 so this function is
going to written one and this function
is going to return two now if we want
this delegate to be pointing to any of
these functions then this delegate
signature has to match this function
signature so let's say the signature of
the delegate you know we have enter it
and type okay so now what we are doing
is we are creating this delegate
instance and this delegate instance is
pointing to sample method 1 and we are
also registering sample method 2 with
this delegate and if you look at here
what we are doing is we are invoking
this delegate and when we when we invoke
this delegate what is the return type of
this delegate integer meaning this
delegate is going to give us an integer
back ok so let's say end a delegate
return value now if look at what what if
you look at what's happening here this
delegate now we'll go ahead and invoke
this method and this method when the
delegate invokes this method it will
return 1 we get 1 when it removes this
method it we get 2 okay and we are
saying ok whatever value is returned
store it in this value in this variable
now do you think will one be returned or
to be written now that's an interesting
question ok because a single variable
cannot hold two values and obviously if
it's a multicast delegate and if the
function returns a value you can only
harvest or you can only retrieve the
value that is returned by the last
function in the invocation list so in
this for this delegate in its invocation
list we have two methods method 1 method
true method 1 returns one method two
returns 2 and method 2 is the last
method in the invocation list so this
variable will hold value 2 ok so if we
go ahead and print that now
console.writeline
and if we just say delegate return value
is equal to a placeholder and then a
delegate return value and if we run this
program you should say the return value
is to 2 that is returned by sample
method 2 that is the last function in
the invocation list so if you look back
the slides if the delegate has a written
type other than void and if the delegate
is a multicast delegate only the value
of the last n work method will be
returned and along the same lines if the
delegate has an output parameter then
the value of the output parameter will
be the value assigned by the last method
let's look at an example to understand
that better now let's say my delegate I
mean my functions now are going to be
void return type but it's going to have
an output parameter so how do we have an
output parameter we use the out keyword
again if you're new to method parameters
there is a video session that I have
recorded please check that video
tutorial you know if you're new to
output parameters anyway so output
parameter end and let's call this number
and what this function does is
initialize that power output parameter
to a value let us say it it initializes
that to 1 and similarly our sample
method 2 is going to initialize that to
2 okay now again if we want our delegate
to be pointing to these functions
obviously it's signature has to confirm
to the signature of these methods so
let's change to do that and this
delegate takes in an output parameter of
type integer and let's call it s integer
okay now this delegate signature matches
the signature of these methods so this
delegate can point to these functions
and obviously what we are doing here
excuse me this delegate now is pointing
to this in this method
and this method both of the methods and
if you look at this method it
initializes the output parameter to one
and this method initializes it to two
and now let's say instead of saying
delegate return value let's call this
output parameter value okay and let's
initialize that minus one now when we
invoke this delegate when we invoke this
delegate we know that we have to pass at
an output parameter which is going to be
this one so we're going to say delegate
and it expects an output parameter to be
pass ten so we use the out keyword and
we pass in this variable which will
receive the value from these methods so
when we invoke this delegate what it's
going to do it's going to obviously
invoke this method and this method this
method initializes the number to one and
this is initializing it to two but we
can only get one value and that value
will be the value initialized by the
last method in our case the last method
is to in the invocation list of this
delegate so this method is initializing
that to two so obviously this output
parameter will receive the value of two
and what we are doing here is we'll
print that value so if we run this now
you should say the delegate output
parameter value is two so keep this in
mind this is very important you know if
the delegate has a return type other
than void
and if the delegate is a multicast
delegate only the value of the last
invoke method will be returned and along
the same lines the delegate has no
parameter the value of the output
parameter will be the value assigned
with last method in that invocation list
of the delegate and a very common
interview question generally asked us
you know we know what a multicast
delegate is a multicast delegate is a
delegate that points to more than one
function but what is the purpose you
know where do we use this multicast
delegates and in reality you know
they're this multicast delegates
actually makes the implementation of
observer design pattern very simple now
if you ask me do we really have to use
delegates to implement observer design
pattern you don't have to but delegates
makes it much easier in fact if you're
using multicast delegates you are
indirectly using observer design pattern
however we'll be talking about observer
design pattern in detail in a later
session okay and also remember this
observer pattern is also called as
publish/subscribe pattern these terms
are actually used interchangeably so
these are the two examples that we have
just seen in order to create a multicast
delegate there are effectively two ways
either creating multiple instances or
using the same instance if you are using
if you're creating multiple instances
you use the plus sign to change the
delegates together and minus sign to
remove them if you are using the same
instance you use plus equals to register
a method and minus equal to unregister a
method that's it for today thank you for
listening have a great day
venket this is part 39 multicast
delegates if you want to learn the
basics around delegates then I would
strongly recommend you to watch parts 36
37 and 38 of this video tutorial in this
session we will be talking about
multicast delegates so what is a
multicast delegate a multicast delegate
is a delegate that has a references to
more than one function meaning a
delegate that is pointing to more than
one function when you invoke a multicast
delegate all the functions the delegate
is pointing to or invoked okay let's
look at an example and understand this
better so to create a delegate we use
the delegate keyword so first let's go
ahead and create a sample delegate so
let's say public delegate and the
written type delegate is void and let's
call it as a sample delegate and this
delegate doesn't take any parameters so
we are creating a very simple delegate
okay which has wide return type and
doesn't take any parameters now we know
that if we want this delegate to point
to a function that function needs to
have the same signature you know as this
delegate so let's go ahead and create
that function so let's say public void
and let's call this sample method one
and all this function does is go Ahead's
and prints a message to the console
saying that sample method invoked okay
so if you look at what we have done
until now we have just created a
delegate with wide return type and no
parameters and we created another method
you know with wide return type no
parameter the signatures match so this
delegate can point to this function so
how do we do that we create an instance
of this delegate and to the constructor
of the delegate we pass in the name
function and just a change we will call
the static function so that we don't
have to create an instance of the fridge
in class to invoke that function so now
we will create an instance of our sample
delegate let's say delegate is equal to
new sample delegate and to the
constructor we pass in the name of the
function to which we want our delegate
to be pointing to so in this case we
want this delegate to point to this
function so we will copy that and we
pass in that so now if we go ahead and
run this function let's invoke the
delegate okay so if we go ahead and run
this function now what what is going to
happen this delegate is invoked and we
know that this delegate is pointing to
this function so this method will be
invoked okay now how do we convert this
delegate into a multicast delegate
actually there are two ways to do it
so we look at approach one first and
then we will later examine approach to
in approach one what we will do is
instead of directly pointing you know to
a method like this we will create
several instances of delegates let's say
delegate one delegate to delegate three
and maybe delegate four as well okay
from the definition if you look at the
slide a multicast delegate is a delegate
that has references or pointers to more
than one function so if a delegate
points to more than one function then it
is called as a multicast delegate okay
so we want our delegate to be pointing
to more than one function so obviously
we need to create you know more than one
function which confirms to the signature
of this delegate so let's go ahead and
copy
you know this method and make three
copies so let's call the sample method
two
and the same is the message here sample
method too involved and sample method
three and we will call the sample method
three in volton okay so we have three
functions now and if you look at all
these three functions you know their
signature is the same as that of or
delegate so an instance of any instance
of this delegate del 1 del 2 del 3 or
del 4
okay any instance of the sample delegate
can actually point to any of these
methods now let's see how to do that so
what I'm doing is you know we have
sample delegate 1 so we will say
delegate 1 is equal to new sample
delegate and we'll make that point to
sample the sample method 1 and similarly
what we do we make delegate to point to
sample method 2 and delegate three point
two sample method 3 okay so what we are
doing here is assigning you know del 1
to sample method 1 Delta to sample
method 2 del 3 to sample with the 3 and
now what we will do is we will make
delegate 4 is equal to delegate 1 plus
delegate 2 plus delegate 3 okay now
there's a lot of code here but if you
understand that it's pretty simple what
we are doing is you're making delegate 1
point 2 sample method 1 delegate to 2
sample method 2 and delegate 3 to sample
method 3 and we're making delegate for
you know we're assigning delegate for
with by adding all these three delegates
together
you know what actually this does is
since delegate one delegate to and
delegate 3 points to sample one sample
to sample 3 respectively
and when you
Chane these delegates together using
this plus sign and assign it to delegate
for what you're doing effectively is
your delegate for now is pointing to all
of these three methods so now if we go
ahead and invoke delegate for what will
happen is it will invoke all these three
methods so if I go ahead and run this
sample method one invoke sample method
to invoke sample method three in book
now since this delegate now is pointing
to three other functions three different
functions this Dell four is called as a
multicast delegate so now a delegate
pointing to more than one function is
always a multicast delegate okay and how
do we make this delegate a multicast
delegate by chaining the delegates
together with the plus sign so if you
want to chain delegates together we use
the plus sign actually we can also use
plus equals we'll see that in just a bit
okay now let's say I don't want method
two to be invoked for example okay now
you can unchain or you can remove the
references using the minus key but now
let's say when I do del 2 minus del 2
okay so what we are effectively doing is
we are adding delegate two and removing
it so effectively delegate four is now
pointing to just delegate 1 and delegate
3 meaning it's pointing to delegate I
mean sample method 1 and sample method 3
but not sample method 2 because we are
removing it using the minus sign so if
we run this now we will only see the
output as sample method 1 and worked and
sample method 3 in worked ok so the
point to keep in mind here is if you
want to change the delegates together we
use the plus sign if you want to remove
those you use the minus sign ok and what
is the multicast delegate I delegate
that points to more than one function is
called as multigate multicast delegating
all right so now there is another way to
actually create a multicast delegate you
don't have to create so many instances
what you can actually do is let's say I
have a delegate te l is equal to new
sample delegate and
let's make this point to sample method
one so now our delegate is pointing to
sample method one not only to that one
we can also say by using plus equal
symbol okay this delegate now is
pointing to one function but I want this
delegate to point to sample method two
and sample method three as well so how
do we do that we can use the plus equal
sign with the same delegate instance
okay and then here you say sample method
two what is happening here is we are
using the plus equal sign to register
this method with this delegate okay so
in the previous example we have seen we
can use plus symbol when we use
different instances of the delegate but
if you want to use the same instance and
you still want you to delegate to point
to multiple functions then you use plus
equals okay to register you know when we
do this when we use this syntax what we
are technically saying is we are
registering this method with this
delegate and similarly the same is the
case if you pass it to the constructor
you are registering this delegate I mean
this method with this delegate okay so
if you want to register the fourth
method as well I mean the third method
as well you can do exactly the same
thing so sample method three and then if
you go ahead and invoke the delegate now
it's going to invoke method one method
to method three the same effect but we
are just using a slightly different
approach to do this okay so if you want
to use the same instance and register
multiple functions with this delegate
then we can use plus equals if you want
to make use of different instances then
you just use the plus sign so you can
either use plus or if you go back to the
slides you know you can either use plus
or plus equals to register a method with
a delegate now when you register a
method with the delegate those methods
are said to be in some kind of a list
called as delegates invocation list so
when you n walk the delegate okay I mean
specifically multicast delegate
a multicast delegate it works the
methods in its invocation list in the
same order in which they are added if
you look at this one we have added this
example method one sample method to and
sample method 3 so these these functions
will be invoked in that same order and
this is a multicast delegate why because
it's pointing to more than one function
right now alright and to remove a
delegate you can use minus equals in the
previous example we have seen we used
just a minus sign ok so now it's like
effectively our sample delegate delegate
instance is pointing to just method two
and three or method one so if I run this
now you will say method to invoke and
Method 3 invoked so basically to create
a multicast delegate you have two
approaches either using different
instances of that delegate or using the
same instance and then using plus equals
to register and minus equals to
unregister
a function from a delegates invocation
list ok now there is a you know there
there is a small issue here now in our
example if you look at this methods
these are wide methods in the sense
these methods doesn't return anything
and when you invoke the delegate all of
them will be called in that order in
which they are registered but now let's
imagine if our function is going to
return a value ok if the function
returns a value then what's going to
happen let's look at that
let's say I have two functions now first
of all if a function has to return a
value the function needs to have a
return type so I'm going to say this
function is going to return an integer
and all this function dash is returned
in number so return let's say 1 since
the return type of this function is
integer it's going to written 1 and same
is the case here this is going to return
maybe 2 so this function is
going to written one and this function
is going to return two now if we want
this delegate to be pointing to any of
these functions then this delegate
signature has to match this function
signature so let's say the signature of
the delegate you know we have enter it
and type okay so now what we are doing
is we are creating this delegate
instance and this delegate instance is
pointing to sample method 1 and we are
also registering sample method 2 with
this delegate and if you look at here
what we are doing is we are invoking
this delegate and when we when we invoke
this delegate what is the return type of
this delegate integer meaning this
delegate is going to give us an integer
back ok so let's say end a delegate
return value now if look at what what if
you look at what's happening here this
delegate now we'll go ahead and invoke
this method and this method when the
delegate invokes this method it will
return 1 we get 1 when it removes this
method it we get 2 okay and we are
saying ok whatever value is returned
store it in this value in this variable
now do you think will one be returned or
to be written now that's an interesting
question ok because a single variable
cannot hold two values and obviously if
it's a multicast delegate and if the
function returns a value you can only
harvest or you can only retrieve the
value that is returned by the last
function in the invocation list so in
this for this delegate in its invocation
list we have two methods method 1 method
true method 1 returns one method two
returns 2 and method 2 is the last
method in the invocation list so this
variable will hold value 2 ok so if we
go ahead and print that now
console.writeline
and if we just say delegate return value
is equal to a placeholder and then a
delegate return value and if we run this
program you should say the return value
is to 2 that is returned by sample
method 2 that is the last function in
the invocation list so if you look back
the slides if the delegate has a written
type other than void and if the delegate
is a multicast delegate only the value
of the last n work method will be
returned and along the same lines if the
delegate has an output parameter then
the value of the output parameter will
be the value assigned by the last method
let's look at an example to understand
that better now let's say my delegate I
mean my functions now are going to be
void return type but it's going to have
an output parameter so how do we have an
output parameter we use the out keyword
again if you're new to method parameters
there is a video session that I have
recorded please check that video
tutorial you know if you're new to
output parameters anyway so output
parameter end and let's call this number
and what this function does is
initialize that power output parameter
to a value let us say it it initializes
that to 1 and similarly our sample
method 2 is going to initialize that to
2 okay now again if we want our delegate
to be pointing to these functions
obviously it's signature has to confirm
to the signature of these methods so
let's change to do that and this
delegate takes in an output parameter of
type integer and let's call it s integer
okay now this delegate signature matches
the signature of these methods so this
delegate can point to these functions
and obviously what we are doing here
excuse me this delegate now is pointing
to this in this method
and this method both of the methods and
if you look at this method it
initializes the output parameter to one
and this method initializes it to two
and now let's say instead of saying
delegate return value let's call this
output parameter value okay and let's
initialize that minus one now when we
invoke this delegate when we invoke this
delegate we know that we have to pass at
an output parameter which is going to be
this one so we're going to say delegate
and it expects an output parameter to be
pass ten so we use the out keyword and
we pass in this variable which will
receive the value from these methods so
when we invoke this delegate what it's
going to do it's going to obviously
invoke this method and this method this
method initializes the number to one and
this is initializing it to two but we
can only get one value and that value
will be the value initialized by the
last method in our case the last method
is to in the invocation list of this
delegate so this method is initializing
that to two so obviously this output
parameter will receive the value of two
and what we are doing here is we'll
print that value so if we run this now
you should say the delegate output
parameter value is two so keep this in
mind this is very important you know if
the delegate has a return type other
than void
and if the delegate is a multicast
delegate only the value of the last
invoke method will be returned and along
the same lines the delegate has no
parameter the value of the output
parameter will be the value assigned
with last method in that invocation list
of the delegate and a very common
interview question generally asked us
you know we know what a multicast
delegate is a multicast delegate is a
delegate that points to more than one
function but what is the purpose you
know where do we use this multicast
delegates and in reality you know
they're this multicast delegates
actually makes the implementation of
observer design pattern very simple now
if you ask me do we really have to use
delegates to implement observer design
pattern you don't have to but delegates
makes it much easier in fact if you're
using multicast delegates you are
indirectly using observer design pattern
however we'll be talking about observer
design pattern in detail in a later
session okay and also remember this
observer pattern is also called as
publish/subscribe pattern these terms
are actually used interchangeably so
these are the two examples that we have
just seen in order to create a multicast
delegate there are effectively two ways
either creating multiple instances or
using the same instance if you are using
if you're creating multiple instances
you use the plus sign to change the
delegates together and minus sign to
remove them if you are using the same
instance you use plus equals to register
a method and minus equal to unregister a
method that's it for today thank you for
listening have a great day
Related Exams
About this Video
|
4.90/5 Rating |
|
Oct 24, 2024 Last updated |
Video Description: Part 39 C# Tutorial Multicast Delegates in C# for Back-End Programming 2024 is part of C sharp: Enhance your Skills (English) preparation.
The notes and questions for Part 39 C# Tutorial Multicast Delegates in C# have been prepared according to the Back-End Programming exam syllabus.
Information about Part 39 C# Tutorial Multicast Delegates in C# covers all important topics for Back-End Programming 2024 Exam.
Find important definitions, questions, notes, meanings, examples, exercises and tests below for Part 39 C# Tutorial Multicast Delegates in C#.
Introduction of Part 39 C# Tutorial Multicast Delegates in C# in English is available as part of our C sharp: Enhance your Skills (English) for Back-End Programming & Part 39 C# Tutorial Multicast Delegates in C# in
Hindi for C sharp: Enhance your Skills (English) course. Download more important topics related with notes, lectures and mock test series for
Back-End Programming Exam by signing up for free.
Description
Video Lecture & Questions for Part 39 C# Tutorial Multicast Delegates in C# Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming - Back-End Programming full syllabus preparation | Free video for Back-End Programming exam to prepare for C sharp: Enhance your Skills (English).
Information about Part 39 C# Tutorial Multicast Delegates in C#
Here you can find the meaning of Part 39 C# Tutorial Multicast Delegates in C# defined & explained in the simplest way possible.
Besides explaining types of Part 39 C# Tutorial Multicast Delegates in C# theory, EduRev gives you an ample number of questions to practice Part 39 C# Tutorial Multicast Delegates in C# tests,
examples and also practice Back-End Programming tests.
|
Explore Courses for Back-End Programming exam
|
|
Signup for Free!
Signup to see your scores go up within 7 days! Learn & Practice with 1000+ FREE Notes, Videos & Tests.
Related Searches
mock tests for examination
,study material
,Summary
,Previous Year Questions with Solutions
,Semester Notes
,shortcuts and tricks
,Free
,Exam
,Viva Questions
,practice quizzes
,Important questions
,video lectures
,Part 39 C# Tutorial Multicast Delegates in C# Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming
,Objective type Questions
,MCQs
,Extra Questions
,Sample Paper
,past year papers
,Part 39 C# Tutorial Multicast Delegates in C# Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming
,Part 39 C# Tutorial Multicast Delegates in C# Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming
,ppt
;
Study Part 39 C# Tutorial Multicast Delegates in C# on the App
Students of Back-End Programming can study Part 39 C# Tutorial Multicast Delegates in C# alongwith tests & analysis from the EduRev app,
which will help them while preparing for their exam. Apart from the Part 39 C# Tutorial Multicast Delegates in C#,
students can also utilize the EduRev App for other study materials such as previous year question papers, syllabus, important questions, etc.
The EduRev App will make your learning easier as you can access it from anywhere you want.
The content of Part 39 C# Tutorial Multicast Delegates in C# is prepared as per the latest Back-End Programming syllabus.
|
© EduRev
|
Education Revolution
|
Follow Us
|
Signup to see your scores
go up within 7 days!
Access 1000+ FREE Docs, Videos and Tests
Takes less than 10 seconds to signup