Los lenguajes, como casi todo en este universo que tiende a la entropía, van evolucionando y ganando complejidad con el tiempo. Así nos encontramos con la paradoja de que cuanto más completa es la sintaxis, más ilegible se puede volver el código.

Por ejemplo, la máxima que decía “escribe la menor cantidad de código, que vaya lo más rápido posible”, tiene un orden de prioridad menor frente a paradigmas de programación más modernos como Clean Code o KISS.

Por ello ahora quiero compartir una técnica para facilitar la legibilidad de nuestros programas y que trata de la sobrecarga de los métodos.

Qué es sobrecargar

Según MSDN, “La sobrecarga consiste en crear más de un procedimiento, constructor de instancia o propiedad en una clase con el mismo nombre y distintos tipos de argumento”. Lo cual, sin un buen ejemplo, es un tanto confuso.

Me pongo manos a la obra, creo un proyecto de consola y, en el inicio del programa, hago que escriba por consola el resultado de un método llamado suma().

using System;


namespace GenbetaDevConsola



{

    class Program

    {

        static void Main(string[] args)

        {

            System.Console.Write(suma(1, 1));

        }

    }



}

Obviamente debo escribir el método, tal que así:

private int suma(int numero1, int numero2)



{

  return numero1 + numero2;



}

Pero, ¿si me encuentro con que los números no son enteros si no que son más grandes?

Tengo dos opciones. Una sería crear un nuevo método que se llame algo como sumaDouble() y que tenga dos números doubles por parámetros. La otra opción es sobrecargar el método suma con nuevos parámetros, pudiéndolo utilizar indistintamente en un caso o en el otro.

private int suma(double numero1, double numero2)



{

  int numero = 0;

  Int32.TryParse((numero1 + numero2).ToString(),out numero);

  return numero;



}

Lo mejor es que Intellisense del Visual Studio me ayuda y me indica que el método suma() está sobrecargado y me ofrece ver la firma de cada una de ellas.

Es más, puedo ir añadiendo complejidad a mi método suma aceptando más parámetros y de diferente tipo como, por ejemplo, poder sumar tres cantidades o hacer sumas booleanas.

private static int suma(int numero1, int numero2, int numero3)



{

  return numero1 + numero2 – numero3;



}


	
private static int suma(Boolean numero1, Boolean numero2)



{

  return numero1 == numero2? 1 : 0;



}

NOTA: Lo que he utilizado en la suma Booleana es una forma compacta de un condicional. Si se cumple la igualdad, devuelvo 1. Si no, devuelvo 0. No es muy legible y conozco alguno que decía que esto era “evil”. Pero es muy útil.

Fíjate que lo importante de utilizar sobrecargas, es que encapsulo el funcionamiento de los métodos de forma que siempre llamo a suma(), y solo me debo preocupar de cumplimentar correctamente alguna de sus posibles firmas.

Por cierto, por si alguno desconoce el concepto de firma, MSDN dice:

Los métodos se declaran en una clase o struct mediante la especificación del nivel de acceso como public o private, modificadores opcionales como abstract o sealed, el valor devuelto, el nombre del método y cualquier parámetro de método.Todos esos elementos constituyen la firma del método.

Mejorando las sobrecargas

Pero C# sigue adelante en su evolución (realmente todo .NET) y a partir de la versión 4.0 tengo tres novedades que me han llamado mucho la atención por su utilidad.

Puedo declarar un método y ponerle por defecto un valor a cada uno de sus parámetros. Por ejemplo si quiero calcular la hipotenusa puedo crear un método tal cual,

public static double calculaHipotenusa

                                      (

                                        double cateto1 = 100,

                                        double cateto2 = 100,

                                        double hipotenusa = 0
         
                                       )



{ 

  return Math.Sqrt(Math.Pow(cateto1,2) + Math.Pow(cateto1,2));



}

Así puedo llamar a este método de diferentes formas de acuerdo a los datos que tenga, sin tener que rellenar obligatoriamente todos los parámetros.

static void Main(string[] args)



{

  System.Console.Write(calculaHipotenusa());

  System.Console.Write(calculaHipotenusa(100));

  System.Console.Write(calculaHipotenusa(100, 50));

  System.Console.Write(calculaHipotenusa(cateto2:50));



}

Ahora fíjate en la última forma de llamar al método. Estoy introduciendo el nombre del parámetro que quiero cargar. Esto, que parece trivial, nos alivia de tener que construir un método sobrecargado para cada una de las firmas. Y tampoco debemos de invocar el método con todos sus parámetros, ya que solamente remito los que quiero enviándolos por su nombre.

Por último, y si tienes ganas de jugar más fuerte, te puedes meter en la sobrecarga de operadores. Es decir, darle comportamientos particulares y específicos a cosas como +, -, =, etc. Así puedo hacer una suma directa de valores booleanos en una clase sin tener que construir un método con esa firma.

Pero esto yo no lo he utilizado nunca y no encuentro ahora mismo donde aplicarlo.

Más información | Métodos (Guía de programación de C#), Nuevas características de C# en .NET Framework 4