Part 27 - C# Tutorial - Properties in C#.avi Video Lecture - C sharp Enhance

hello welcome to presume technologies
I'm rented this is part 27 properties in
c-sharp in this session we'll be looking
at read write read only and write only
properties we'll also be looking at
author implemented properties which are
introduced in c-sharp 3.0 in the
previous session we have seen how to
protect class files using public getter
and setter methods in this session we
will do the same thing using properties
if you haven't watched my video session
on why properties are required I would
strongly encourage you to do so before
continuing with the session because
we'll be using examples from our
previous session so let's look at that
example in the previous session we have
designed a student class with three
private fields and to protect and then
capsulate these fields we have used the
respective public get and set methods
okay for example to read and write this
private field ID we are making use of
set ID and get ID methods okay so now
how do we do that using properties in
c-sharp okay to do that there is a
slight modification that we have to do
we know that ID field is actually an
integer so public end and you don't have
to have a parameter passed N and what
you need to have instead is a get and
set accessor since this is set
they're gonna call this set and a get
accessor so what does the gate access
are going to do it is simply going to
return the ID so this under school ID
and look at this so public and instead
of calling it a set ID will call it as
if you know ID so the property name is
ID and we are saying okay if somebody
sets the value let's say for example how
do they set it so
like see one dot ID look at that it's
appearing as if it's a field ID let's
say if somebody sets it to one zero one
what's gonna happen this one zero one
gets passed into this property and the
set accessor will be called because we
are setting the value and then how will
it be check there is a built in keyword
called value okay so this value will
contain one zero one which are which we
are assigning to this property so this
one zero one actually gets passed into
this keyword so if 1 0 1 is 1 0 1 less
than or equal to zero that's false so it
comes here and this dot ID equal to
again value so this is what is the
disconnect that you have to understand
the value keyword is the one which will
receive the value that be set to this
property okay so in this example we are
setting the ID to 1 0 1 so this 1 0 1
value gets passed into this keyword okay
so we use that if somebody passes 500
that gets passed again to this and since
we are setting the value the set
accessor gets invoked and similarly if
somebody is trying to print the value
how they would do that console.writeline
c1 dot you don't have to use cat ID
anymore c1 dot ID so now the c-sharp
will automatically understand that okay
somebody is trying to pull the value out
of this property so what happens is it
invokes this ID property and somebody is
trying to read the value so it didn't
works the get accessor of this property
and returns the value which is there in
that private fear so pretty simple right
and the advantage of using this property
is look at this it's not like a method
you use the properties as if they are
fears
but on the other hand when we had set ID
we had to call it like a method so
there's no need to make use of the set
ID or get ID methods anymore instead we
use this property public entirely and
the same is the case we do for name okay
so what we do since name is of type
string it's a public string and give it
a meaningful name maybe a name is the
property and we get rid of that
parameter and a property will have a set
and a get accessor so set X's are
and a cat accessor so what will the get
accessor do it will simply return the
value that is present in the field now
it doesn't simply return that it has to
do this check so what we can do in the
get accessor will have this logic if you
remember this is the ternary operator we
are checking okay if this dot name is
null or empty then return no name else
written whatever is there in that name
feel okay so we can get rid of this cat
name now so what we are doing is we are
getting rid of the getter and setter
methods which were which we introduced
and we are using properties instead okay
so now we have to make use of that value
keyword because that's what receives the
value which people set to this property
all right so that's about name and then
this is interesting now look at this
this name property it has got booth set
and get accessors meaning this is a
read/write property somebody can assign
a value to this property which in turn
will assign that value to the field and
somebody can read the value from this
property so it's a read/write property
if it has got get and set accessors it's
a readwrite property but if you remember
from a previous example we wanted the
pass mark field to be a read-only fear
okay so if you want a field to be
read-only you want your property also to
be read-only so what you do you only
have the get accessor you will not have
the set accessor so in that case it
becomes a read-only fear okay so how do
I do that again get passed mark instead
of that we will just say passed mark
and we don't have to have that
parenthesis because this is a property
and all we will have is a get accessor
that's it and we return that so now what
we have done in this example is we
replaced all the getter and setter
methods with properties with get and set
accessors and if you look at this
example we have to read right property's
name and ID or read/write properties
because they have got getting set
accessors whereas passmark is a
read-only property because it has got
only the get accessor okay so let's go
ahead and see how to use that so we
don't have to have set name anymore
instead see one dot name is equal to
maybe mark and past mark I I will not be
able to set look at that if I try to set
past mark to maybe 35 or 34 whatever
look at this I get a compilation error
immediately and if you hover the mouse
over that you see property student that
Pathmark cannot be assigned to it is
read-only because why when we try to
assign a value passed mark property
right click on that and when I say go to
definition look at this property it has
got only the get accessor it doesn't
have the set access so you can't set a
value to that you need read value from
that feel so that's why this is a
read-only field so very simple to make
it property read-only just have the get
accessor remove the set accessor that
makes it read-only and similarly if you
want to make a property right only then
you knock off the get accessor and have
only the set accessor that makes it
right only you can only you know write a
value or set a value but you cannot read
value from that property
so that's that so now if I want to go
ahead and print that look at that get
name is like a method we don't have to
rely on getter and setter methods
anymore
instead we use the properties and look
at these properties I use them as if
they are fields and similarly if I want
to use the pass mark dot plasma and look
at this now I don't get a compile error
because the run time is is good enough
to understand okay somebody is trying to
read a value no because it doesn't have
an equal to here it has an equal which
means we are trying to set a value so I
think it makes you know that decision
based on that and it's trying to read
the past Mach value here and since the
past my property has a get accessor it
will be able to do that so when we go
ahead and run that the program works
exactly the same except that we using C
char properties instead of the getter
and setter methods okay so if we go back
to the slides in c-sharp encapsulate and
protect fields we use properties instead
of the getter and setter methods we use
getting set accessors tree implement
properties a property with both get and
set accessor is a readwrite property a
property with only get accessor is a
read-only and a property with only a
write with the set X is a write only
property and the advantage of using
properties with traditional get and set
methods is that you can access them as
if they were public fields and another
important concept that got introduced in
c-sharp 3.0 is auto implemented
properties because many a times you know
you may not have any logic like this for
example here we are validating the name
fear and here we are validating you know
the student ID should not be negative
but many a times let's say for example
maybe I have
private string that maybe underscore
City where the customer is living and
maybe private string underscore email
etc now if I have to implement
properties for this then I have to type
public string and maybe city and then I
get access I can't return this dot
underscore city and similarly we need to
have the set accessor it will set you
know maybe this dot underscore city is
equal to value okay and if I have to
implement the email then I have to do
public since that is also a string
public string email and then we need to
have a get and a set accessor in the get
accessor we will say return this dot
under school email and then the set
access herb will say this dot underscore
email is equal to value so I mean for
any properties that hasn't got any logic
in the get or set access uh you know
this is a lot of code and in reality you
know the objects are huge you know they
will have city state gender etc and most
of them we don't have to have any kind
of validation happening so in those
cases this is a lot of cool which we
have to write so that's why what they
have done is in c-sharp 3.0 they have
actually implemented or - implemented
properties let's look at an example of
how to do that so so for the city
private feel and for this email private
field if we have to convert them to
properties I need to have you know these
many lines of
but what we can do with Otto implemented
properties is you don't have to have two
private fields and then implement the
properties simply what you can do you
can get rid of those two fields and
obviously when you get rid of them you
get this warnings and then what you can
do is you can get rid of all this
implementation and you can simply say
get and set
similarly get and set so what's going to
happen behind the scenes is that you
know the compiler will create for us
automatically a private field and then
this property will be used to read and
write to that problem that private fear
okay so if you have you know 50
properties which doesn't have any logic
within them with the get and set
accessors you can make use of the author
implemented properties which will reduce
the amount that you have to write and
for implemented properties the compiler
will automatically create the backing
private fields for us okay so if you
want to get the size even reduced you
can actually format that you know
something like that get and everything
comes you know in one line anyway so
just like that you can format this as
well so it's just one line so if there
is no additional logic in the property
accesses then we can make use of how to
implement it properties introduced in
c-sharp 3.0 or implemented properties
reduce the amount of code that we have
to write when you use auto implemented
properties the compiler will create a
private anonymous field that can only be
accessed you properties get and set
accesses
that's it for today thank you for
listening have a great day