Part 60 C# Tutorial Difference between String and StringBuilder Video Lecture

hello welcome to playing technologies I
am bring kit this is part 60 in this
session we'll understand the difference
between the strings of type system dot
string and system dot text string
builder in fact the difference is very
simple strings of type system dot string
are immutable whereas strings of type
string builder are mutable okay so what
do we mean by mutable and immutable
let's understand with an example and
then we'll understand the advantage of
using string builder when heavy string
manipulation is involved okay let's say
I have you know a simple program like
this string let's say use a string
variable and initially I'm actually
initializing this to c-sharp let's say I
want to print a word c-sharp video
tutorial for beginners you know the way
I can do is you know I initially
initialized that to c-sharp and then
maybe I will concatenate that again plus
equals maybe we will say c-sharp video
and you know you can concatenate them
like this
so obviously what we are doing here is
we are manipulating this string object
we are changing the string object many
times so c-sharp video tutorial and
maybe here and maybe here so if you look
at this you have changed the string
almost five times initially you have
initialized that to c-sharp and then
change that to c-sharp video by
concatenating this word and then c-sharp
video tutorial for beginners so one two
three four five
you are basically changing the state
same string object five times so what
actually happens when you change it five
times okay this is what happens in
memory look at this when you first
initialize the string this does use this
variable user string to see shop what
happens this variable gets created this
reference variable gets gets created on
the stack which will be pointing from
the c sharp object initially and you
wouldn't have all these objects okay
so it will be pointing to this and then
when we have this line use a string is
equal to use a string plus video and
when we have this line so what's going
to happen you know this object this
reference variable now is pointing so as
soon as this line gets executed what
happens the reference variable you know
will no longer point to this object it
will instead create another new string
object because this string once created
this object once created it's immutable
meaning you cannot change the table
shipped in memory there instead when
this line gets executed what actually
happens is this object you know will
remain there in the memory another new
string of objects get created this value
this value within this object will be
copied over and to that this word will
be concatenated you know in this new
object okay so now your reference
variable will point will be pointing to
this object
but then when it encounters this line
what happens even this object is
discarded in the sense your reference
variable will no longer point to that
object it will now be pointing to this
object copying that value and then
tutorial word together and then forms
this new string object so it goes on
okay so here if you look at this we just
manipulated it five times and we ended
up with how many objects five objects
and food are actually thrown away I mean
they are not used at all but they still
remain in memory you know they occupy
the amount of memory they occupy okay so
when will they be cleaned and who will
clean them garbage collector so until
the garbage collector runs you know
these objects are going to stay in the
memory on the heap and you know there is
going to be memory pressure for your
program so obviously any time you know
when you when you manically its trained
over and over and over again you will
have so many objects created here we are
changing the string object five times so
we have four orphaned string objects
orphaned meaning there is no reference
variable point into the
objects that's why these are considered
garbage and they will be clean when the
garbage collector runs okay but this
object is not garbage why because there
is a reference variable pointing to it
at this point you know pointing to this
object so when somebody says you know
print the value that is contained in
user string variable what happens it
goes and checks what is the value in
this object pulls that value and print
set okay so this object is not garbage
but all these are garbage
so since strings of type system dot
string are immutable they cannot be
changed once created that is what is the
meaning of immutable okay but whereas
strings of type string builder are
mutable meaning no matter how many j
times you change your string builder
object
you wouldn't get new objects the same
object will be changed in memory so even
if you change the object ten thousand
times you will still have only one
string builder object you don't have lot
of you know garbage objects or orphaned
stringbuilder objects because why it can
be changed it can be it's mutable
changeable over time but whereas strings
of type system dot string are immutable
you cannot change them once created if
you have to change them then what
happens that object will be discarded
another new object gets created which
the value and your reference variable
anomie point into that new object so
that's how strings of types is to not
strain get change they are immutable
okay so we can rewrite I mean actually
if we print this as you expect we get
that C sharp video tutorial for
beginners message so let's print that so
as we expect we get that now to make
this program a little more efficient
what you can actually do is use string
builder object okay so instead of using
you know the string we use string
builder and string builder class you
know this
class is actually present in system
namespace but whereas stringbuilder is
present in system nor text namespace so
let's include that and then instead of
using string I'm gonna say string
builder okay so user string is equal to
new string builder and there are several
overloaded versions of this constructor
so I'm going to use the version which
takes in a string object and create that
and obviously if it is a string builder
object you cannot use plus equals to
concatenate those strings instead what
you need to do is there is a method
called append so we need to use that
append method so when we use the append
method we can concatenate the strings
together let's do the same thing for the
other things to be here
you
okay and finally if you want the string
representation of that string builder
object we use the two string method and
now when you run this program as you
might expect there wouldn't be any
change in the output except that we have
a program built a little better now it
doesn't create unnecessary you know
string objects the orphaned string
objects so anytime there is heavy
manipulation of strings involved always
use string builder rather than strings
because it's good for performance you
don't end up the plot of Earth and
string objects on the heap so a string
builder objects are mutable they offer
better performance than string object so
type system not strain when heavy string
manipulation is involved okay just
imagine I just want to show you a very
simple program let's say I have a
program like this maybe string user
string is equal to string dot empty
initially we are creating an empty
string so one string object gets created
in the heap and then there is a loop
like this for int I is equal to one
maybe I less than or equal to 10,000 I
plus plus and what we are basically
doing here is user string plus equals
you know I want to add that the number
and then a space so what's going to
happen now we are going to add numbers 1
space 2 space 3 space for until 10,000
into the string variable and finally we
will just print that now as you might
expect now since strings of type system
not strain'd are immutable how many
objects do you think gets created there
are like 2,000 I'm in 20,000 10,000
objects get created ok 10,000 won in
fact because we have this object already
created here and out of these 10,000 one
objects we will use only one string
object the other 9999 or objects or
10,000 objects or our friend
we no longer use them they are just
there sitting and floating on the hip
waiting for the garbage collected to run
and destroy them until then the program
will be under severe memory pressure so
when we run this you know as you might
expect it prints those numbers but just
imagine how many you know orphaned
string objects get created on the heap
so that's why when heavy string
manipulation is involved always use
strings of type system or text string
builder rather than strings of type
system string so brief up in summary you
know there are basically three
differences between system not string
and system dot text string builder okay
strings of type system not string or
present in systems of string namespace
where a string builder is present in
system dot txt or string builder
namespace and one of the main
differences is strings of type system
constrained are immutable
there are string builder strings per
mutable and because of which we have
better performance using stringbuilder
objects over system not string if there
is heavy string manipulation as involved
so this diagram should give you a very
good idea about what we mean by mutable
and immutable immutable means you can
change them in place those objects can
be changed once created there as
immutable means they cannot be changed
if you have to change them you have you
will end up creating another object on
this slide you can find resources raised
before Ned and c-sharp interview
questions that's it for today thank you
for listening have a great day