C# | finalmente palabra clave – Part 1

En programación, a veces una excepción puede causar un error que finaliza el método actual. Sin embargo, ese método podría haber abierto un archivo o una red que debe cerrarse. Entonces, para superar este tipo de problemas, C# proporciona una palabra clave especial denominada «finally». Es una palabra clave reservada en C#.
El bloque «finally» se ejecutará cuando el bloque «try/catch» abandone la ejecución, independientemente de la condición que lo provoque. Siempre se ejecuta si el bloque try termina normalmente o termina debido a una excepción. El objetivo principal del bloque finalmente es liberar los recursos del sistema. El bloque «finally» sigue al bloque «try/catch».

Sintaxis:

try {

    // code...
}

// this is optional
catch {

   // code..
}

finally
{
    // code..
}

Puntos importantes:

• En C#, no se permiten varios bloques finalmente en el mismo programa.
• El bloque finalmente no contiene ninguna declaración de retorno, continuar o interrumpir porque no permite que los controles abandonen el bloque finalmente.
• También puede usar el bloque finalmente solo con un bloque de prueba sin un bloque de captura, pero en esta situación, no se manejan excepciones.
• El bloque «finally» se ejecutará después de los bloques «try» y «catch», pero antes de que el control vuelva a su origen.

Ejemplo 1:

// C# program to demonstrate finally
using System;
  
class Geek {
      
    // A method that throws an
    // exception and has finally. 
    // This method will be called
    // inside try-catch. 
    static void A() 
    { 
        try {
              
            Console.WriteLine("Inside A"); 
            throw new Exception("Throwing Exception");
        } 
          
        finally
        { 
            Console.WriteLine("A's finally"); 
        } 
    } 
  
    // This method also calls
    // finally. This method 
    // will be called outside
    // try-catch. 
    static void B() 
    { 
          
        try { 
              
            Console.WriteLine("Inside B"); 
            return; 
        } 
          
        finally
        { 
            Console.WriteLine("B's finally"); 
        } 
    } 
  
// Main Method
public static void Main(String[] args) 
{ 
    try { 
          
        A(); 
    } 
      
    catch (Exception) { 
          
        Console.WriteLine("Exception Caught"); 
    } 
    B(); 
} 
} 

Producción:

Inside A
A's finally
Exception Caught
Inside B
B's finally

Ejemplo 2: usar el bloque finalmente con una excepción controlada

// C# program to illustrate the finally
// block with handled exception
using System;
  
public class GFG {
  
    // Main Method
    static public void Main()
    {
  
        // variables
        int number = 4;
        int divisor = 0;
  
        // try block
        // This block raise exception
        try {
  
            int output = number / divisor;
        }
  
        // catch block
        // This block handle exception
        catch (DivideByZeroException) {
  
            Console.WriteLine("Not possible to divide by zero!");
        }
  
        // finally block
        // This block release the 
        // resources of the system
        // and this block always executes
        finally {
  
            Console.WriteLine("Finally Block!");
        }
    }
}

Producción:

Not possible to divide by zero!
Finally Block!

Explicación: En el ejemplo anterior, se genera una excepción (DivideByZeroException) dentro del bloque de prueba que es capturado por el bloque de captura asociado con el bloque de prueba. Ahora, después de que los bloques try-catch dejen su ejecución, finalmente el bloque se ejecuta y libera los recursos del sistema que utiliza el bloque try-catch.

Ejemplo 3: usar el bloque finalmente con una excepción no controlada

// C# program illustrate the finally
// block with unhandled exception
using System;
   
public class GFG {
      
    // Main method
    static public void Main () {
          
    // variables
    int number = 4;
    int divisor = 0;
    int output;    
       
    // In this block exception raise
    // Here this exception in unhandled
    // due to the absence of catch block
    try
    {
         output = number/divisor;      
    }
       
    // finally block, this block always
    // executes 
    finally
    {
        Console.WriteLine("Finally Block!");
    }
    }
}

Producción:

Finally Block!

Errores de tiempo de ejecución:

Excepción no controlada:
System.DivideByZeroException: se intentó dividir por cero.
en GFG.Main() en: 0
[ERROR] EXCEPCIÓN FATAL NO MANEJADA: System.DivideByZeroException: se intentó dividir por cero.
en GFG.Principal() en :0

Explicación: en este ejemplo, se genera una excepción (DivideByZeroException) dentro del bloque de prueba, pero no se maneja porque el bloque de captura asociado al bloque de prueba no está presente. En esta situación, cuando el bloque de prueba deja su ejecución, finalmente el bloque se ejecuta y libera los recursos del sistema. Significa que finalmente al bloque no le importa si la excepción se maneja o no.