Part 30 - C# Tutorial - Interfaces in c#.avi Video Lecture - C sharp Enhance

hello welcome to presume technologies I
am venket this is part 30 introduction
to interfaces in this session we'll
learn interface basics in the next
session we will talk about abstract
classes and the differences between
abstract classes and interfaces after
that we will find out the real time
scenarios where we can actually use
interfaces and abstract classes these
two of very very important concepts and
we use them a lot in life projects all
right so an interface is one of my
favorite subjects all right we know that
we create a class using class keyword so
to create an interface we use the
interface keyword and interfaces are
very similar to classes we know that a
class can contain properties methods
delegates events similarly an interface
also can contain them but only
declarations and no implementations so
let's see what we mean by that so to
create an interface we use the interface
keyword and let's say I want to create a
customer interface look at that
just before the customer name I prefixed
a capital letter I this is a common
naming convention ok interfaces in
general are prefixed with a capital
letter
I the interface names I mean ok now if
you don't give that we don't get the
compiler error but it is just a common
convention so if you look at that will
succeeded ok so the reason why we do
that is just by looking in the name you
can tell this is an interface and not a
class and if somebody is using that
interface somewhere let's say for
example I customers see one ok so just
by looking at the name you can see that
ok this is an interface and not a class
or a structure you know that's why we
use the capital letter I in the name of
the interface now I told you interfaces
can only contain declarations and no
implementations so for example let's say
I want to have a print method so I'm
saying void print and then I close the
method and the semicolon you cannot have
an implementation let's say for example
console dot write line
hello you cannot do this okay
if you try to do this you will get a
compiler error so let's go ahead and
build this okay and we clearly says the
error clearly says interface members
cannot have definition or implementation
they need to only have declarations so
an interface member should only have the
method declarations property
declarations etc but no implementations
okay so if you look at this interface
you know it has only declaration the
return type of the method the name of
the method and then a semicolon
without the curly braces and
implementation okay another important
thing to keep in mind is that interface
members it is an interface member so
interface members are public by default
okay and that does not mean you can use
a public keyword like this okay if you
try to do that and when you try to build
the solution get again a compiler error
saying that the modifier public is not
valid for this item so interface members
are public by default and you cannot
have an explicit access modifier we
haven't spoken about access modifiers at
we will be talking about them in a later
session but remember that on the
interface members you cannot have access
modifiers they are public by default
okay now
can an interface have feels no we know
that a class can have fields like int ID
or string name etc but an interface
cannot have a field so this is a field
and integer field now if I go ahead and
try to build that again we get a
compiler error stating that interfaces
cannot contain fields so remember that
as well
okay so we have this interface and this
interface let's say you know can be
implemented by a class a class can
inherit this interface so let's say for
example I have class customer and this
class is inheriting I customer interface
okay so now this customer class is
actually implementing this AI customer
interface okay now when a class inherits
an interface that class has to provide
implementation for this interface member
okay otherwise look at this if it
doesn't provide implementation and if
somebody says customer c1 is equal to
new customer and then when I say c1 dot
print
c1 dot pland you know we basically since
this class is inheriting from this
interface this method is available to
this class and if this class doesn't
provide implementation the interface did
provide implementation with this method
and if the class doesn't provide
implementation for that method then what
will this line do that's why any class
implementing an interface member it
could be a method property event
whatever if the class inherits that
interface it has to provide the
implementations of that interface member
otherwise we get a compiler error okay
now let's go ahead and you know try to
compile this let's get rid of these
lines if I try to build this
you will get a compile error stating
that customer does not implement
interface member print I customer dot
print okay so the interface will only
have declarations and those interfaces
are there for your classes or structures
to implement to provide implementation
for those interfaces you might be
wondering if the interfaces doesn't
provide any implementation then what is
the use of these interfaces don't worry
about that we will actually talk about
the real-time scenarios where we use
these interfaces in a later session but
for now let's understand the basics
around interfaces the rules around
interfaces okay all right
so this class has to provide the
implementations for this interface
member so in order to do that public
okay we need to use the access modifier
here wired and then the name of the
method now look at this the signature of
the method should exactly look similar
to the method in the interface for
example here I say instead of the same
signature if I say name here now this
method is different from this so the
compiler doesn't treat as if you are
implementing this print method here
because this print method signature is
different it has got a parameter here
but it doesn't have a parameter you know
in the interface declaration so if you
try to build this you will again get the
same error okay so that's why the
signature of the method in the class
should match the signature of the method
in the interface so now if we go ahead
and compile it will compile without any
issues look at that build succeeded in
the status bar okay so let's say for
example console dot write line and we'll
just put here interface print method and
then if somebody wants to create an
instance of this class what they can do
is customer c1 is equal to new customer
and c1 dot print
so if we go ahead and run that interface
print method okay so let's go back to
the slides so we know that we create
interfaces using the interface keyword
just like classes interfaces also
contain properties methods delegates
events but only declarations and no
implementations if you try to have an
implementation for an interface member
it's a compile time error
it's a compile time error to provide
implementation for any interface member
interface members are public by default
and they don't allow explicit access
modifiers and interfaces cannot contain
fields we have seen that as well if a
class a restructure inherit from an
interface it must provide
implementations for all interface
members otherwise we get a compiler
error in our example this interface has
just one method and this class is
implementing that interface and it has
to provide implementation for that map
method if there is another method or a
property or a name in your class still
has to provide implementation for that
member as well okay so if your class
implements an interface it has to
provide implementation for all the
interface members otherwise we get a
compiler error a class a distract can
can inherit from more than one interface
at the same time okay this is another
interesting and important concept
classes allow multiple interface
inheritance at the same time for example
if I have another interface let's say
interface I do and this is got you know
maybe public I to method oops
void I do method something like that now
this class can inherit from more than
one interface at the same time so this
class can inherit from this interface as
well and look at this to provide the
implementation of this method you don't
have to type it by hand visual studio
will actually give you a snippet to do
that implement interface I - there's
another option explicitly implement
interface I too will be talking about
explicit interface
in a later session so don't worry about
that so implement interface I do what's
going to happen is it will automatically
stop this method out in the class for
you without you having to type that okay
so a little bit of you know time can be
saved in terms of typing so what we can
do now is console dot readline I to
method just to know that okay now look
at this your class can inherit from
multiple interfaces at the same time
that's possible so if I go ahead and
build that it will happily build without
any errors but whereas we have seen in
classes and inheritance that a class
cannot inherit from more than one class
at the same time let's say you have this
class called class customer let's create
another class maybe class
sample and will not provide any
implementation okay basically we have
two classes one is customer class and
the other one is a sample class now can
my program class inherit from both of
these classes at the same time let's see
that customer and then I'm saying sample
okay so this class is basically trying
to inherit from customer and sample at
the same time let's go ahead and build
and see what's going to happen we get
the compiler error and base class
customer is less accessible okay that is
because of missing access modifier let's
put that there let's put this here as
well we'll come back to access modifiers
in a later session so let's go build a
solution so class program cannot have
multiple base classes customer and
sample it's not possible a class cannot
inherit from multiple classes at the
same time but whereas a class can
inherit from multiple interfaces at the
same time so multiple class inheritance
is possible I'm sorry it's not possible
whereas multiple interface inheritance
is possible okay so interfaces can
inherit from other interfaces a class
that inherits this interface must
provide implementation for all interface
members in the entire interface
inheritance chain let's understand what
we mean by that okay let's get rid of
these things here all right so let's say
I have two interfaces this is one
interface let's call this as I customer
and let's call this we have one
interface called I customer which has
got friend method and let's call this I
customer one let's call this I customer
two so we have two interfaces and let's
say this is Sprint one
and this is trend - okay so we have two
interfaces I customer one I customer two
and let's say I customer do actually
inherits from I customer one and then
let's say our customer class inherits
from I customer - so customer do
inherits from customer one and this
customer class inherits from this so
obviously print one and print two is
available to the customer class now look
at this
you know our customer class here is
actually inheriting from my customer do
so we need to provide implementation for
print - method so we can say public void
print - and then let's say
console.writeline 22 so now if we go
ahead and compile it will not compile
we'll get a compiler error why because
this customer class is inheriting from
my customer do so I customer - has got
this method so we have provided the
implementation from that method but I
customer - is inheriting from I customer
one and I customer one has got print one
so print one is available - I customer -
as well and since customer is inheriting
from I customer to customer - has got
now print one and print - to implement
so if an interface inherits other
interfaces and your class inherits from
this interface then this class has to
provide implementation for this member
dismember and if you look at this this
an interface inheritance chain okay and
this class is in inheriting from this
interface and that inheritance chain so
this class has to provide implementation
for all the interface members in this
interface in
heritance chain okay so if a class
inherits an interface and if that
interface inherits another interface
then your class has to provide
implementations of all the members in
that interface inheritance chain
otherwise we get a compiler error again
so let's go ahead and try to build this
and see what we get so it says that I
customer 100 print one is not
implemented by by this customer class so
obviously we have to implement that as
well so just make a copy of that we can
say print one and print one so now this
customer class is implementing both of
these methods and now we try to build
that the build succeeds okay look at
that pill succeeded now let's go ahead
and see how to use that so I can go
ahead and create a customer object
customer c1 is equal to new customer and
you can call both c1 dot print 1 and C 1
dot print 2 and you go ahead and run
that you get print 1 and print 2 as
expected
okay this is another important point
okay probably this is what we will use
in a real time scenario we cannot create
an instance of an interface but an
interface a reference variable can point
to a derived class object and look at
this we don't really have to my mug
these statements they make a lot of
sense you know we cannot create an
instance of an interface and that makes
sense let's say for example if I am able
to create an instance of an interface
for example we have this i customer 1
let us say cost is equal to when I say
new i customer 1 now look at this if I
am able to create an instance of this
interface an object of this interface
and this interface has got this print 1
method does that print is that print 1
method implemented no so when I call
this customer interface object 1
dot print 1 what will it do since there
is no implementation it cannot do
anything that's why it does not allow us
to create an in you know an instance of
an interface basically interfaces are
incomplete ok because they don't have
implementations you know if you create
objects and if you are able to use them
they cannot do anything that's why the
language doesn't allow us to create
instances of interfaces and abstract
classes as well which we'll be talking
about in a later session ok so you
cannot create an instance an object you
cannot new up an interface but what you
can do is in the last session we have
actually spoken about the difference
between an object reference variable and
the object itself okay if I say customer
c1 is equal to new customer c1 is
actually an object reference variable to
an object on the heap
similarly here cust is a reference
variable of type I customer one but what
you can do here is you can say new
customer
okay now customer class is actually
inheriting from that interface customer
is inheriting from I customer to and I
customer to is inheriting from my
customer one which means for customer I
customer one is also a parent ok and in
the inheritance in class inheritance
chapter we have learned that a parent
class reference variable can point to a
child class object similarly since an
interface is over since this I customer
one is a parent to a customer class a
reference variable of I customer one can
actually point to customer object that's
why we are able to do this i customer
cost is equal to new customer now when I
say
dot I will only see the print one method
because why I customer one is of type
sorry caste is of type I customer one
okay so that's another important concept
to keep in mind very very important so
we cannot create an instance of an
interface but an interface reference
variable can point with derived class
object and we have already seen that
interfaces names are generally prefixed
with capital I as I told you in the next
session we will actually be talking
about abstract classes and the
differences between interface and
abstract classes after which we will see
the real-time application of these
abstract classes and interfaces on this
slide you can find resources for asp.net
and C sharp interview questions thank
you for listening have a great day