1. Módulo I- Introducción a la Programación en
la Plataforma .Net con C#

2. TEMARIO
CAPITULO III.- INTRODUCCIÓN AL
LENGUAJE DE PROGRAMACIÓN C#
 Introducción a los Métodos
 Utilización de Parámetros

3. INTRODUCCIÓN A LOS MÉTODOS
Definición de métodos
Main es un método
 Para definir métodos propios se usa la misma
sintaxis
using System;
using System;
class ExampleClass
class ExampleClass
{{
static void ExampleMethod( )
static void ExampleMethod( )
{
{
Console.WriteLine("ExampleMethod");
Console.WriteLine("ExampleMethod");
}
}
static void Main( )
static void Main( )
{
{
// ...
// ...
}
}
}}

4. Tipos Métodos
Procedimiento Void : Un procedimiento debe
tener un nombre. Este nombre será utilizado para
invocarle. No retorna datos. Ej: Void Hola Mundo()
Funciones: Si un método devuelve valor, se
llama función sino retorna valor se le llama
procedimiento.
Procedimientos de eventos : 2 elementos
distinguen un procedimiento clásico a un de
eventos:
 La llamada al procedimiento de eventos se realiza
automáticamente.
 El nombre del procedimiento de eventos es la
concatenación del nombre del evento para la cual se
gestiona el evento: Ej: button_click()

5. Llamadas a métodos
Una vez definido un método, se puede:
 Llamar a un método desde dentro de la misma
clase
 Se usa el nombre del método seguido de una
lista de parámetros entre paréntesis
 Llamar a un método que está en una clase
diferente
 Hay que indicar al compilador cuál es la clase
que contiene el método que se desea llamar
 El método llamado se debe declarar con la
palabra clave public
 Usar llamadas anidadas
 Unos métodos pueden hacer llamadas a
otros, que a su vez pueden llamar a otros
métodos, y así sucesivamente.

6. Uso de la instrucción return
Return inmediato
Return con una instrucción condicional
static void ExampleMethod( )
static void ExampleMethod( )
{
{
int numBeans;
int numBeans;
//...
//...
Console.WriteLine("Hello");
Console.WriteLine("Hello");
if (numBeans < 10)
if (numBeans < 10)
return;
return;
Console.WriteLine("World");
Console.WriteLine("World");
}
}

7. Uso de variables locales
Variables locales
 Se crean cuando comienza el método
 Son privadas para el método
 Se destruyen a la salida
Variables compartidas
 Para compartir se utilizan variables de clase
Conflictos de ámbito
 El compilador no avisa si hay conflictos entre
nombres locales y de clase

8. Devolución de valores
El método se debe declarar con un tipo
que no sea void
Se añade una instrucción return con una
expresión
 Fija el valor de retorno
 Se devuelve al llamador
Los métodos que no son void deben
devolver un valor
static int DosMasDos( )
static int DosMasDos( ) {in t x ;
i nt x;
{
int a,b;
int a,b; x = DosMasDos( );
x = DosMasDos( );
a = 2;
a = 2; Console.WriteLine(x);
Console.WriteLine(x);
b = 2;
b = 2;
return a + b;
return a + b;
}
}

9. UTILIZACIÓN DE PARAMETROS
Declaración y llamadas a
parámetros
Declaración de parámetros
 Se ponen entre paréntesis después del nombre
del método
 Se definen el tipo y el nombre de cada parámetro
Llamadas a métodos con parámetros
 Un valor para cada parámetro
st a t i c v o i d
tatic void MethodWithParameters(int n, string y)
MethodWithParameters(int n, string y
{ ... }
... }
Me t h o d W i t h P a r a m e t e r s ( 2 , " H o l a , m u n d o " ) ;
ethodWithParameters(2, "Hola, mundo");

10. Mecanismos de paso de
parámetros
Tres maneras de pasar parámetros
entrada Paso por valor
entrada Paso por valor
entrada
entrada Paso por referencia
Paso por referencia
salida
salida
salida Parámetros de salida
salida Parámetros de salida

11. Paso por valor
Mecanismo predeterminado para el paso de
parámetros:
 Se copia el valor del parámetro
 Se puede cambiar la variable dentro del método
 No afecta al valor fuera del método
 El parámetro debe ser de un tipo igual o compatible
