Part 31 - C# Tutorial - Explicit interfaces implementation.avi Video Lecture

- welcome to prism technologies I am
venket this is path 31 explicit
interface implementation in the previous
session we learned basics around
interfaces in this session we will
understand explicit interface
implementation let's look at an example
let's flip back to visual studio in the
previous session we have understood that
we can create an interface using
interface keyword let's say I want to
create interface I 1 and this interface
is going to contain a member called
interface method and we know that
interface members cannot have access
modifiers and they are public by default
and interfaces cannot have
implementations only declarations okay
now if this program class implements
this interface I 1 then the program
class has to provide implementation for
that interface method so let's go ahead
and provide the implementation so public
void interface and I'll just avoid any
errors in typing let's copy that and if
your class is implementing the interface
member the signature has to match
exactly to that of the method signature
in the interface now so let's go ahead
and implement this so console dot write
line let's call this I 1 interface
method ok and we know that in order to
crew in work this method we can create
an instance of a program class
and we can just say P dot interface
method this is what we have learned in
the previous session okay so an
interface contains uh you know a method
declaration with your class in you know
your class is going to implement that
interface and then you can create an
instance of that class invoke that
interface method we have seen this in
the previous session now let's say I
have another interface interface I do
and it happens to that even this
interface has got a method which is
exactly similar to I one okay and your
class is inheriting from both of the
interfaces okay now this class is
inheriting from i1 and i2 and if you
look at I one it has got interface
method and I do it has got interface
method which is exactly similar and a
class is inheriting both the interfaces
and now this class has provided
implementation for the interface method
now which one of the method do you think
you have implemented here are you
implementing a one interface
I mean interface one method or interface
two methods so there is an ambiguity but
visual Schramm in the.net thinks that
the class has implemented both of the
methods okay you know when it looks at
this okay all right this program class
has satisfied you know the rule that
interface method needs to be implemented
if you look at this the signature is
similar to this and this okay so both of
the interfaces think okay the class is
implementing this interface method so it
doesn't give us any compile time error
so if I go ahead and build that you
don't actually get a compiler error but
then when you actually print this you
know when I say P dot interface method
which method am i calling there is no
clarity on that okay so this there's
definitely a little bit of confusion so
obviously if a class is inheriting from
two interfaces and if those interfaces
have got same method names then it makes
sense
you know to use explicit interface
implementation so that we know which
interface method we are calling okay
for example if I do this look at this if
I want to call let's say interface one
method to be a little clearer I can say
P and then typecast that to interface I
one
using the typecast operator and then we
can go ahead and invoke the interface
method now since we are typecasting this
object into interface one and we call
interface method we know that we are
trying to invoke this interface method
and similarly if I want to be in a
position to invoke interface to method I
can do this now look at this if I am
calling interface to method or interface
one method since we only have one
implementation you know only this
instance will be called and it doesn't
make sense you know it's a little
ambiguous here okay
so that's when we actually go for
explicit interface implementation and
the way we do it if you want to
explicitly implement this interface
method there are two changes that you
have to do one when you are explicitly
implementing an interface member you are
not allowed to use the access modifier
and number two you have to use the
interface name and then dot the method
name within that interface which you are
implementing so now this class is said
to be ex will explicitly implementing
interface one method similarly if you
want to do the same thing for your
interface too all you do is copy base
that and change this to I two and just
to make a difference you know print the
messages I to interface method call now
if you look at this okay we are saying
program P is equal to new program P
typecasted to be of type I one and then
we call interface method interface
method now if we go ahead and run
you can see that as expected interface
one method called end of its to method
call now by looking at your definition
of your class you can clearly say okay
this is the interface one method and
this is the interface to method why
because you are explicitly stating where
is this interface method coming from
okay but another thing to keep in mind
when you explicitly implement an
interface method one thing which you
cannot do is you cannot say P dot
interface method because you get this
when I say dot the intellisense doesn't
show interface method because you know
when I when I am in a position to say P
dot interface method which method should
I be calling so there will be definitely
ambiguity there that's why in a visual
studio will not I mean dotnet will not
allow you to do that and in case if you
try to do that just by copy pasting you
will actually get a compiler error look
at that come it does not contain a
definition for interface method okay so
when you explicitly enter in Plamondon
tur face member the only way to invoke
those explicitly implemented interface
members is through using the interface
reference variable and keep in mind
objects are different from object
reference variable here P is not an
object it is just an object reference
variable okay which is pointing to a
program object in the memory okay now
when we explicitly implement an
interface okay like
interface method in i1 or interface
method in i2 when we explicitly
implement them then the only way to
invoke them is to use the interface
reference variable you cannot invoke
that on the class reference variable
okay all right so that's called explicit
interface implementation so if you look
at it we have the same example here we
are using the explicit interface
implementation and it's pretty much the
same example that we have just seen okay
and we know that when a class explicitly
implements an interface member the
interface member can no longer be access
to class reference variable but only
through interface reference variable
look at this when we try to access this
interface method you can only access
that through the interface reference
variable you're typecasting DP you know
P variable to be of type interface 1 and
then calling the interface a method
similarly for interface 2 method and
then actually another way to do that is
instead of if you don't want to be
typecasting what you can actually do is
you can say interface I 1 is equal to a
new program because we know that from
from the concept of inheritance derive
the class up we cannot do that interface
maybe I 1 is equal to new program and
similarly you can say I 2 I 2 is equal
to new program and you can say I 1 dot
interface method and I 2 dot interface
method you can either do this or you can
type cast ok so let's go back so and
also to keep in mind when we are
explicitly implementing the interface
members you are not allowed to use any
access modifiers ok and in fact this is
a very common interview question if a
class inherits from two interfaces and
both the interfaces have the same method
name how should the class implement the
method for both the interfaces we using
explicit interface implementation ok and
there is a default implementation as
well what do we mean by default
implementation let's say for example I
want my class to have a default
implementation ok because when I create
an instance of let's say if I say
program P is equal to new program and
then when I say P dot
in the face method I should be you know
my default should be like interface one
method okay I want to make this
interface one method default in spite of
two interfaces having the same method I
want this method in this interface I
want to be default so how do we do that
it's very simple implement that member
normally and the other one which you
don't want to be default implement that
explicitly so what I mean by that is in
my class implementation I'm going to say
okay I'm going to implement the
interface one method normally so public
wide interface method so this class is
now implementing this interface one
method normally but whereas interface
two method is implemented explicitly
look at the interface name and no public
access modifier okay so now when I go
ahead and run this program
when I say program P is equal new
program P dot interface method it sees
this okay I need to invoke this method
it invokes that so here we are making
this interface method of this I one
interface default whereas this one is
explicit if somebody wants to call this
the only way they will be capable of
doing it is by typecasting so typecast P
to be of I I to type and then call the
interface method so first one we'll call
the interface one method and this one
the second line will call the interface
two method so when we go ahead and run
that we get the same so we can have we
can mix them default implementation and
explicit interface implementation so
obviously if you want to make one of the
interface methods the default then
implement that method normally and the
other interface method explicitly this
makes the default method to be
accessible through class reference
variable
all right on this slide you can see some
resources for asp.net and C sharp
interview questions that's it for today
thank you for listening
have a great day