Métodos en C#

Tabla de Contenido

0. Introducción
1. Métodos
2. Firma de un Método
2.1 Argumentos vs Parámetros
3. Modificadores de un Método
4. Sobrecarga de Métodos
5. Diferencia entre Pasar por Valor y Pasar por Referencia
6. Conclusiones
7. Glosario
8. Referencias

0. Introducción

Otro de los miembros fundamentales en la creación de una clase de objeto es el método. A lo largo de este artículo estudiaremos temas relacionados con los métodos: su concepto como unidad funcional, su firma, los parámetros, el valor de retorno, y modificadores para cambiar la visibilidad, el modo en que deben heredar, y otros modificadores para código no administrado.

1. Métodos

Los métodos son un tipo de función que permite llevar a cabo una acción u operación siguiendo un conjunto de instrucciones o sentencias. A través de un método se puede cambiar o acceder al estado de un objeto (esto a través de invocaciones o mensajes enviados desde código cliente, por ejemplo).

Además, un método se puede ver como una unidad de procesamiento: tiene una entrada (especificada por los parámetros), y una salida (opcional) producto de la acción llevada a cabo en su implementación.

Figura 1. Analogía entre método y proceso [1].

En esencia, la ejecución de un método empieza por invocar su nombre (nombre del mensaje) y pasar datos de entrada (input) (opcional), a continuación se lleva a cabo la ejecución de cada una las instrucciones o sentencias, al final se generará una salida (valor de retorno o output) (también opcional).

En C# [2] cada instrucción que se ejecuta se realiza en torno en el contexto de un método. Inclusive la aplicación más sencilla: sea para sumar dos números, mostrar un texto "Hello World" en pantalla, etc., las instrucciones giran en torno a un método especial: Main.

2. Firma de un Método

La firma (o signatura [3]) de un método corresponde con los tipos de los valores de entrada (parámetros) y los valores de salida (valor de retorno). Veamos el método que hablé el último parráfo anterior: Main.

Las firmas definidas por C# para el método Main son:

public static void Main()

public static void Main(string[] args)

public static int Main()

public static int Main(string[] args)

Analícemos la primera firma de Main: en la sección de parámetros no se ha definido ninguno. Esto quiere decir que el método no espera ningún dato de entrada para empezar su ejecución. En cuanto al valor de retorno, void, significa que el método al finalizar su ejecución no retornará ningún valor a la función que lo invocó (como se trata de Main, es la misma CLR que se encarga de realizar tal llamada).

La cuarta firma de Main:

• la sección de argumentos tiene especificado un argumento que corresponde con un arreglo de cadena de caracteres (string);
• el valor de retorno (tipo integral int).

En CodeProject $andes M Patil ha preparado un artículo de mayor detalle acerca del método Main: [3].

2.1 Argumentos vs Parámetros

La invocación de un método implica tener en cuenta los tipos de los parámetros y también de los argumentos. Es decir, si la firma es algo como esto:

public string PartirCadenaCaracteres( string cadena, int inicio, int longitud )

La invocación del método PartirCadenaCaracteres requiere que los argumentos pasados a los parámetros sean de tipos de datos compatibles.

Invocación correcta:

PartirCadenaCaracteres("C# Programming Language", 0, 2);

Invocación incorrecta:

PartirCadenaCaracteres("C# Programming Language", 0, "2");

3. Modificadores de un Método

La Figura 1 [4] presenta los tipos de modificadores de métodos permitidos en C#:

Figura 1. Modificadores de métodos en C# [4].

El modificador static cumple la misma función de una variable con este modificador, para lo que corresponde con el caso, permite realizar una invocación de un método sin requerir la instanciación de un objeto de la clase en cuestión.

Ejemplos de métodos estáticos en .NET Framework:

• Max(Double, Double) [5]
• Round(Decimal, Int32) [6]
• Create(String) [7]

En [8] se cubre con más detalle el uso de métodos estáticos.

3.1 Modificadores de acceso

El conjunto de modificadores de acceso para un método en C# son los siguientes:

• public: visible para todos.
• internal: sólo disponible para los artefactos que pertenezcan al mismo assembly.
• private: sólo visible para el tipo en sí.
• protected: visible para las clases hijas o heredadas.

4. Sobrecarga de Métodos

La sobrecarga de un método consiste en crear firmas diferentes para métodos que tienen el mismo nombre.

Ejemplos:

public void MostrarNombre (string primerNombre)

public void MostrarNombre (string primerNombre, string primerApellido)

public void MostrarNombre (string primerNombre, string primerApellido, string segundoApellido)

Cada uno de los anteriores métodos tienen el mismo nombre, pero la signatura (firma) es diferente transitivamente.

Ejemplos de métodos con el mismo nombre que no pueden coexistir en el cuerpo de definición de una clase o estructura:

float Sumar (double a, double b) {...}

double Sumar (double a, double b) {...}

void ConcatenarGrupoCadenasCaracteres (string[] cadenas)

void ConcatenarGrupoCadenasCaracteres (params string[] cadenas)

En el primer caso -método Sumar- la sobrecarga no diferencia entre el valor de retorno. Por lo tanto al ejecutar una definición de clase que contenga estos dos métodos con esa firma se generará un error en tiempo de compilación.

Para el segundo grupo, la sección de parámetros no difiere para exista la sobrecarga. Se genera un error en tiempo de compilación:

error CS0111: A member `Test.Sumar(double, double)' is already defined. Rename this member or use different parameter types

5. Diferencia entre Pasar por Valor y Pasar por Referencia

Cuando en la signatura un parámetro es pasado por valor o por referencia, esto también entra a formar parte de la firma. Veamos estos ejemplos:

• void InvertirValor(int x) {...} 
• void InvertirValor(ref int x) {...} 
• void InvertirValor(out int x) {...} 

La primera definición puede coexistir con cualquier de las dos. Sin embargo, la segunda y tercera, no. Debido que los parámetros son equivalentes: por referencia.

6. Conclusiones

Hemos visto otro de los miembros de un tipo de objeto: el método. En resumen, un método no es más que unidad de procesamiento. Está compuesto por sentencias -la implementación-; tiene una firma y un valor de retorno. Aquí también se comentó acerca de la sobrecarga de métodos: el mismo nombre pero con encabezado o firma diferentes. Finalizando nos dimos cuenta que se pueden crear conflictos cuando los parámetros tienen un equivalente.

7. Glosario

• Argumento
• Firma
• Método
• Parámetro
• Signatura
• Sobrecarga

8. Referencias

[1]: User:Tzaynah/TComputingCourse - WikiEducator - http://wikieducator.org/User:Tzaynah/TComputingCourse
[2]: Methods (C# Programming Guide) - http://msdn.microsoft.com/en-us/library/ms173114.aspx
[3]: Main Method in C# - CodeProject - http://www.codeproject.com/Articles/479467/Main-Method-in-Csharp
[4]: C# 5.0 in a Nutshell by Joseph Albahari and Ben Albahari. Copyright 2012 Joseph Albahari and Ben Albahari, 978-1-449-32010-2.
[5]: Math.Max Method (Double, Double) (System) - http://msdn.microsoft.com/en-us/library/7x97k0y4.aspx
[6]: Math.Round Method (Decimal, Int32) (System) - http://msdn.microsoft.com/en-us/library/zy06z30k.aspx
[7]: RSA.Create Method (String) (System.Security.Cryptography) - http://msdn.microsoft.com/en-us/library/5ws2s1f6.aspx
[8]: C# Static Method - http://www.dotnetperls.com/static-method

O