La sobrecarga (overloading) es un proceso a través del cual puedes asignarle a un solo método definiciones múltiples. Esto significa que puedes usar el mismo nombre del método para hacer dos cosas distintas.

Digamos que necesitas un método para sumar dos cantidades, podrías crear un método AddNumbers() que sería responsable de sumar esos dos números. Sin embargo, el sumar dos strings (o cadenas) funciona de manera diferente; por ende, necesitarías un nuevo método llamado AddString().

Esto funciona bien, el problema es que ahora necesitas recordar los nombres de dos métodos diferentes que esencialmente hacen lo mismo, Una mejor manera de hacerlo sería sobrecargar un método llamado Add() para que funcione con números o con strings.

La sintaxis

public class SomeClass
{
    // modificator_acceso valor_retorno firma
    public int Add(int num1, int num2)
    {
        return num1 + num2;
    }
}

Aquí tenemos un método llamado Add() que lee dos números y retorna un número. Cada método tiene lo que se conoce como una firma. La firma está constituida del nombre y la lista de parámetros de un método. No puede haber dos métodos con la misma firma dentro del mismo ámbito.

public class SomeClass
{
    // modificator_acceso valor_retorno firma
    public int Add(int num1, int num2)
    {
        return num1 + num2;
    }

    public string Add(string str1, int str2)
    {
        return str1 + str2;
    }
}

Sobrecargamos métodos al darle a un método nuevo el mismo nombre, pero una firma diferente. Usando nuestro ejemplo anterior podemos sobrecargar este método Add() al crear un nuevo método que suma dos strings.

Date cuenta de que nuestro nuevo método Add() tiene el mismo nombre pero tiene una lista de parámetros diferentes. Desde que es una firma diferente, está permitido.

public class SomeOtherClass : MonoBehaviour
{
    void Start()
    {
        // instancia de la clase
        SomeClass myClass = new SomeClass();

        int resultInt = myClass.Add(1, 2);
        Debug.Log(resultInt); // output 3

        string resultString = myClass.Add("Hello ", "World");
        Debug.Log(resultString); // output "Hello World"
    }
}

En otras clases cuando tratamos de acceder al método Add() podemos ver que hay dos versiones del mismo.

La versión correcta se escogerá basada en los argumentos que le pases. Al pasar dos números, el método que suma dos números se ejecutará. De la misma manera, si pasas dos strings entonces el método que agrega dos strings se ejecutará.

¿Cómo saber cuál elegir?

Ocurrirá una de tres cosas cuando el sistema trata de decidir la versión correcta que debe ejecutar de una sobrecarga de método.

• Exact Match, primero, si hay un ejemplo donde los parámetros coincidan perfectamente entonces, esa versión del método sobrecargado será ejecutada.
• Least Conversion, Si no hay un método que coincida perfectamente, el sistema buscará todos los métodos que coincidan parcialmente y escogerá el que requiera la menor cantidad de conversión.
• Error, finalmente, si no hay métodos que coincidan parcialmente, o versiones múltiples que requieran la misma cantidad de conversión el sistema te dará error.

Apoya el contenido de mi blog a través de:

Fuente:

• Microsoft Docs: Methods C#
• Unity Learn: Junior Programer