Part 43 C# Tutorial Exception handling abuse Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming

Oh welcome to prism technologies I'm
Lincoln this is path 43 exception
handling abuse in this session
learn what exception handling abuse is
all about and we love to see how to
prevent exception handling abuse now we
know that an exception is nothing but an
unforeseen error that occurs when a
program is running for example let's say
we have an application that reads data
from the database and displays that
maybe on a web page
I mean it's doing that there is a
database error so obviously to handle
that we use you know exception handling
techniques but many times I have seen
people using exception handling
incorrectly to grab logical flaw which
is extremely bad and that's what is
termed as exception having abused
probably we'll look at an example which
will make that clear so let's say you
know I want to write a simple program
which can divide two numbers and display
the division result and that's pretty
simple to do so first let's prompt the
user to enter their numerator so console
dot write line and we'll ask the user to
enter numerator so please enter
numerator now once we ask the user to
enter the numerator he will enter the
numerator so we need a variable which
can hold that so we use the console dot
readline method to read the input from
the user
but since red line reads that in the
form of a string we need to convert that
integer so we can make use of convert
class to convert to in 32 so what is
this going to do it's going to convert
that to integer and store in that
numerator variable so similarly let's
ask the user to enter denominator
and once the user enters the denominator
we want to read that from the console
can wear that to interior and store it
in this denominator variable and
obviously we want to calculate the
division result which is equal to
numerator by denominator and then we
finally print the result back to the
user so result is equal to result all
right now if we run this program it's
pretty simple it will last then the user
to enter two numbers let's say numerator
is 10 denominator is 2 result is 5 it
works but then there are several reasons
why this program can fail if you look at
this you know it's asking us to enter a
numerator the first reason why this
program might fail
if I enter you know alphabets instead of
numbers what this program will do it
will try to read that from console and
try to convert that now when this
convert the two in 32 method you know
tries to convert the string it cannot
convert that into here it will throw an
exception format exception so when I do
this look at that you get a format
exceptions so obviously to handle that
what we can do we can put this in a try
block so basically what you want your
program to do is you know when you read
that in from the console you want to
check if that is in a valid format
rather than using exception handling
like this so for example format
exception let's say F E and what we do
console.writeline please and a number or
only number slapped whatever okay we
don't have to use this object here
because we are not using that for any
purpose so now if I run this so please
end the numerator so if I enter
alphabets then what's going to happen
they
slime will try to read that convert that
integer which will fail a format
exception will be thrown the catch block
will catch that exception and prints
this message to the user okay that looks
fine but there are other reasons as well
why this program can fail for example
it's asking me to enter a numerator now
I enter a very big number now you know
that an into 32 an integer can only hold
you know a number of certain size and
this is definitely big for an integer
variable to hold so when I press enter
what's gonna happen console dot readline
will read that number and when it tries
to convert that to an integer obviously
it cannot convert that to an integer
because it overflows okay what happens
if you pour two litres of water in a 1
liter can it's gonna overflow similarly
if you try to you know store a huge
number in a variable of smaller datatype
obviously that's on overflow so we get
an overflow exception so obviously to
handle this probably we have to have
another catch block let me catch
overflow exception and what we want to
do here is we want to tell the user okay
you entered a number that makes sense
but that entered number should be
between you know the range is that an
integer variable can and what is that
range how do you find out let's see that
it's a console dot write line and then
we want to say only numbers between
that's the minimum value and maximum
value are allowed so what is the minimum
value that an entity to variable can't
hold it's very easy to identify that to
find that out you don't have to remember
you know top of your head so for example
if I say that in 32 we know that in
tactical is a value type and it's a
structure so the intelligence shows that
so now when I right-click on that and
say go to definition look at this this
int 32 has a constant a public constant
variable of type minimum value and
maximum value which will basically tell
what's the minimum value it can hold and
what's the maximum value it can hold so
basically you can use these two
constants to get your value so minimum
value and in 32 not max value so that's
it so now if we run this and then if we
try to enter a very big number which in
you know an integer variable cannot hold
obviously it will through an overflow
exception this cache block handles that
and then choose this meaningful message
to the users who only numbers between
that range are allowed and there is
another reason why this program can fail
as well let's see now please enter in
numerator I enter a valid number please
enter the denominator I hundred zero now
we know that in mathematics it's illegal
to divide a number by zero which will
lead to infinity and a program cannot
with chain that number so obviously you
know divided by dividing by zero is is
illegal so the application is divided by
zero exception but our application you
know cannot handle that exception so
when we do that we get it divided by
zero exception so obviously to handle
that we need another cache block let's
say so catch
/ 0 exception and obviously what we can
display here is denominator cannot be
zero so we'll display that meaningful
message to the user denominator cannot
be zero so now if the user enters zero
as the denominator then he will get that
meaningful message and apart from these
three if there is any other exception
then it's safe to have another catch
block so we will just say
console.readline he extract message
maybe here we will have a reference
variable all right so now our program
looks okay now it's it can you know
basically handle any type of exception
now I run this whatever is the case you
know this program doesn't break but then
if you look at the look at what we have
done in this program this is actually
wrong I mean we are abusing exception
handling you know instead of using a
format exceptional exceptional / 0
exception to handle these scenarios ok I
would say use error checking mechanisms
like instead of using converted to int
32 use int or tryparse method and then
if the tryparse is not successful you
know that there is something wrong with
the input and based on that you know
display the meanings and you messages to
the user i'm similarly instead of
allowing you know the / 0 exception to
occur and then catching that what you
can basically do is check the
denominator is 0 after after you have
successfully parse at that and then show
that message to the user all right what
we will do is actually we will see how
to you know prevent this exception
handling abuse with an example in a next
session so I I hope in this session you
have understood you know this way of
implementing programming logic you know
he
what am i doing I'm using format
exception basically to tell okay you are
your entered number should only be a
your entered value should only be a
number similarly to tell him the range I
am using overflow exception but instead
of that once you try to parse that based
on the result you can basically tell
whether if he has entered a number or
not but if it falls within a specific
range or not similarly if the
denominator is zero you can straight
away tell the user okay dividing by zero
is not allowed rather than allowing the
divided by zero exception to occur and
then telling the user you know within
that exception okay denominator cannot
be zero so so we have to prevent this
and we will see that in our next session
on this slide you can see s we don't
need as he should happen to be questions
thank you for listening have a great day