El diseño descendente pone en práctica la frase "divide y vencerás" de forma que se aborda un problema dividiendo ente en partes más pequeñas. Se dividirá nuevamente cada parte en otras tantas cuantas veces sea necesario hasta limitar acciones más fáciles y capaces de ser desarrolladas por una única persona.
El diseño descendente:
- Simplifica la programación.
- Permite que un programs pueda ser desarrollado por más de una persona.
- Contribuye a la creación d bloques reutilizable.
- Favorece la abstracción.
Abstracción: el mecanismo por el que se consigue que un bloque de código pueda ser usado sin conocer qué función desempeña, que elementos necesita para comenzar a funcionar y cuáles serán las salidas obtenidas.
En el programa principal es donde se soluciona el problema planteado, origen del software, y es donde incluiremos las denominadas llamadas a subprogramas. El programa principal suele ser sencillo y no muy extenso, además al observarlo se denota claramente la funcionalidad del problema que se está desarrollando.
Un subprograma en cambio se encargara de resolver una parte del problema, Un subprograma se codifica pero no se ejecuta hasta que sea "llamado". La llamada a un subprograma consiste en escribir el nombre de este, sin olvidar los paréntesis y posibles parámetros de entrada, cuando nos sea necesario.
Los subprogramas pueden codificarse junto al programa principal, en el mismo fichero o en ficheros externos. En caso de que se incluyan en ficheros externos será necesario hacer alguna referencia a estos para poder usar el subprograma, ejemplo using system;
Los subprogramas suelen ser denominados funciones o procedimientos. La diferencia entre ambos es que devuelven o no un vaslor al programa que los solicita tras ejecutarse.
Estructura básica de una función en C#:
Modificadores tipo_devuelto nombre _ función (lista de parámetros)
{
sentencias;
return expresión; //Solo en caso dequetipo_devuelto sea distinto de void.
}
Donde:
Modificadores: Palabras reservadas que aplicadas sobre la función le proporcionan características adicionales. Por ejemplo: public o static.
Tipo_devuelto: En caso de que la función devuelva algún valor indicaremos aquí el tipo tipo de datos básico que devuelve (int, car, etc.).Si la función no tiene retorno debemos indicarlo con la palabra reservada void.
Nombre_función: Es el identificador de la función que usaremos para realizar la llamada.
Lista_de_parámetros: Representa el conjunto de variables que usaremos en la función. El uso de parámetros permite que puedan utilizarse los valores asignados a variables creadas en otras zonas del código.
Return expresión: Sentencia que indica que debe devolverse un valor.
Ejemplo:
using System;
using System.Net.NetworkInformation;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace tema_4
{
class Program
{
/*
Función estática menu
Parámetros de entrada: ninguno
valor devuelto: entero
estatica entero menu (){...}
*/
static int menu()
{
int opcion;
Console.WriteLine("MENU");
Console.WriteLine("1. información");
Console.WriteLine("2. Ping");
Console.WriteLine("3. Salir");
Console.WriteLine("¿Que desea hacer?");
opcion = int.Parse(Console.ReadLine());
return opcion;
}
/*
Función estática infoRed
Parámetros de entrada: ninguno
valor devuelto: ninguno
estatica void infoRed (){...}
*/
static void infoRed()
{
NetworkInterface[] interfacesRed = NetworkInterface.GetAllNetworkInterfaces();
foreach (NetworkInterface adaptador in interfacesRed)
{
Console.WriteLine(adaptador.Description);
Console.WriteLine("Tipo de adaptador: {0}", adaptador.NetworkInterfaceType);
Console.WriteLine("Dirección MAC: {0}", adaptador.GetPhysicalAddress().ToString());
if (adaptador.Supports(NetworkInterfaceComponent.IPv4))
{
Console.WriteLine("Versión del protocolo IP: IPv4");
}
else
{
Console.WriteLine("Versión del protocolo IP: IPv6");
}
Console.WriteLine("--------------------------------------");
}
}
/*
Función estática ping
Parámetros de entrada: cadena de caracteres (dirección IP)
valor devuelto: ninguno
estatica void ping (cadena ip){...}
*/
static void ping (string ip)
{
Ping ping = new Ping();
PingReply respuesta = ping.Send(ip);
if (respuesta.Status.ToString() == "Success")
{
Console.WriteLine("Correcto, host accesible");
}
else
{
Console.WriteLine("Fallo, host inaccesible");
}
}
/*
Función estática Main (function principal9
Parámetros de entrada: Array de cadenas de caracteres (args)
valor devuelto: ninguno
*/
static void Main (string[] args)
{
int op;
string ip;
do
{
op = menu();
switch (op)
{
case 1:
infoRed(); //llamada a la función inforRed
break;
case 2:
Console.Write("Indica dirección IP:");
ip = Console.ReadLine();
ping(ip); //llamada a la función ping
break;
case 3:
Console.WriteLine("Gracias por usar este software");
break;
default:
Console.WriteLine("Opcion inexsistente");
break;
}
Console.ReadLine();
} while (op != 3);
}
}
}
4.1
4.2
4.3
En la mayoría de lenguajes de programación se distinguen dos métodos para pasar parámetros a una función: paso de parámetro por valor y paso de parámetro por referencia.
- Paso de parámetro por valor: Hace una copia del parámetro pasado, de forma que las posibles modificaciones realizadas sobre él, a nivel local a la función, no alteren su valor en la función principal. Se puede usar como parámetro, variables, constantes y expresiones.
- Paso de parámetro por referencia: Las modificaciones realizadas a nivel local afectarán al valor del parámetro más allá de los límites de la función.Solo puedes usar como parámetro variables.
Ejemplo:
Ejercicio: Realiza un programa que permita cualcular el área de diferentes figuras geométricas de forma que muestre el siguiente menú:
a. Círculo
b. Cuadrado
c. Rectángulo
d. triangulo
e. salir
using System;
namespace cuatro_seis
{
class Program
{
static void area_circulo()
{
const double pi = 3.1415;
double radio, resultado;
Console.WriteLine("Introduzca el radio del circulo");
radio = double.Parse(Console.ReadLine());
resultado = pi * (radio * radio);
Console.WriteLine(resultado);
}
static void area_cuadrado()
{
int lado, resultado;
Console.WriteLine("Introduzca el lado del cuadrado");
lado = int.Parse(Console.ReadLine());
resultado = lado * lado;
Console.WriteLine(resultado);
}
static void area_rectangulo()
{
int ancho, alto, resultado;
Console.WriteLine("Introduzca el ancho del rectangulo");
ancho = int.Parse(Console.ReadLine());
Console.WriteLine("Introduzca el del rectangulo");
alto = int.Parse(Console.ReadLine());
resultado = ancho * alto;
Console.WriteLine(resultado);
}
static void area_triangulo()
{
int bas, altura, resultado;
Console.WriteLine("Introduzca la base del triangulo");
bas = int.Parse(Console.ReadLine());
Console.WriteLine("Introduzca la altura del triangulo");
altura = int.Parse(Console.ReadLine());
resultado = (bas * altura) / 2;
Console.WriteLine(resultado);
}
static int menu()
{
int opcion;
Console.WriteLine("¿De que forma geométrica desea calcular el área?");
Console.WriteLine("1.- circulo");
Console.WriteLine("2.- cuadrado");
Console.WriteLine("3.- ractángulo");
Console.WriteLine("4.- triangulo");
Console.WriteLine("5.- salir");
opcion = int.Parse(Console.ReadLine());
return opcion;
}
static void Main(string[] args)
{
int op, aux=0;
while (aux == 0)
{
op = menu();
switch (op)
{
case 1:
area_circulo();
break;
case 2:
area_cuadrado();
break;
case 3:
area_rectangulo();
break;
case 4:
area_triangulo();
break;
case 5:
Console.WriteLine("bye, bye");
aux = 1;
break;
}
}
Console.ReadKey();
}
}
}
Framework.net
C# dispone de una biblioteca estándar de clases y funciones que proporcionan soporte para las operaciones más utilizadas.
- Funciones de entrada y salida: En este grupo podemos encontrar la clase Console que incluyen las clases necesarias para operar con la entrada, salida y error estándar en aplicaciones de consola.
- Write y WriteLine: Métodos para mostrar información en pantalla.
- Read y ReadLine: Métodos para recoger información introducida por el usuario a través del teclado.
- CapsLock, NumberLock y KeyAvailable: Estados del teclado. Son propiedades.
- Clear: Método que permite borrar la ventana.
- Etc.
- Funciones numéricas: La clase encargada de proporcionar las funciones numéricas es Math.
- Truncate(x): Calcula la parte entera de un número decimal.
- Abs(x): Devuelve el valor absoluto de un número.
- Pow(x,y): Calcula x elevado a y.
- Sqrt(x): Calcula la raíz cuadrada de un número dado.
- Acos(x), Asin(x) y Atan(x): Arco coseno, seno y tangente de x.
- Cos(x), Sin(x) y Tan(x): Coseno, seno y targente de x.
- Exp(x): Calcula e elevado a x
- Log(x): Logaritmo neperiano de x.
- Log10(x): Logaritmo decimal de x.
- Funciones de manipulación de cadenas: La clase String es la encargada de proporcionar los métodos necesarios para la manipulación de cadena de caracteres.
- Length: Propiedad que obtiene la longitud de la cadena de caracteres.
- Compare(string, string): Compara las cadenas de caracteres incluidas entre los paréntesis indicando su ordenación.
- CompareTo(String): Otro metodo de comparación de cadenas. Compara la cadena actual con la que se especifica entre los paréntesis.
- Equals(String): Determina si dos cadenas de caracteres son iguales.
- IndexOf(cgar): Devuelve la posición de la primera aparición del carácter especificado entre los paréntesis.
- Split(Char[]):Divide la cadena en partes en función del elemento delimitador especificado.
- ToLower().Devuelve una copia de la cadena con todos sus caracteres en minúsculas.
- TuUpper(): Devuelve una copia de la cadena con todos sus caracteres en mayúsculas.
- Funciones de fecha y hora: Para obtener la fecha y hora del sistema usaremos la clase DateTime.
- Date: Obtiene la fecha.
- Day, Moth y Year: Obtiene el día, mes y año.
- Hour, Minute y Second: Obtienes horas, minutos y segundos.
- Now: Obtiene la fecha y hora actuales.
- Funciones de carácter: El objeto que proporciona funciones para manipulación de caracteres es Char.
- IsLetter(c): Indica si el carácter introducido "c" es una letra.
- IsDigit(c): Indica si el carácter introducido "c" es un dígito.
- ToUpper(c): Convierte "c" a mayúsculas.
- ToLower(c): Convierte "c" a minúsculas.
- Funciones aleatorias: Se usara la clase Random. A la hora de trabajar con números enteros debemos:
- Inicializar el valor inicial a partir del que se reproduce el ciclo de creación de números aleatorios.
- Generar números aleatorios:
- Next(): Genera un número aleatorio entero.
- Next(valor): Devuelve un número aleatorio positivo menos que valor.
- Next(min,max): Devuelve un número aleatorio positivo en el intervalo min y max.
- NextDouble(): Devuelve un número aleatorio entre 0.0 y 1.0
- Etc
Una función es recursiva cuando entre sus líneas realiza una llamada o invocación a sí misma.´
modificación tipo_devuelto nombre_función (tipo par1,...,tipo parn)
{
...
nombre_función(var1,...var2);
...
}
Se puede distinguir dos tipos de recursividad:
- Recursividad directa: Es aquella en la que la función realiza una llamada a sí misma desde un punto concreto entre sus llaves de inicio y fin.
- Recursividad indirecta: Es aquella en la que la función realiza una invocación a otra función que es quien llama a la primera.
Todos los problemas recursivos presentan una estructura similar, contemplan:
- Un caso base que permite la finalización del problema.
- Casos recursivos que hacen que la función vuelva a ser ejecutada.
Ejemplo: Calcula el factorial de un número. El factorial de un número n es:
n!=n*(n-1)*(n-2)*(n-3)*...*1
Caso base; Si n=1, factorial(1) devuelve 1;
Caso recursivo: Si n>1, factorial(n)=n*factorial(n-1);
Realiza una función recursiva que calcule el Fibonacci de un número especificado, teniendo en cuenta que:
Fibonacci(n)=Fibonacci(n-1)+Fibonacci(n-2).
Fibonacci(0)=0.
Fibonacci(1)=1.
En C# es posible crear en una misma aplicación funciones con el mismo nombre, ya que el lenguaje las diferenciará en función de los parámetros que contengan. Así, podemos tener dos funciones que se llamen igual pero tengan diferente número de parámetros o parámetros de diferentes tipos.
Cuando tenemos una función definida de diferentes formas en un mismo programa, decimos que se ha sobrecargado la función.
0 comentarios:
Publicar un comentario