Part 40 C# Tutorial Exception Handling in C# Video Lecture - C sharp Enhance

hello welcome to prism technologies I am
venket this is path 40 exception
handling in this session we will learn
the basics of exception handling let's
look at an example I want you to write a
c-sharp program which can read the
contents of a text file and display them
in the console window now in my C Drive
I have a folder called sample file so if
you look at this part in C Drive sample
files folder I have a file called data
not txt and if I open this notepad you
see that we have a message welcome to on
lines you should have training from
trading technologies now I want you to
write a c-sharp program which can read
the contents of this file and print them
onto the console and it's very easy to
do that so let's get back to visual
studio now if you want to read or write
to a file then we have to make use of
classes that are present in the system
aiyoo namespace input/output so let's go
ahead and import that using system dot
IO now within this system to Ryo
namespace there is a class called stream
reader class what this class basically
does is you know goes out to the file
and then reads the contents of that file
and then strange them out for us so
let's say stream reader let's create an
instance of that class stream reader is
equal to new stream reader and if you
look at the constructor of the stream
reader it takes backs the path of the
file whose contents you want to read ok
and we know that in C Drive sample files
folder we have a file called data dot
txt so we want to read the contents of
that file so let's go ahead and put that
so the name of the file is data dot txt
ok so this is the constructor expecting
and obviously you have a red squiggly
here because a backslash has special
meaning it's an escape sequence
character so you need to back
keep that with another backslash or you
can use the verbatim literal you know
whichever you choose you know here for
the valid Windows part and the web
batting literal looks good so let's go
ahead and use that so now what we are
doing here we created a stream reader
class which goes ahead and reads the
contents of this file and what we want
to do is read the contents to the end of
the file and if you look at the return
type of this method it's a string so we
can print that directly onto the console
screen so we pass this entire content
onto the console screen and this will go
ahead and print that all right and
finally we need to close the stream
reader okay what this clue statement
does if you look at the intellisense it
closes the same stream reader object and
the underlying stream and releases any
system resources you know any system
resources to which this class is holding
on to during the program execution dues
will be released you know maybe we call
this closed method okay let's go ahead
and run this when I run this you know
you expect this output welcome to online
C shop training from régime technologies
which is present in a notepad you
program and read that and print that out
on the console now everything is fine
you know you have the file you ran the
program everything is fine then why do
we need exception handling now what is
an exception an exception is nothing but
an unforeseen error that happens you
know when your program is executing
let's say you know somebody goes and
changes the name of that file or
somebody deletes that file what happens
when this program tries to read that
file it will throw an error because that
is unexpected you always expect that
file to be there but somebody changed
the name of it or somebody deleted it so
it's an unexpected you know unforeseen
error but your program should still be
in a position to handle even those kind
of unforeseen errors and that's where
exception handling comes in ok now let's
go ahead and actually change the name of
that file so let's say for example
somebody just came here they
the name of the file from data to one
data dot txt now if we run this program
look at what's going to happen we have
an unhandled exception and if you look
at the exception it is a file not found
exception okay so what did this program
did it tried to read the contents of
this file but in this C Drive sample
files directory there is no file called
data dot txt and the system through an
exception saying that okay I cannot find
that file anymore okay
now if your end-users looks at this
message okay unhandled exception system
that I file not found exception if
you're not from a dotnet background you
know obviously your end users will not
anything about dotnet so when they look
at this message it doesn't really make
any sense to them so to our end-users we
should actually be giving you no useful
messages now what are the problems of
not handling exceptions actually there
are several and the first and foremost
is that your end-users will see this
confusing and cryptic message which does
not make any sense at all so there is
definitely be annoyed by it messages
like this and they will never come back
to use your program again and the next
most dangerous I'd wear this advantage
of unhandled exception is that you know
the this exception information contains
valuable you know information to a
hacker okay you the hacker can use this
information to actually hack into your
application actually when we talk about
a do not net in that session we will
learn how to use exception and no
exception information to hack into an
application but just until then believe
me
exception information can be used by
hacker to hack into your application so
that's another disadvantage of not
handling exceptions okay and from an
application perspective another problem
is look at this it tries to read this
you know it tries to open this file and
read the contents of this file this
particular line okay now at this line we
got an exception so when that happens
what will basically happen is these two
lines will be skipped
and your streamreader will never be
closed so your resources you know if you
don't close the streamreader the
resources to which this class object is
holding on to is never released you know
that's why it's always good to use
exception handling okay so what is an
exception an exception is an unforeseen
error that occurs when a program is
running we have seen a very simple
example in a program trying to read a
file and if the file is not found you
know the program file not found
exception similarly if you if your
program tries to read from your database
table and if the table does not exist or
if the database is down or if you have
misspelled a column name then there will
be a sequel exception okay however these
are very unlikely but you still should
anticipate that menu program should be
programmed you know basically to handle
exceptional situations as well and
that's where exception handling comes in
and we also have seen you know if you
don't handle exceptions users will be
annoyed as their as they as the message
is they see or cryptic and doesn't make
any sense to them and exceptions contain
information that can be used for hacking
into your application and what is an
exception an exception is not something
strange it's actually an object you know
that is derived from system not
exception class let's look at that in an
example now too to handle exceptions we
use a construct called try catch finally
okay so try so in the try block you will
put the code which can possibly through
an exception okay so any any line within
this try block if it throws an exception
what will happen is let's say for
example at this line there is an
exception immediately what happens is
the compiler I mean the runtime will
skip executing these two lines and the
control will be you know jumping to the
nearest catch block in this case
the sketch block so these two lines will
be scared and then it comes into the
catch block let's say for example I want
to catch an exception so let's say e^x
okay so we are catching the exception
now if you look at this exception object
if I right-click on that and when I say
go to definition you will actually find
this is nothing but a class it last
called exception okay and if you look at
this class it has got several properties
for example message source stack trace
target side etc will actually be
investigating what this properties are
and what is the benefit of them okay so
now we have this exception object so
when there is an exception what happens
you know it immediately jumps into the
cache block and this exception object
receives you know that exception and
then you can basically use the
properties let's say for example I want
to know what is the message you can say
'hey x dot message okay and similarly
let's say for example i want to print
the message console dot readline e^x dot
message similarly if you want to look at
the stack trace let's go ahead and write
that console.readline extort stack stack
trace and just to kind of have some
space between them let's have a couple
of console write lines okay so now if
you look at this program we are actually
inspecting the message property and the
stacked a stack trace properly so if we
run this program now look at this it's
in the debug mode what is what it is
trying to do it's it's trying to create
a stream reader class the moment I do
that it tries to create the class object
and then it tries to read that file
which does not exist and there is an
exception so when we press f10 and if
you look at this object look at this
there is actually a system dot IO dot
file not found exception interesting
this object reference variable if you
look at this this is of type exception
but if you look at the actual object
that is thrown it is system that I you
got file not found exception okay we'll
come back to that in just a bit but now
if you look at the message look at the
message the message property will tell
you will give you a meaningful in a
message about the exception it's saying
not fine file whatever C equivalent
backslash sample files data similarly
you have the stack trace property to
look at the stack trace property what
will the stack trace property give you
it will actually tell you which line in
this program is actually throwing that
exception so if you look at this in
program dot C is file at line number 10
you know there is an exception okay so
if I if I close this and come to this
program and I said ctrl G and line
number 10 so it comes to this line so
obviously we have this exception here so
stack trace property will give you you
know the line number where actually the
program has caused an exception the
message property will give you a
meaningful message about that particular
exception okay so if if we let this true
and we have seen that actually the
object that is thrown is a file not
found object okay so what is that file
not found let's go ahead and say instead
of this one will actually use file not
found
so catch file not found exception let's
say X okay
so now let me go ahead and right-click
on that look at this file not found
exception okay this class is inheriting
from IU exception and if I right-click
on that one and say go to definition our
exception inherits from system exception
which in turn inherits from exception
class so
what I mean to say here is for all the
exceptions within the dotnet runtime
environment within the Dartmouth
framework you know they directly or
indirectly inherit from the exception
class and if you look at this exception
class it has got the message stack trace
source target site etc all these
properties are really valuable
you know debug and figure out the issue
so since any exception you know there
are several exceptions in dotnet
actually if you press alt control e in
Visual Studio it will actually show you
all the exceptions that are available in
dotnet framework and you know so
basically if you look at CL are
exceptions for example and if you look
at system there are so many exceptions
ok argument exception arithmetic
exception ok several exceptions are here
now any type of exception you know
directly or indirectly inherits from
system load exception class so system
load exception class is the base class
for all the exceptions that we have ok
so since all these classes are actually
inheriting from system load exception we
know that they are going to contain all
these properties as well message stack
trace etc ok so let's go back to our
program now filenotfoundexception now if
I go ahead and run this you'll actually
see that ok this is the message and this
is the stack trace information it's very
much similar ok
now file not found exception is actually
inheriting indirectly from exception
class now when you look at this file not
found exception object Y X dot apart
from you know the regulars things like
message stack true stack trace rules etc
there is another property called
filename since this is a file not found
exception so there is a specific
property on this object called filename
which will give you the information
about the file which is basically not
found but whereas if it is a general
exception class it will not have this
file name property because the base
exception class is is very generate and
this file and found exception it's
actually a child of that class which
specialized in part 21 inheritance
series we have actually learned that you
know a child class is basically a
specialization of its parent class okay
now let's say I mean what you basically
do is when you handle exception
you don't show this kind of messages to
the end user you know you use this
message stacktrace and whatever
properties and you write them either to
a database or you send an email to an
administrator who will come and look at
the exception and see how to solve that
okay but what you will actually do after
you log the exception details or email
them you will actually print out a
meaningful message to the user for
example I want to say please check if
the file exists and which file is that
you can say X dot file name because that
property of this exception object will
contain the file name which is not found
so if we run this now you should see
that please check in the file sequel and
sample files data dot ixt
XS okay so users are now getting a
meaningful message and you're handling
exceptions and basically about this line
you may log the details to the database
or even view or whatever for debugging
purposes later okay now let's do a
simple change here now let me change
this file name back to
data and if we run our program now it
will succeed but now let's make a simple
change instead of sample files let's say
somebody changed the name of the folder
itself from sample files to sample files
one now I think since the program is
using that let's change it here sample
one files ok now some reason for some
reason the directory name is changed now
if I run this program look at this it
tries to go to that part and read that
file but that part does not exist
meaning sample one files directory is
not present at all so now when I press
f10 look at this there is an exception
directory not found exception and if I
let this true okay let me run this once
again so when I run this look at this I
have an attached block to actually
handle the exception but this catch
block can only catch file not found
exception what type of exception did we
get now we get a directory not found
exception
so obviously this catch block will not
be able to handle that exception because
this is a different object reference
variable and what object is actually
this program throwing is a directory not
exception so obviously this e^x
reference variable will not be able to
catch that ok
so for these purposes you know there can
be a variety of different exceptions
depending on what your program is trying
to do and it may not practically be
possible to remember all the type of
exceptions so in general what we do is
move to the specific exceptions that we
can think of we will we will include
them and just to be safe we will also
include another catch block where we
specify the base exception type
and then maybe we will just say console
dot write line y X dot message so what's
going to happen now is when we run this
okay so could not find part of the path
C colon backslash sample a part of this
part you know we cannot find it it could
be filename but it would be directly
named whatever okay now if you look at
this one what happened the exception
that is thrown is actually if a
directory not found exception so at this
line a directory not found exception is
thrown it checks this catch block but
this cache block cannot handle a
directory not found exception it comes
to the next cache block which is of
parent type and we know that from part
21 inheritance session we know that a
parent class reference variable can
point to a derived class object and then
dotnet we know that any exception
directly or indirectly inherits from the
base exception class so this base
exception class is the parent for all
types of exceptions dotnet so obviously
this reference variable can point to any
of the desired you know child exception
classes class objects so that's how this
exception class is able to catch in fact
this is you know if somebody asks you in
an interview can you tell me a practical
application of inheritance this is a
practical application and evidence if
you want to handle exceptions properly
you know you will have more specific
exceptions on the top and the general
one at the bottom so that if there is
any other exception type we know for
sure this cache block will handle that
okay
so always remember that have the more
general one at the bottom and more
specific ones on the top your more
specific exceptions will have additional
properties for example file not found
exception has a file name property but
if you look at the base exception object
it will not have that because this is
base and very generate alright so points
to remember more specific exceptions on
the top and the most general ones I mean
the general exception at the bottom but
what happens if you do the other way
around if you do the other way around
you will actually get a compiler error
if you try to go ahead and build this
you will get and I look at this a
previous catch Clause already catches
all exceptions so obviously your general
exception has to be the bottom most
exception I mean catch block okay so
what is an exception it's basically a
class the device from system to
exception class the system hood
exception class has several useful
properties that provide valuable
information for example the message
property and the stack trace property
which you know gives us the call stack
to the line number in the method where
the actual exception occurred and we
have seen how to use the try and catch
blocks and we we have also seen that you
know we need to have the more specific
ones on top and the general one at the
bottom and if and there is another one
called finally now here if you look at
this particular piece of code this is
still problematic why because if there
is an exception here in this line for
example what happens you have the stream
reader object created and this line will
never get executed because there is an
exception here so what happens it comes
to one of the cache blocks it will catch
that and the program terminates you are
never closing the stream reader okay so
this line never gets executed and the
resources are not released that's why it
is always important to release the
resources only in the finally block why
because the finally block is guaranteed
to execute a respect you off whether
there is an exception or not so if there
is no exception this line this line gets
executed it comes to the finally block
closes the stream reader without any
problems okay if there is an exception
it comes either to this catch block or
this catch block finishes that and it
will still come to finally block closest
that so irrespective of whether there is
an exception or not you're finally block
is guaranteed to execute that is why you
should always be releasing resources in
the finally block so let's go ahead and
put this here and correct this so that
we don't get an exception and just to be
sure it is coming to the finally block
let's put a message there
console.writeline
finally block okay just so that we know
a finally block is getting executed okay
so now what happens there is no
exception
so this line this line gets executed
even the finally blocks get it block
gets executed close the stream reader
and it will print this message finally
block so let's run this now so you see
that welcome to this the message from
the notepad and finally block executed
which means even stream reader dot
clothes got call now on the other hand
let's put an exception let's say data
one so what happens
data one file does not exist so
obviously it tries to execute this line
there will be an exception it will come
here and then you know this cache block
will handle that exception and finally
block will flows that let's run this
oh there is another unhandled exception
you know why this happened because it
came to finally block it tried to close
streamreader but then if you look at
this the exception that we had is
actually in this slide so when I tried
to create that streamreader
that's when we got the exception so
streamreader will always be na ok so if
it is null we can't definitely close it
that's why you need to check if
streamreader
not equal to null then plus that that
makes more sense so now if we run this
program look at this please check if
this file exists and then finally block
so irrespective of whether there is an
exception or not you're finally block is
guaranteed to exit execute that's why
it's always a good practice to have your
you know cool to release resources in
the finally block and actually you know
some people might argue ok why do I need
a finally block why can't they just put
this piece of code ok and then remember
finally block is optional it's not
mandatory so if it's not mandatory let's
do this
okay let's put this consult or tree line
outside as usual okay so what we are
trying to do here is instead of having
this clean up code inside the finally
block I am putting it just outside of
the cache block so what people argue is
okay if there if there is no exception
these two lines get executed cache
blocks will not be executed it comes
here loses the streamreader fine
wonderful but if there is an exception
okay if there is a file not found
exception it comes to this okay it it
executes this cache block and then it
skips this catch block it comes here
closes the stream reader so why do I
need a finally block if there is an
exception it's able to close that if
there is no exception it is still able
to use that why do we need a finally
block actually the reason is let's say
for example this piece of code here
obviously there will be some cool to
lock the details of the exception at
either to the database or to send an
email to the administrator you know you
will have some piece of code so if this
code causes an exception you know it's
trying to write to a database and
obviously let's say there is an
exception you know maybe the table is
missing or some problem what is going to
happen when it throws an exception from
this catch block there is no catch block
outside of this there is no try block
here so what's going to happen it will
not execute any of these lines and as a
result your stream reader will not be
closed that is why it is always better
to have a finally block so if there is a
finally block even if there is an
exception in this cache block it is
guaranteed to execute and your resources
get released so always keep that in mind
finally block is your you know kind of
safest bed to release resources properly
okay so we use the try catch and finally
blocks for exception handling and in the
try block we will have the code that can
possibly cause an exception whereas the
cache block
we'll handle the exception and then the
finally block will have the code to
clean and free up the resources and
finally block is optional but make sure
if you are cleaning resources always do
that in a finally block and it's a good
practice to always release resources in
the finally block which we have just
discussed and specific exceptions will
be caught before their base general
exceptions so specific exception block
should always be on top of the base
general base exception class otherwise
you'll get an you'll encounter a compile
error which we have just seen on this
slide you can find resources for asp.net
and C sharp interview questions thank
you for listening
have a great day