The document discusses different types of errors in programming - syntax errors, runtime errors (exceptions), and logical errors. It explains that exceptions can be handled using try, catch, and finally blocks. The try block contains code that might throw exceptions, catch blocks handle specific exceptions, and finally blocks contain cleanup code that always runs. Key aspects of exception handling include using specialized catch blocks before general ones and obtaining exception details to understand errors.

1. Hi friends
C# Tutorial
Part 41:
ERROR
www.siri-kt.blogspot.com

2. • Errors refer to the mistake or faults which occur
during program development or execution. If you
don't find them and correct them, they cause a
program to produce wrong results.
• Types of Errors
• In programming language errors can be divided into
three categories as given below-

3. • Syntax Errors:
• Syntax errors occur during development, when you make
type mistake in code. For example, instead of writing
while, you write WHILE then it will be a syntax error
since C# is a case sensitive language.
• bool flag=true;
• WHILE (flag) //syntax error, since c# is case sensitive
• {
• //TO DO:
• }

4. • Runtime Errors (Exceptions):
• Runtime errors occur during execution of the
program. These are also called exceptions. This can
be caused due to improper user inputs, improper
design logic or system errors.
– int a = 5, b = 0;
– int result = a / b; // DivideByZeroException
• Exceptions can be handled by using try-catch
blocks.

5. • Logical Errors
• Logic errors occur when the program is written fine
but it does not produce desired result. Logic errors
are difficult to find because you need to know for
sure that the result is wrong
• int a = 5, b = 6;
• double avg = a + b / 2.0; // logical error, it should
be (a + b) / 2.0

6. • Exception Handling
• Exception handling is a mechanism to detect and handle
run time errors. It is achieved by using Try-Catch-
Finally blocks and throw keyword.
• Try block
• The try block encloses the statements that might throw
an exception.
– try
– {
– // Statements that can cause exception.
– }

7. • the microsoft given 4 keywords for handling Runtime errors
• 1.try
• 2.catch
• 3.finally
• 4.Throw
• if we are not expect any errors in an application then we can't work with exception
handling.
• syntax:
• try
• { expected error information }
• catch
• { exception information }
• finally
• { Result(o/p) }
• throw
• { user defined exception }

8. • 1.try:
• in the try block we have to include all expected
exceptions statements. try block followed with cacth
&finally,catch (or)finally one try block may having
multiple catch blocks but having only one finally block.
one try block raising only one exception at a time.one try
block can executes one catch block at time
• 2.catch:
• using catch block we can provide exception
information.one catch block can handles only one
exception
• 3.finally block:
• the finally block executes which statements doesn't

9. • 4.throw:
• throw bloack can handle only one userdefined exception at a time. this block can handle
multiple userdefined exceptions at a time.
• example exception Handling:
• static void Main(string[] args)
• { try
• { int a, b, c;
• Console.WriteLine("enter a value");
• a=int.Parse(Console.ReadLine());
• Console.WriteLine("enter b value");
• b=int.Parse(Console.ReadLine());
• c = a / b;
• Console.WriteLine(c.ToString());
• Console.ReadLine(); }
• catch (Exception ex)
• { Console.WriteLine(ex.ToString());
• Console.ReadLine(); }

10. • ex2:
• 1.take a form
• 2.add 3 label,3 textboxes&one button
• source code:
• private void button1_Click(object sender, EventArgs e)
• { int a, b, res = 0;
• try
• { a = Convert.ToInt16(textBox1.Text);
• b = Convert.ToInt16(textBox2.Text);
• res = a / b; }
• catch (Exception ex)
• { MessageBox.Show(ex.Message); }
• finally
• { textBox3.Text = res.ToString(); } }

11. • Catch block
• Catch block handles any exception if one exists.
– catch(ExceptionType e)
– {
– // Statements to handle exception.
– }
• Finally block
• The finally block can be used for doing any clean-up process like releasing
unused resources even if an exception is thrown. For example, disposing
database connection.
– finally
– {
– // Statement to clean up.
– }

12. – Throw keyword
– This keyword is used to throw an exception explicitly.
– catch (Exception e)
– {
– throw (e);
– }

13. • Key points about exceptions handling
• Exceptions are types that all directly or indirectly
derive from System.Exception class.
• Exception objects contain detailed information about
the error, such as the state of the call stack and a text
description of the error.
• A try block is used to throw multiple exceptions that can
handle by using multiple catch blocks.
• More specialized catch block should come before a
generalized one. Otherwise specialized catch block will
never be executed.
• Exceptions can be explicitly generated by a program by
using the throw keyword.

14. • If no exception handling mechanism is used, the program
stops executing with an error message.
• By providing a catch block without a brackets or arguments,
we can catch all exceptions occurred inside a try block.
– Catch
– { Console.WriteLine("oException" ); }
• By providing a catch block with an exception object, you can
obtain more information about the type of exception that
occurred.
– catch(Exception e)
– { Console.WriteLine(e.Message); }
• The statements inside the finally block are always executed
whether exception occurs or not in the program.
• Also, before the termination of the program finally block is
always executed.

15. Order of Try-Catch-Finally blocks
• In the order of exceptions handling blocks try block comes first, after
that catch block(s) come and in the last finally block come.
• try
• { // statements that can cause exception. }
• catch (MoreSpecificExceptionType e1)
• { // error handling code }
• catch (SpecificExceptionType e2)
• { // error handling code }
• catch (GeneralExceptionType eN)
• { // error handling code }
• finally
• { // statement to clean up. }

16. You can also skip finally block if
required.
• try
• { // statements that can cause exception. }
• catch (MoreSpecificExceptionType e1)
• { // error handling code }
• catch (SpecificExceptionType e2)
• { // error handling code }
• catch (GeneralExceptionType eN)
• { // error handling code }
• You can also skip catch block(s) if required.
• try
• { // statements that can cause exception. }
• finally
• { // statement to clean up. }
• Hence a combination of try-catch-finally or try-catch or try-finally blocks is valid.

17. For more visit our website www.siri-kt.blogspot.com
Thanks for
Watching
More Angular JS TutorialsMore C sharp (c#) tutorials