# Métodos y funciones

En C#, un **método** es un bloque de código que realiza una tarea específica o una serie de tareas. Los métodos permiten organizar y modularizar el código al dividirlo en funciones más pequeñas y manejables. Cada método tiene un nombre, puede aceptar cero o más parámetros como entrada, puede realizar un trabajo y puede devolver un resultado (un valor) como salida. Aquí está una descripción de los elementos clave de un método en C#:

**Nombre del método:** Es el identificador único que se utiliza para llamar al método y debe seguir las reglas de nomenclatura de C#.

**Parámetro**:

* Un parámetro es una variable declarada en la firma de una función o método.
* Los parámetros se utilizan para recibir datos o valores que serán procesados por la función o método.
* Los parámetros son especificados cuando se define la función o método y actúan como marcadores o nombres de variables que se utilizarán en el cuerpo de la función.
* Los parámetros son como los "agujeros" en una función donde se pasan los argumentos para ser utilizados dentro de la función.

**Argumento**:

* Un argumento es el valor real que se pasa a una función o método cuando se llama.
* Los argumentos se utilizan para proporcionar datos concretos que la función o método procesará utilizando los parámetros correspondientes.
* Los argumentos son los valores reales que se suministran en la llamada a la función o método.
* Los argumentos se corresponden uno a uno con los parámetros de la función o método, según el orden en que se definen.

**Tipo de retorno:** Es el tipo de dato que especifica qué tipo de valor devuelve el método como resultado. Un método puede tener un tipo de retorno específico o puede ser void, lo que significa que no devuelve ningún valor.

#### Accesos:

**Public (Público)**:

* Los miembros marcados como **`public`** son accesibles desde cualquier lugar, ya sea dentro de la misma clase, en clases derivadas (si la clase es una clase base), o desde cualquier otro lugar del código que tenga acceso a la instancia de la clase.
* Estos miembros son parte de la interfaz pública de la clase y se utilizan para exponer la funcionalidad principal de la clase.

Ejemplo:

```csharp
public void MetodoPublico()
{
    // Código del método
}
```

**Private (Privado)**:

* Los miembros marcados como **`private`** solo son accesibles desde dentro de la misma clase en la que están definidos. No se pueden acceder desde fuera de la clase, ni siquiera desde clases derivadas.
* Estos miembros se utilizan para encapsular detalles de implementación y ocultarlos del mundo exterior.

Ejemplo:

```csharp
private int variablePrivada;

private void MetodoPrivado()
{
    // Código del método
}
```

### Void

Un método "void" es un tipo de método que se utiliza para realizar una acción o ejecutar un conjunto de instrucciones, pero no devuelve ningún valor. La palabra clave "void" se usa como el tipo de retorno del método para indicar que no se espera que el método devuelva ningún valor o resultado. En otras palabras, un método "void" simplemente hace algo sin generar un valor que pueda ser utilizado posteriormente en el código.

```csharp
using System;

class Program
{
    // Método void que muestra un mensaje en la consola
    static void Saludar()
    {
        Debug.Log("¡Hola, mundo!");
    }

    static void Main()
    {
        // Llamamos al método Saludar
        Saludar();
        
        // La función Saludar() no devuelve un valor que podamos almacenar o utilizar.
        // Simplemente muestra un mensaje en la consola y no esperamos obtener un valor de vuelta.
    }
}
```

En el ejemplo anterior, el método **`Saludar()`** es un método "void" porque no devuelve ningún valor. Simplemente imprime un mensaje en la consola cuando se llama desde el método **`Main()`**. Los métodos "void" son útiles cuando se necesita realizar una acción sin preocuparse por el resultado o cuando no es necesario devolver un valor.

### Funciones con retorno

En C#, puedes crear métodos que devuelvan valores de diferentes tipos, como **`float`**, **`bool`**, **`string`**, entre otros. A este tipo de metodo que retorna X se le llama Funcion.

#### float

```csharp
float CalcularPromedio(float[] numeros)
{
    float suma = 0;
    foreach (float numero in numeros)
    {
        suma += numero;
    }
    return suma / numeros.Length;
}
```

En este ejemplo, el método **`CalcularPromedio`** toma un arreglo de números (**`float[]`**) como argumento, calcula la suma de esos números y luego devuelve el promedio como un valor **`float`**.

#### bool

```csharp
bool EsPar(int numero)
{
    return numero % 2 == 0;
}
```

El método **`EsPar`** toma un número entero como argumento y devuelve **`true`** si es par y **`false`** si es impar.

#### string

```csharp
string ObtenerSaludo(string nombre)
{
    return "¡Hola, " + nombre + "!";
}
```

Este método toma un nombre como argumento y devuelve un saludo personalizado en forma de cadena (**`string`**).

Recuerda que al llamar a estas funciones, puedes asignar el valor de retorno a una variable del tipo correspondiente. Por ejemplo:

```csharp
float promedio = CalcularPromedio(new float[] { 2.5f, 3.0f, 4.5f });
bool esPar = EsPar(10);
string saludo = ObtenerSaludo("Juan");
```

## **Declarar funciones con parámetros:**

En C#, puedes declarar funciones con parámetros y también funciones con parámetros opcionales.

Para declarar una función con parámetros en C#, debes especificar los tipos de datos de los parámetros dentro de los paréntesis después del nombre de la función. Aquí tienes un ejemplo sencillo de una función que suma dos números:

```jsx
public int Sumar(int numero1, int numero2)
{
    return numero1 + numero2;
}
```

En este ejemplo, la función **`Sumar`** toma dos parámetros de tipo **`int`** llamados **`numero1`** y **`numero2`**. Puedes llamar a esta función pasando dos valores enteros como argumentos.

## **Declarar funciones con parámetros opcionales:**

Los parámetros opcionales tienen un valor predeterminado, lo que significa que si no se proporciona un valor cuando se llama a la función, se usará el valor predeterminado. Aquí tienes un ejemplo:

```jsx
public int Multiplicar(int factor1, int factor2 = 1)
{
    return factor1 * factor2;
}
```

En este ejemplo, la función **`Multiplicar`** toma dos parámetros de tipo **`int`**. Sin embargo, el segundo parámetro, **`factor2`**, tiene un valor predeterminado de 1. Esto significa que puedes llamar a la función de dos maneras diferentes:

```jsx
int resultado1 = Multiplicar(5, 3); // resultado1 es 15
int resultado2 = Multiplicar(5);    // resultado2 es 5, ya que factor2 toma el valor predeterminado de 1
```

> 💡 Es importante mencionar que los parámetros opcionales deben estar al final de la lista de parámetros de una función. No puedes tener un parámetro opcional seguido de un parámetro obligatorio en la lista de parámetros de una función.

Esta funcion **no** es valida:

```jsx
public int Multiplicar(int factor2 = 1, int factor1)
{
    return factor1 * factor2;
}
```
