Aunque en C# los métodos y funciones se consideran lo mismo, realmente hay una pequeña diferencia entre unos y otros. Tanto los métodos como lás funciones, son las estructuras más importantes y fundamentales de todos los lenguajes de programación junto a las variables y los tipos de datos. Hasta ahora, se realizaron todos los ejemplos en el método principal del programa, el método Main. Ese que el programa busca una vez que se ejecuta para empezar a funcionar. Pero a parte de esto, podemos realizar un programa no solo dependiendo del método Main.
La importancia de los métodos y las funciones en C#.
Un programa puede dividirse en diferentes subprogramas. Estos subprogramas es lo que llamamos métodos y funciones en el lenguaje de programación C#. Esto también ocurre en el lenguaje java y lo llamamos programación modular. Éstos, se van a ejecutar solamente en un momento determinado y será cuando sean llamados. Los métodos o las funciones pueden ser llamados desde el Main, o desde otro método totalmente diferente. Esta forma de dividir el código en diferentes subprogramas, es lo que llamamos programación modular. Esto nos va a permitir tener un código más legible, menos engorroso y más fácil de interpretar.
Sintaxis de los métodos o funciones en C#.
Para identificar a un método o función debemos tener en cuenta la siguiente estructura:
- Tipo de dato que va a devolver + nombre indentificativo(parámetros);
En este ejemplo se explica el propio método Main.
using System;
namespace Funciones
{
class Program
{
static void Main(string[] args)
{
// static (Quiere decir que es un método estático).
// void (quiere decir que no devuelve ningún valor).
// Main (nombre del método).
// (string[] args) Recibe por parámetro un array
// de string que lo llama args.
}
}
}
Métodos y funciones static.
Ya sabemos que todos los métodos o funciones deben estar dentro de una clase definida por un nombre. En CSharp por lo general la clase que se nos crea por defecto es la clase Program.
Cuando un método o función, llevan la palabra reservada static, quiere decir que es estático y que pertenece a la clase en la que es definido. En estos ejemplos y por el momento, todos nuestros métodos serán estáticos (static). Una vez visto de que se compone el método Main, vamos a ver otros ejemplos.
Métodos o funciones void en C# sin paso de parámetros.
Cuando hablamos de que un método o función es de tipo void, quiere decir que el método o función en cuestión no devuelve ningún valor. En este ejemplo se creará un método personalizado que mostrará un saludo por consola. Este método no recibirá ningún parámetro entre los paréntesis.
sing System;
namespace Funciones
{
class Program
{
static void Saludar()
{
// Esto es un método que creamos nosotros.
// Lo único que hace es saludar al usuario
Console.WriteLine("Hola aprendiz de programador");
}
}
}
Este método, por si solo no puede hacer nada. Para que se pueda ejecutar, debemos llamarlo desde el punto de partida del programa (el método Main). Eso lo hacemos de la siguiente manera:
using System;
namespace Funciones
{
class Program
{
static void Saludar()
{
// Esto es un método que creamos nosotros.
// Lo único que hace es saludar al usuario
Console.WriteLine("Hola aprendiz de programador");
}
static void Main(string[] args)
{
// Llamamos al método saludar
Saludar();
// pausamos la consola
Console.ReadKey();
}
}
}
Lo único que tenemos que hacer es escribir el nombre del método y el programa se ejecutará. Además, siempre es importante acompañar en el método principal la instrucción Console.ReadKey(); para pausar el programa.
Métodos o funciones que devuelven un valor y sin paso de parámetros.
En este ejemplo vamos a crear una función. Ésta, ya no será de tipo void porque devolverá un valor. Para C#, de momento, tanto estas funciones serán también de tipo estático. Pertenecerán a la clase donde han sido creadas. En este caso vamos a crear una función que sume dos números enteros. La función va a devolver un resultado de tipo entero (int). Veamos este ejemplo práctico explicativo.
using System;
namespace Funciones
{
class Program
{
static int SumarValores()
{
/* Esto es una función que creamos nosotros.
* Vamos a sumar dos números y devolveremos
* el resultado. Programamos normalmente.
* Declaramos dos variables de tipo entero:
* primerNumero y segundoNumero y las iniciamos.*/
int primerNumero = 15;
int segundoNumero = 32;
/* Ahora declararemos una variable de tipo entero
* llamada resultadoSuma, donde almacenaremos
* el resultado de la suma. Como siempre
* la iniciamos (siempre es recomendable
* iniciar una variable cuando es declarada.)*/
int resultadoSuma = 0;
/* Sumamos las dos variables primerNumero
* y segundoNumero y lo almacenamos
* en la variable resultadoSuma.*/
resultadoSuma = primerNumero + segundoNumero;
/* Habiamos quedado en que la funcion
* tiene que devolver la suma de los dos valores
* primerNumero y segundoNumero.
* ¿Dónde lo tenemos? El resultado de la suma
* se encuentra en la variable resultadoSuma.
* Esta variable es la que debemos devolver
* Para devolver el resultado, lo hacemos con la
* instrucción Return.*/
return resultadoSuma;
}
}
}
Cuando queremos crear una función y devolver un valor, al final debemos utilizar la palabra reservada Return. Además, con este ejemplo, volvemos a la misma situación de antes. Una función construída no puede ejecutarse por si sola. Debe llamarse el punto de entrada del programa.
Cómo llamar a métodos y funciones en C# desde otro método o desde el Main.
No hay que olvidar que la función cuando se ejecuta está devolviendo un valor. Éste, puede ser numérico, de texto, booleano, etc. Este valor no puede ser enviado a ningún método o función si no lo almacenamos en algún lugar. Como la función está devolviendo un valor, debemos guardar su resultado en una variable. Es muy importante saber que tipo de valor esta devolviendo la función. Debemos almacenar el valor devuelto en una variable del mismo tipo de dato que devuelve la función. Para llamar a la función anterior lo haremos de la siguiente manera.
using System;
namespace Funciones
{
class Program
{
static int SumarValores()
{
/* Esto es una función que creamos nosotros.
* Vamos a sumar dos números y devolveremos
* el resultado. Programamos normalmente.
* Declaramos dos variables de tipo entero:
* primerNumero y segundoNumero y las iniciamos.*/
int primerNumero = 15;
int segundoNumero = 32;
/* Ahora declararemos una variable de tipo entero
* llamada resultadoSuma, donde almacenaremos
* el resultado de la suma. Como siempre
* la iniciamos (siempre es recomendable
* iniciar una variable cuando es declarada.)*/
int resultadoSuma = 0;
/* Sumamos las dos variables primerNumero
* y segundoNumero y lo almacenamos
* en la variable resultadoSuma.*/
resultadoSuma = primerNumero + segundoNumero;
/* Habiamos quedado en que la funcion
* tiene que devolver la suma de los dos valores
* primerNumero y segundoNumero.
* ¿Dónde lo tenemos? El resultado de la suma
* se encuentra en la variable resultadoSuma.
* Esta variable es la que debemos devolver
* Para devolver el resultado, lo hacemos con la
* instrucción Return.*/
return resultadoSuma;
}
static void Main(string[] args)
{
/* Declaro una variable para almacenar
* el tipo de dato que devuelve la función.
* Como la función devuelve un tipo int, debemos
* declarar una variable int*/
int resultadofuncion = 0;
// Ahora almaceno en esta variable
// el resultado de la funcion
resultadofuncion = SumarValores();
// Ya tengo el resultado que devuelve la funcion
// en una variable. Ahora solo queda mostrarlo
// por pantalla si queremos.
Console.WriteLine("El resultado de la función es "
+ resultadofuncion);
// pausamos la consola
Console.ReadKey();
}
}
}
Definición y tipos de parámetro en CSharp.
Es muy habitual que los métodos y funciones puedan recibir parámetros o argumentos. Un parámetro es una variable, una constante o un objeto que se le pasan entre paréntesis a un método o función para que podamos trabajar con ellos. Los tipos de parámetros o argumentos que podemos encontrarnos son:
- Por valor. Cuando pasamos un parámetro por valor, estamos pasando una copia del valor de una variable. Podemos manejar ese valor en el parámetro de la función. Por mucho que el valor del parámetro cambie, el valor de la variable original, permanece inalterable.
- Por referencia: Cuando pasamos un parámetro por referencia, estamos pasando una copia del valor de una variable. Podemos manejar ese valor en el parámetro de la función. Si el valor del parámetro cambia, el valor de la variable original también cambia.
Ejemplo de funciones void. Paso de parámetros por valor en C#.
En este ejemplo se crea un método void, por lo tanto no va a devolver ningún resultado. Lo que hará será ejecutar una serie de instrucciones. Al no devolver ningún resultado, no llevará ninguna instrucción return. Veamos el ejemplo.
using System;
namespace Funciones
{
class Program
{
static void SumarValores(int primerNumero, int segundoNumero)
{
// Mostramos un mensaje en el que se suman las dos variables.
// En este caso los dos parámetros o argumentos.
Console.WriteLine("La suma de los dos números es " +
primerNumero + segundoNumero);
// Muestro el mensaje con el símbolo + (de concatenación).
// En dos lineas, aunque se puede hacer un una sola linea.
}
}
}
En este ejemplo estoy sumando dos números. Lo que hago es la suma de los dos argumentos que están entre paréntesis. Las dos variables de tipo int, que están entre paréntesis son los parámetros. Estos parámetros guardarán una copia de dos valores.
¿Qué valores va a almacenar?
Almacenará dos valores que se encuentren en dos variables que se hayan iniciado en el método Main. Vamos a ver como quedaría el método Main.
using System;
namespace Funciones
{
class Program
{
static void SumarValores(int primerNumero, int segundoNumero)
{
// Mostramos un mensaje en el que se suman las dos variables.
// En este caso los dos parámetros o argumentos.
Console.WriteLine("La suma de los dos números es " +
primerNumero + segundoNumero);
// Muestro el mensaje con el símbolo + (de concatenación).
// En dos lineas, aunque se puede hacer un una sola linea.
}
static void Main(string[] args)
{
// Declaro dos variables de tipo entero y las inicio.
int num1 = 27;
int num2 = 31;
/* num1 y num2 son las dos variables que se pasan
* por parámetros al método SumarValores. Una
* copia de estos dos variables viajarán a él y se
* almacenarán de la siguiente manera:
* num1 viajará al primer parámetro del método primerNumero
* num2 viajará al segundo parámetro del método segundoNumero
* Una copia de los dos valores de las variables están
* viajando a los dos parámetros porque cuando llamo al método
* se lo voy a indicar entre paréntesis. de la siguiente manera.*/
/* Llamo al método y le paso entre parentesis
las dos variables*/
SumarValores(num1, num2);
// pausamos la consola
Console.ReadKey();
}
}
}
Funciones que devuelven un valor y con paso de parámetros por valor.
En este caso se hace de la misma manera que hemos hecho en el ejemplo anterior cuando creamos el método. Solo hay que tener en cuenta que una función devuelve un valor. Vamos a ver el mismo ejemplo pero en este caso la función devolverá un valor de tipo entero. Teniendo en cuenta los ejemplos anteriores, vamos a complicarlo un poco para ver que podemos hacer más cosas. Vamos a ir por partes. La función quedaría de la siguiente manera:
using System;
namespace Funciones
{
class Program
{
static int SumarValores(int primerNumero, int segundoNumero)
{
/* En programación hay que acostumbrarse a trabajar
* con variables. Asi que vamos a declarar una variable para
* almacenar el resultado de la suma*/
int resultado = primerNumero + segundoNumero;
// Ahora devolvemos el resultado de la funcion
// que se encuentra en la variable resultado.
return resultado;
}
}
}
En nuestro método Main vamos a combinar la opción de que el usuario introduzca un valor por pantalla, un bucle. Este bucle nos permitirá repetir la pregunta hasta que el usuario introduzca un dato correcto. Por otro lado y para terminar veremos una nueva forma de convertir datos. Después de ver la conversión implícita, ahora convertiremos por ejemplo de decimal a entero. Esta forma de convertir valores es lo que llamamos conversión explícita de datos.
using System;
namespace Operaciones_con_Matrices
{
class Program
{
static int SumarValores(int primerNumero, int segundoNumero)
{
/* En programación hay que acostumbrarse a trabajar
* con variables. Asi que vamos a declarar una variable para
* almacenar el resultado de la suma*/
int resultado = primerNumero + segundoNumero;
// Ahora devolvemos el resultado de la funcion
// que se encuentra en la variable resultado.
return resultado;
}
static void Main(string[] args)
{
// Declaro tres variables de tipo double y las inicio a cero
double num1 = 0;
double num2 = 0;
double resultadoSuma = 0;
// Declaro otras tres de tipo entero int
int valor1 = 0;
int valor2 = 0;
int sumaTotal = 0;
do // Ejecutamos este bucle como mínimo una vez
{
// Pedimos el primer valor al usuario.
Console.WriteLine("Introduce el primer valor");
// Convertimos a doble el primer valor y lo metemos en num1
num1 = double.Parse(Console.ReadLine());
// Pedimos el segundo valor al usuario.
Console.WriteLine("Introduce el segundo valor:");
// Convertimos a doble el segundo valor y lo metemos en num2
num2 = double.Parse(Console.ReadLine());
// y mientras que el usuario introduzca un valor vacio.
} while (num1.Equals("") || num2.Equals(""));
/* Tenemos las tres variables de tipo double (decimal)
* y la función me va a devolver un resultado de tipo int.
* Además la función me pide dos parámetros de tipo int.
* Esto quiere decir que estas dos variables no me sirven.
* Primero debemos pasar las variables num1 y num2 a int.*/
valor1 = (int)num1;
valor2 = (int)num2;
/* Ya las tenemos como tipo entero, pero resulta que el
* resultado de la funcion es de tipo entero y tenemos
* una variable resultadoSuma de tipo decimal, Debemos tambien
* pasar esta variable resultadoSuma a tipo entero. Debemos
* recordar que el resultado que devuelve una funcion
* debe almacenarse en una variable del mismo tipo de dato
* que devuelve la función*/
sumaTotal = (int)resultadoSuma;
// Esta forma de conversión es lo que llamamos
// conversión explícita
// y ahora si podemos llamar a la funcion.
sumaTotal = SumarValores(valor1, valor2);
// Para mostrar el resultado lo haremos asi:
Console.WriteLine(sumaTotal);
// pausamos la consola
Console.ReadKey();
}
}
}