ARTÍCULO:
“IMPLEMENTACIÓN DE
MÉTODOS EN C#.NET”
2
1.- INTRODUCCIÓN
Los primeros lenguajes de programación eran
lineales o secuenciales
Muy extensos
Poco legibles
Mal organizados
Complicados de corregir o depurar
Duplicidad de código
Programación
estructurada: Usa
subrutinas
(métodos)
3
2.- DEFINICIÓN DE MÉTODO
Es un conjunto de instrucciones que realiza
una tarea específica y bien definida que se
escribe solamente una vez pero puede
invocarse muchas ocasiones.
Antes
se conocían con el nombre de
“subrutinas” o simplemente “rutinas”
4
Métodos
En C# las subrutinas se conocen como
métodos y se clasifican en …
MÉTODOS
Procedimientos – NO devuelven valor
Funciones – Devuelven un valor
5
3.- PROCEDIMIENTOS
Es un método que realiza una acción
específica pero NO devuelve valor.
Se declaran de tipo void
6
Sintaxis de los métodos
< tipoValorDevuelto > < nombreMétodo > (< parámetros >)
{
void significa que NO
devuelve valor (procedimiento)
< cuerpo >
}
Ejemplo:
void Saludo( )
{
Console.Write(“Hola”);
}
7
Ejemplo de un procedimiento
static void Imprimir()
{
Console.WriteLine(Nombre);
Console.WriteLine(Edad);
Console.WriteLine(Sueldo);
}
8
4.- FUNCIONES
Son métodos que realizan alguna acción
específica y bien definida e informan del
resultado obtenido.
Devuelven 1 valor.
Utiliza la sentencia return() para devolver
el valor deseado.
Teóricamente una
función NO puede
devolver más de un valor.
9
Ejemplos de funciones
static int Sumar() // Devuelve un valor de tipo numérico entero
static double Calcular() // Devuelve un valor de tipo numérico real
static string Comparar() // Devuelve un valor de tipo cadena
static double CalcularArea()
{
return(Math.PI * Math.Pow(Radio,2));
}
10
4.1.- Limitación de return()
Teóricamente una función NO puede
devolver más de un valor.
Si se desea que una función devuelva
más de un valor, entonces implemente:
a) Envío de parámetros por referencia (ref).
b) Parámetros de salida (out).
11
5.- ÁMBITO DE LAS VARIABLES:
VARIABLES LOCALES Y GLOBALES
Se conoce como el ámbito de una variable a su disponibilidad
dependiendo de la ubicación de su declaración
El ámbito de una variable define dónde puede usarse esa
variable
Una variable local declarada en un bloque de programa,
sólamente puede ser usada en ese bloque
El ámbito de una variable también aplica a los métodos y a los
ciclos
Ámbito de las variables
Ámbito de
variables
Locales – Se declaran y utilizan dentro de
un contexto específico. No se puede hacer
referencia a ellas fuera de la sección de
código donde se declara.
Globales – Se declaran fuera del cuerpo de
cualquier método
13
Ámbito de variables en un ciclo for
for(int x = 1; x<=10; x++)
{
Console.Write(x);
}
Console.Write(x);
14
Llamadas a los métodos
class Program
{
static void Main(string[] args)
{
Metodo(); // Se invoca (llamada)
}
static void Metodo( )
{
. . . // Codificación
}
}
15
Llamadas de procedimientos
class Program
{
static void Main(string[] args)
{
Procedimiento(); // Llamada
}
El
Procedimiento
NO devuelve
valor
El uso de la
sentencia
return() es
opcional
static void Procedimiento( )
{
Console.Write(“Tec Laredo”);
return();// Fin del Procedimiento
}
}
16
6.- ENVÍO DE PARÁMETROS A
LOS MÉTODOS
Entre los paréntesis se especifican una o mas variables (separadas por
comas) con sus respectivos tipos de datos.
Esas variables estarán accesibles dentro del método.
public void CambiarEstado( string nuevoestado )
{
Dato
de
entrada
estado = nuevoestado;
}
Al momento de invocar el método, se deben incluir esos valores en la
llamada:
CambiarEstado(“Apagado”);
17
Firma de un método
Se le llama la firma al conjunto de
parámetros que recibe un método
La firma de un método define:
a) La cantidad
b) El orden
c) Tipo de dato de cada uno de los
parámetros
18
Firma de un método (cont.)
Debe coincidir la firma de los parámetros
enviados con la firma definida en el método
que los recibe.
Ejemplo:
Si un método tiene una firma con 2
parámetros, entonces cuando se invoque
deben enviarse 2 parámetros (respetando el
orden de los datos enviados).
19
Parámetros recibidos por los
métodos
Parámetros
Por valor – Se envía una copia del valor de
la variable
Por referencia – Se envía la dirección de la
variable
20
6.1.- Envío de parámetros por valor
class Program
{
static void Main(string[] args)
{
int x=10;
Metodo( x ); // Se envía el valor de x
Console.Write(“x=“+x.ToString()); // x=10
}
static void Metodo(int y)
{
y+=5;
Console.Write(“y=“+y.ToString()); // y=15
}
}
21
Envío de parámetros por valor
22
class Program
{
static int x = 5; // Variable global
static void Main(string[] args)
{
int y = 13; // Variable local
Console.WriteLine("\nx=" + x);
// Llamada al método y envío por valor
Metodo(y);
Console.WriteLine("\nx=" + x);
Console.WriteLine("\ny=" + y);
Console.ReadKey();
}
// El parámetro "a" recibe el valor de "y"
static void Metodo(int a)
{
a = a + 3;
Console.WriteLine("\na=" + a);
x = x * 2;
}
}
23
Descargar el ejemplo de parámetro
por valor en
http://www.itnuevolaredo.edu.mx
/Takeyas/libroED/Prog7-1.rar
24
6.2.- Envío de parámetros por
referencia
static void Main(string[] args)
{
int x = 10;
Metodo(ref x); // Se envia la referencia de x
Console.WriteLine("x=" + x); // x=15
Console.ReadKey();
}
static void Metodo(ref int y)
{
y += 5;
Console.WriteLine("\n\ny=" + y); // y=15
}
25
class Program
{
static int x = 5; // Variable global
static void Main(string[] args)
{
int y = 13; // Variable local
Console.WriteLine("\nx=" + x);
// Llamada al método y envío por referencia
Metodo(ref y);
Console.WriteLine("\nx=" + x);
Console.WriteLine("\ny=" + y);
Console.ReadKey();
}
// El parámetro "a" recibe la ref. de "y"
static void Metodo(ref int a)
{
a = a + 3;
Console.WriteLine("\na=" + a);
x = x * 2;
}
}
26
Envío de parámetros por referencia
27
Descargar el ejemplo de parámetro
por referencia (ref) en
http://www.itnuevolaredo.edu.mx
/Takeyas/libroED/Prog7-2.rar
28
6.3.- Parámetros de salida (out)
Son muy parecidos a los parámetros por
referencia (ref)
El parámetro ref debe ser inicializado antes
de enviarse
El
no
es
parámetro
necesario
inicializarlo antes de enviarlo, sino que lo
inicializa el método.
out
29
class Program
{
static int x = 5; // Variable global
static void Main(string[] args)
{
int y = 13; // Variable local
bool esImpar;
Console.WriteLine("\nx=" + x);
// Llamada al método y envío por referencia
Metodo(ref y, out esImpar);
Console.WriteLine("\nx=" + x);
Console.WriteLine("\ny=" + y);
if (esImpar)
Console.WriteLine("\ny es un número impar");
else
Console.WriteLine("\ny es un número par");
Console.ReadKey();
}
// El parámetro "a" recibe la referencia de "y" y el parámetro de salida sirve para determinar si el parámetro
enviado es Impar
static void Metodo(ref int a, out bool Impar)
{
a = a + 3;
Console.WriteLine("\na=" + a);
x = x * 2;
if (a % 2 != 0)
Impar = true;
else
Impar = false;
}
}
30
Descargar el ejemplo de parámetro
de salida (out) en
http://www.itnuevolaredo.edu.mx
/Takeyas/libroED/Prog7-3.rar
31
RECIBIENDO EL VALOR
7.-
DEVUELTO POR UNA FUNCIÓN
El “Tipo de dato” del método NO es “void”.
Dentro del método debe haber una sentencia “return” con algún valor del
tipo de dato del método.
Ejemplo (Al declararlo):
public string ConsultarEstado()
{
return estado;
}
Al llamar al método (desde el programa):
string estado_actual = miCarro.ConsultarEstado();
32
32
Llamadas de métodos que retornan
valor (funciones)
static void Main(string[ ] args)
Parámetro enviado
a la función
{
}
Variable
receptora
double Radio = 10, Area;
Area = Funcion(Radio);
Console.WriteLine("Area=" + Area);
Console.ReadKey();
Valor devuelto por la
Función
static double Funcion(double r)
{
return (Math.PI * Math.Pow(r,2));
}
33
class Program
{
static void Main(string[] args)
{
double Radio, Area;
Console.Write("Teclee el valor del radio: ");
Radio = double.Parse(Console.ReadLine());
// La variable Area recibe el valor devuelto por la función
Area = CalcularArea(Radio);
Console.Write("Área = " + Area);
Console.ReadKey();
}
static double CalcularArea(double r)
{
return (Math.PI * Math.Pow(r, 2));
}
}
34
Descargar el ejemplo de recepción
del valor devuelto por una función
en
http://www.itnuevolaredo.edu.mx
/Takeyas/RepasoFP/Prog4.rar
35
Otros títulos del autor
http://www.itnuevolaredo.edu.mx/Takeyas/Libro
[email protected]
Bruno López Takeyas
Comentarios de: Implementación de Métodos en CSharp .NET (0)
No hay comentarios