at i c v o i d S u m a U n o ( i n t x )
tic void SumaUno(int x)
x++; // Incrementar x
x++; // Incrementar x
at i c v o i d M a i n ( )
tic void Main( )
int k = 6;
int k = 6;
SumaUno(k);
SumaUno(k);
Console.WriteLine(k); // Muestra el valor 6, no
Console.WriteLine(k); // Muestra el valor 6, n

12. Paso por referencia
¿Qué son los parámetros referencia?
 Una referencia a una posición de memoria
Uso de parámetros referencia
 Se usa la palabra clave ref en la declaración y
las llamadas al método
 Los tipos y valores de variables deben coincidir
 Los cambios hechos en el método afectan al
llamador
 Hay que asignar un valor al parámetro antes de
la llamada al método

13. Parámetros de salida
¿Qué son los parámetros de salida?
 Pasan valores hacia fuera, pero no
hacia dentro
Uso de parámetros de salida
 Como ref , pero no se pasan valores al
método
 Se usa la palabra clave out en la
static void OutDemo(out int p)
static void OutDemo(out int p)
{
{ declaración y las llamadas al método
// ...
// ...
}
}
int n;
int n;
OutDemo(out n);
OutDemo(out n);

14. Uso de listas de parámetros de
longitud variable
Se usa la palabra clave params
Se declara como tabla al final de la lista de
parámetros
Siempre paso por valor
static long AddList(params long[ ] v)
static long AddList(params long[ ] v)
{
{
long total, i;
long total, i;
for (i = 0, total = 0; i < v.Length; i++)
for (i = 0, total = 0; i < v.Length; i++)
total += v[i];
total += v[i];
return total;
return total;
}
}
static void Main( )
static void Main( )
{
{
long x = AddList(63,21,84);
long x = AddList(63,21,84);
}
}

15. Normas para el paso de
parámetros
Mecanismos
 El paso por valor es el más habitual
 El valor de retorno del método es útil para un
solo valor
 ref y/o out son útiles para más de un valor de
retorno
 ref sólo se usa si los datos se pasan en ambos
sentidos
Eficiencia
 El paso por valor suele ser el más eficaz

16. Uso de métodos recursivos
Un método puede hacer una llamada a sí
mismo
 Directamente
 Indirectamente
Útil para resolver ciertos problemas

17. Declaración de métodos
sobrecargados
Métodos que comparten un nombre en una
clase
la s s O e r l odistinguen m p l e
a s s Ov eSe oa d i n g E x a examinando la lista de parámetros
v rl adingExample
static int Suma(int a, int b)
static int Suma(int a, int b)
{
{
return a + b;
return a + b;
}
}
static int Suma(int a, int b, int
static int Suma(int a, int b, int c)
c)
{
{
return a + b + c;
return a + b + c;
}
}
static void Main( )
static void Main( )
{
{
Console.WriteLine(Suma(1,2) +
Console.WriteLine(Suma(1,2) + Suma(1,2,3))
Suma(1,2,3))
}
}

18. Signaturas de métodos
Las signaturas de métodos deben
ser únicas dentro de una clase
Definición de signatura
Forman la definición
Forman la definición No afectan a la
No afectan a la
de la signatura
de la signatura signatura
signatura
 Nombre del método
 Nombre del método  Nombre de parámetro
 Nombre de parámetro
 Tipo de parámetro
 Tipo de parámetro  Tipo de retorno de
 Tipo de retorno de
método
método
 Modificador
 Modificador

19. Uso de métodos sobrecargados
Conviene usar métodos sobrecargados si:
 Hay métodos similares que requieren
parámetros diferentes
 Se quiere añadir funcionalidad al código
existente
No hay que abusar, ya que:
 Son difíciles de depurar
 Son difíciles de mantener

20. Ejercicios
1. Desarrolle un programa que calcule la fórmula de energía cinética. El
cálculo debe estar definido en una función que reciba los datos para el
cálculo y que retorne el resultado a una variable. Fórmula: Ec = 1 / 2
* M * V 2.
2. Desarrolle un programa que determine si un número es primo, el
calculo debe ser realizado en una función que recibe como parámetro
el numero a evaluar y retorno si es primo o no (verdadero o falso). Un
número es primo cuando solo es divisible entre él y la unidad. Ej.: 3, 5,
7, 11,17….
3. Desarrolle un programa que calcule en factorial de un numero. El
calculo debe ser realizado en una función que reciba como parámetro
el numero a factorizar.
4. Opcional: Desarrollar el programa de factorial pero con funciones
recursivas