finally keyword in C# is an important component of exception handling. It makes sure that specific cleanup code is always executed, whether an exception is thrown or not. This makes it ideal for releasing resources such as file handles, database connections, or network streams. The finally block is used in conjunction with try and catch blocks.
- The finally block always executes, even if an exception occurs or a return statement is used in the try or catch blocks.
- A finally block can be used without a catch block, making it versatile for scenarios where exceptions are not explicitly handled.
- It is primarily used to release or clean up resources like file streams or database connections.
- The finally block does not allow control transfer statements such as return, break, or continue.
Example 1: Basic Usage of finally
C#
// C# Program to demonstrate
// the use of finally block
using System;
class Geeks
{
static void Main()
{
try
{
// Simulating an exception
Console.WriteLine("Inside try block");
throw new Exception("An error occurred!");
}
catch (Exception ex)
{
// Handling the exception
Console.WriteLine($"Caught exception: {ex.Message}");
}
finally
{
// Cleanup code
Console.WriteLine("Finally block executed");
}
}
}
OutputInside try block
Caught exception: An error occurred!
Finally block executed
Explanation: In the above example, the try block throws an exception. The catch block handles the exception. The finally block executes cleanup code and makes sure it runs regardless of exceptions.
Syntax of finally
try
{ // Code that may throw an exception }
catch (ExceptionType e)
{ // Code to handle the exception }
finally
{ // Cleanup code that always executes }
Important Points:
- In C#, multiple finally blocks in the same program are not allowed.
- The finally block does not contain any return, continue, break statements because it does not allow controls to leave the finally block.
- You can also use finally block only with a try block means without a catch block but in this situation, no exceptions are handled.
- The finally block will be executed after the try and catch blocks, but before control transfers back to its origin.
Example 2: Using finally Without a catch Block
C#
// C# Program of finally without catch block
using System;
class Geeks
{
static void Main()
{
try
{
// Code that may cause an exception
Console.WriteLine("Opening a file..");
}
finally
{
// Always executed, even without a catch block
Console.WriteLine("File closed successfully.");
}
}
}
OutputOpening a file..
File closed successfully.
Explanation: In this example, the finally block ensures the file is closed even though no exception handling (catch) is implemented.
Example 3: Using finally With Handled Exceptions
C#
// C# Program with finally block
// handling handled exception
using System;
class Geeks
{
static void Main()
{
try
{
// Trying to divide by zero at runtime
Console.WriteLine("Inside try block");
int numerator = 10;
int denominator = 0;
int res = numerator / denominator;
Console.WriteLine("Result of division: " + res);
}
catch (DivideByZeroException)
{
// Handling the exception
Console.WriteLine("Caught: Cannot divide by zero");
}
finally
{
Console.WriteLine("Finally block executed.");
}
}
}
OutputInside try block
Caught: Cannot divide by zero
Finally block executed.
Explanation: In the above example the try block raises a DivideByZeroException. The catch block handles it, and the finally block ensures cleanup.
Example 4: Using finally With Unhandled Exceptions
C#
// C# Program with finally block handling
// runtime division by zero exception
using System;
class Geeks
{
static void Main()
{
try
{
// Trying to divide by zero at runtime
Console.WriteLine("Attempting division...");
int numerator = 10;
int denominator = 0;
// Simulating runtime division by zero
int res = numerator / denominator;
Console.WriteLine("Result of division: " + res);
}
catch (DivideByZeroException ex)
{
// Handling the divide by zero exception
Console.WriteLine("Caught exception: " + ex.Message);
}
finally
{
// Executes even though the exception is handled
Console.WriteLine("Finally block executed");
}
}
}
OutputAttempting division...
Caught exception: Attempted to divide by zero.
Finally block executed
Explanation: In the above example, the try block raises an exception DivideByZeroException, that is not handled, but the finally block still executes, ensuring cleanup is performed.
Similar Reads
C# - continue Statement In C#, the continue statement is used to skip over the execution part of the loop(do, while, for, or foreach) on a certain condition, after that, it transfers the control to the beginning of the loop. Basically, it skips its given statements and continues with the next iteration of the loop. Or in o
2 min read
C# Program to Demonstrate the Use of Exit() Method of Environment Classhttps://origin.geeksforgeeks.org/?p=705454 Environment Class provides information about the current platform and manipulates, the current platform. The Environment class is useful for getting and setting various operating system-related information. We can use it in such a way that retrieves command-line arguments information, exit codes inf
3 min read
ungetc() in C/C++ The ungetc() function takes a single character and shoves it back onto an input stream. It is the opposite of the getc() function, which reads a single character from an input stream. Also, ungetc() is an input function, not an output function. Syntax: int ungetc(int char, FILE *stream) Parameters:
3 min read
Finally Block in Programming The finally block in programming, commonly used in languages like Java and C#, is a block of code that is executed regardless of whether an exception is thrown or not. It is typically used in conjunction with a try-catch block to ensure certain cleanup or finalization tasks are performed, such as cl
6 min read
Finally keyword in Python In Python, the finally keyword is used in a try-except-finally block to define a section of code that will always execute, regardless of whether an exception occurs or not. It guarantees predictable code behavior, maintaining program stability even when errors arise. By using finally, developers ens
3 min read