Carrera: Desarrollo de software Semestre 5

Programación net I Unidad 3. Estructuras de control

Ciencias Exactas, Ingeniería y Tecnología | Desarrollo de Software 1

Carrera: Desarrollo de software Semestre 5

Asignatura: Programación net I

Unidad 3. Estructuras de control

Ciudad de México, Octubre, 2021

Clave: 15143526

Universidad Abierta y a Distancia de México



Índice

Presentación de la unidad ........................................................................................................ 3

Propósitos de la unidad ............................................................................................................ 3

Competencia específica ........................................................................................................... 3

Temario de la unidad ................................................................................................................ 3

3.1. Estructuras de control selectivas ....................................................................................... 4

3.2. Estructuras de control cíclicas ......................................................................................... 10

Cierre de la unidad ................................................................................................................. 17

Para saber más… ................................................................................................................... 17

Fuentes de consulta ............................................................................................................... 17



Presentación de la unidad Bienvenido(a) a la asignatura Programación .NET I. En esta tercera unidad, conocerás sobre las estructuras de control, su implementación y uso; además de las estructuras cíclicas, de las cuales, al igual que las de control, se mostrará su uso e implementación en el entorno C# .Net. Es importante que estudies estos dos tipos de estructuras debido a que con el uso de ellas podrás tomar ciertas decisiones dentro de la programación; estas decisiones podrán ir desde permitir acceder a un método o no, hasta ingresar o no al sistema, entre otras. La Unidad 3. Estructuras de control, representa el cierre de la asignatura, por lo tanto, es importante que recuperes contenidos vistos en unidades anteriores y los integres a tu revisión de textos y sobre todo, los apliques a las evidencias que en la unidad realizarás. Por lo anterior, es menester que atiendas a cada una de las indicaciones que en el programa se te presentan y que realices todas las actividades. Propósitos de la unidad Conocer y entender las estructuras cíclicas y de control, especialmente su uso, declaración y características que ayudarán al mejor manejo y realización de programas en ésta plataforma de .Net. Competencia específica Utilizar las estructuras de control que ofrece la plataforma .NET para resolver problemas de aplicaciones mediante comandos de programación. Temario de la unidad 3. Estructuras de control 3.1 . Estructuras de control selectivas

3.1.1. If – else 3.1.2. If anidados 3.1.2. Switch – case

3.2. Estructuras de control cíclicas 3.2.1. While 3.2.2. Do – While 3.2.3. For



Unidad 3. Estructuras de control En la programación tanto estructurada como orientada a objetos, es necesario tomar decisiones de cualquier tipo, por ejemplo: permitir que un usuario acceda al sistema, dar al usuario una información dependiendo de qué datos haya insertado, o detener un proceso cualquiera porque ya no hay más registros para mostrar. Para realizar acciones como las mencionadas (y muchas más) en programación se utilizan las estructuras de control, las cuales se subdividen en estructuras de control selectivas (if.else, if anidados y switch-case), que son aquellas que nos van a permitir seleccionar sólo los procesos autorizados en estas estructuras. Otras son las estructuras de control cíclicas (while, do-while y for), también conocidas como ciclos, utilizados para que un proceso se ejecute según el número de veces que ahí se indica y posteriormente se detenga. Te invito a que conozcas más a fondo sobre cada una de estas estructuras, las cuales se te presentarán en los siguientes temas. 3.1. Estructuras de control selectivas Una de las partes importantes en la programación, tanto estructurada como orientada a objetos, es lo que se conoce como estructuras de control selectivas, se les llama así por ser las que permiten tomar ciertas decisiones dentro de un programa e incluso realizar ciclos de operaciones hasta que se cumpla la instrucción seleccionada. Podemos definir como objetivo principal de éste tema, el conocer y definir características, uso y declaración de las estructuras de control selectivas tal como if- else, if anidados y switch – case, en el entorno de programación C# .Net. Las estructuras de control selectivas tienen grandes utilidades; dentro de las principales, se destaca el que puedas tomar decisiones dentro de un programa; por ejemplo, si deseas realizar una calculadora y le pides al usuario que ingrese algunos de los signos que identifican la operación a realizar (P.e. “+, -, *, /”), necesitas tener una condición que permita seleccionar, en base a lo ingresado por el usuario, qué operación se realizará. Otro ejemplo es: si quieres realizar un cierto descuento, por ejemplo, un 10%, si la compra es mayor o igual a $1000.00, necesitas una sentencia que pregunte si el monto de la compra es mayor o igual a $1000.00, y si lo es, aplicará un descuento, si no, se hará el cobro normal. Lo anterior son algunos pequeños ejemplos escritos de lo que se realizan con estructuras de control, veamos que dicen los autores acerca de estos términos.



Ceballos, F (2007) menciona que “Las estructuras de control, también conocidas como sentencias en C#, son expresiones, declaraciones o llamadas a métodos.” (p. 47).

Según éste mismo autor, se deben de tener en cuenta ciertas consideraciones al momento de declarar una sentencia en C#:

• Terminar con un punto y coma todas las sentencias simples (;). • Se pueden declarar dos o más sentencias en una sola línea, pero es necesario

separarlas con un punto y coma. • Las sentencias que sean nulas, se terminan simplemente con un punto y coma (;).

Ceballos, F (2007) determina que “La sentencias de control permiten tomar decisiones y realizar un proceso repetidas veces” (p. 56-57).

• Sentencia If- else. Sharp John & Jagger Jon (2002), define que: “Una sentencia if se utiliza cuando se desea ejecutar una o más sentencias si el resultado de una expresión booleana es verdadera. También se puede utilizar una cláusula opcional cuando se desea ejecutar una o más sentencias si el resultado de la función booleana es falso”. (p.p. 60 - 64).

Declaración

If (condición) { (Sentencias, operaciones, impresiones…1); } Else if { (Sentencias, operaciones, impresiones…2); }

Generalmente la condición es una expresión booleana y las sentencias, representan sentencias o procedimientos simples o compuestos.

• If anidados Los if (si) anidados no son más que una condición dentro de otra antepuesta por la palabra else (entonces).

Sharp John & Jagger Jon (2002), define que “Las sentencias if se pueden anidar dentro de otras sentencias if. De ésta forma se pueden encadenar una secuencia de expresiones booleanas”. (pp. 62).



If (condición) { (Sentencias, operaciones, impresiones…1); } else if { (Sentencias, operaciones, impresiones…2); } else if { (Sentencias, operaciones, impresiones…2); }

• switch – case

Ceballos, F (2007) determina que “La sentencia switch permite ejecutar una de varias acciones, en función del valor de una expresión. Es una sentencia especial para decisiones múltiples”. (p.p. 57 - 58) La sentencia switch – case se declara de la siguiente forma. El switch evalúa la expresión entre paréntesis y compara su valor con las constantes de cada Case. Switch (expresión) Case expresión – constante 1:] Sentencia1; Case expresión – constante 1:] Sentencia1; … [default:] Sentencia n; }



Tabla. Ejemplo de estructura if en C#, fuera de un método.

namespace EstructuraIf { class Estructura { //Tenemos declarado el método Main static void Main(string[] args) { //Declaramos las variables que almacenaran los valores ingresados por //los usuarios y una más denominada operación que almacenará //la opción de la operación que el usuario seleccione. int num1; int num2; string operacion; //En ésta ocasión vamos a decorar un poco la consola :) //Agregamos un título al programa Console.Title = "Mi primer estructura en C#"; // Damos formato a la consola Console.BackgroundColor = ConsoleColor.White; Console.ForegroundColor = ConsoleColor.Blue; ///Limpiamos por si hubiera basura Console.Clear(); //Pedimos al usuario introduzca el primer valor Console.WriteLine("Introduzca el primer número"); num1 = Int32.Parse(Console.ReadLine()); //Pedimos al usuario introduzca el primer valor Console.WriteLine("Introduzca el segundo número"); num2 = Int32.Parse(Console.ReadLine()); //Pedimos al usuario introduzca el valor de la operación a realizar. Console.WriteLine("Escoja una opción: + para Sumar ó * para Multiplicar"); operacion = (Console.ReadLine()); //En ésta sección declaramos la sentencia if, la cual lo que realiza es //una inspección preguntando por la opción de la operación que el usuario //seleccionó, esto porque de lo seleccionado depende la operación que el //sistema realizará. //si la operación seleccionada es + de Sumar, entrará a ésta condición if (operacion == "+" ) { Console.WriteLine("La suma es =: " + (num1 + num2)); Console.WriteLine("Gracias por utilizar mi programa :)"); } //Si no es sumar lo que el usuario ingresa, entonces preguntaría si //la operación es multiplicar o * y entrara a ésta segunda condición else if (operacion == "*") { Console.WriteLine("La multiplicación es =: " + (num1 * num2)); Console.WriteLine("Gracias por utilizar mi programa :)"); } else { Console.WriteLine("La opción de la operación seleccionada es incorrecta, lo siento, vuelve a intentar :("); } Console.ReadLine(); } } }



Tabla. Ejemplo de if anidados en C#, fuera de un método.

class Anidados { static void Main(string[] args) { int num1, num2, num3; //En ésta ocasión vamos a decorar un poco la consola :) //Agregamos un título al programa Console.Title = "Mi primer estructura anidada en C#"; // Damos formato a la consola Console.BackgroundColor = ConsoleColor.White; Console.ForegroundColor = ConsoleColor.Blue; ///Limpiamos por si hubiera basura Console.Clear(); //uso del IF anidados //Pedimos al usuario introduzca el primer valor Console.WriteLine("Ingrese el primer número entero"); num1 = int.Parse(Console.ReadLine()); Console.WriteLine("Ingrese el segundo numero entero"); num2 = int.Parse(Console.ReadLine()); Console.WriteLine("Ingrese el tercer numero entero"); num3 = int.Parse(Console.ReadLine()); //ESTRUCTURA IF ANIDADA //El siguiente es el primer if if (num1 > num2 && num1 > num3) { //Mandamos imprimir, los números entre paréntesis indican el orden de los valores //impresión, los cuales son indicados por las variables después de las comillas. Console.WriteLine("En número {0} es mayor que , {1} y que, {2} ", num1, num2, num3); } else { //El siguiente es el segundo if dentro del primero if (num2 > num3) { Console.WriteLine("En número {1} es mayor que {0} y {2}", num1, num2, num3); } //El siguiente es la última condición dentro del if else { Console.WriteLine("En número {2} es mayor que {0} y {1}", num1, num2, num3); } } Console.ReadLine(); } }



Tabla. Ejemplo de sentencia switch - case en C#, fuera de un método.

class Seleccion { public static void Main(string[] args) { //Se declaran las variables float primero; float segundo; string operacion; Console.Title = "Especia de calculadora"; Console.Clear(); // Posicionamos el cursor y pedimos el primer número Console.SetCursorPosition(3, 2); Console.WriteLine("Introduce el primer número"); Console.SetCursorPosition(55, 2); primero = float.Parse(Console.ReadLine()); Console.SetCursorPosition(3, 3); // Posicionamos el cursor y pedimos la operación Console.WriteLine("Que operación que deseas realizar (+,-,*,/)"); Console.SetCursorPosition(60, 3); operacion = Console.ReadLine(); Console.SetCursorPosition(3, 4); // Posicionamos el cursor y pedimos el segundo número Console.WriteLine("Introduce el segundo número"); Console.SetCursorPosition(55, 4); segundo = float.Parse(Console.ReadLine()); // Mostramos el resultado Console.SetCursorPosition(55, 5); Console.WriteLine("__________"); Console.SetCursorPosition(3, 6); Console.WriteLine("El resultado es"); Console.SetCursorPosition(60, 6); Console.WriteLine(calcular(primero, segundo, operacion)); // manda llamar al método e imprime el resultado Console.ReadKey(); } private static string calcular(float primero, float segundo, string operacion) { float temp; // Se declara la sentencia switch, en la cual se realizará e caso u operación elegida. switch (operacion) { case "+": temp = primero + segundo; return temp.ToString(); case "-": temp = primero - segundo; return temp.ToString(); case "*": temp = primero * segundo; return temp.ToString(); case "/": temp = primero / segundo; return temp.ToString(); } return "-1"; } }



Para profundizar más sobre el tema, te invito a que no sólo te quedes con la teoría que aquí se menciona, si no que leas cada uno de los autores que se están indicando y realices los ejercicios que ellos presentan, esto para una mejor comprensión del tema. Comienza con Sharp John & Jagger Jon (2002, pp. 60-67), quienes describen, de forma clara, la definición y utilidad de ésta sentencia, además de algunas reglas a seguir cuando las apliques. De igual forma te muestra una serie de ejemplos y un ejercicio donde aplicarás las estructuras de control estudiadas. Otro autor, Ceballos, F. (2007, pp. 47, 56-57), define qué es una sentencia en C# y la explica, además al igual que Sharp, te muestra definición de cada una de las estructuras de control selectivas y te da ejemplos para su mejor comprensión. Por lo tanto, revisa dicho texto, que encontrarás en los materiales descargables de la unidad. Ingresa al sitio de MSDN (2012), en el cual encontrarás ejemplos y ejercicios de gran utilidad para la utilización de estas estructuras; debido a que, este es un sitio Web directo de Microsoft; puedes indagar un poco más, dentro de él, sobre ésta estructuras de control. Copia la siguiente url: https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/ e ingresa a ella. 3.2. Estructuras de control cíclicas Dentro de la programación, existen estructuras o sentencias que realizan la función de un ciclo, es decir, realizan operaciones o procesos en repetidas ocasiones hasta que se cumple la condición dada; por ejemplo: cuando se tiene como condición sumar números del 1 al 18, se realiza una condición que pregunta por la variable que almacena un contador y al momento de llegar a 18, se detendrá y una vez finiquitada, se puede imprimir el resultado. Es de suma importancia conocer cómo funcionan éstas sentencias, debido a que dependiendo del problema que se llegue a presentar en algún momento, pueden ser éstas las que te posibiliten plantear soluciones. Comencemos por:

• Sentencia While

Sharp John & Jagger Jon (2002) apuntan que: “Se utiliza una sentencia para ejecutarla repetidamente mientras una expresión booleana continúa siendo verdadera”. (pp. 73-74). Ceballos, F (2007) determina que: “La sentencia while ejecuta una sentencia, simple o compuesta, cero o más veces, dependiendo del valor de una expresión booleana” (pp.59).



Características: Como te darás cuenta, los dos autores anteriores concuerdan en que la sentencia while es predefinida por un expresión booleana, la cuál es la que nos ayuda a comparar en forma de true o false.

• Condición es la que se compara una variable previamente definida con un tipo definido.

• Sentencia es la expresión u operación que se realiza dentro del ciclo while. • Incremente es el incremento que tendrá la variable para ser comparada en la

condición nuevamente.

Declaración: While (condición) { Sentencia; incremento }

Tabla. Ejemplo del MSDN de Microsoft (recuperado de: http://msdn.microsoft.com/es-es/library/2aeyhxcd(v=VS.80).aspx):

int n = 1; while (n < 6) { Console.WriteLine("El valor de n es {0}", n); n++; } • Sentencia Do-While

Ceballos, F. (2007) menciona que: “La sentencia do-while ejecuta una sentencia simple o compuesta, una o más veces dependiendo del valor de una expresión” (p. 60). Esta sentencia, de las tres que veremos en éste tema, es un tanto diferente, debido a que la comprobación booleana o condición en el caso del While (como se revisó anteriormente) y el For (que revisarás), se realizan al principio del bucle, más sin embargo en el caso del do-while, esta comparación se realiza al final del bucle. Características

• Se evalúa la condición al final de la sentencia.



• Sentencia, es la expresión u operación a realizarse. • Expresión booleana, pertenece a la condición que evaluará a la variable previamente

definida y con un tipo de dato también definido. • Incremento es el incremento que tendrá la variable para ser comparada en la

Expresión booleana.

Declaración: do {

sentencia incremento

}while ( ExpresiónBooleana o condición)

Tabla. Ejemplo obtenido del MSDN de Microsoft (recuperado de: http://msdn.microsoft.com/es-es/library/370s1zax(v=VS.80).aspx).

int x = 0; do { Console.WriteLine(x); x++; } while (x < 5);

• Sentencia For En el MSDN de Microsoft (2012), se menciona que “la sentencia o mejor conocida como ciclo o bucle for ejecuta una instrucción o un bloque de instrucciones repetidamente hasta que una determinada expresión se evalúa como false. El bucle for es útil para recorrer en iteración matrices y para procesar secuencialmente”. Ceballos, F. (2007) determina que: “La sentencia for permite ejecutar una sentencia simple o compuesta, repetidamente un número de veces conocido”. (pp.60 - 61)

• Características

• Se inician las variables. • Se evalúa la condición:

o Si es verdadero (true), se ejecuta la expresión y se regresa al inicio de este punto, evaluar la condición.

o Si es falso (false), la ejecución de la sentencia se da por terminada.



• Declaración

La forma correcta de declarar una sentencia for, es la siguiente: for ( v1 = e; condición; incremento) { Sentencia;

}

Dónde: • v1 es una variable que está definida por un tipo y se inicializa con algún valor. • e es el valor que inicializa a la variable v1. • Condición es la condición que se debe de ejecutar, generalmente es la v1

comparada con otro valor definido. • Incremento es el incremento que tendrá la variable v1 para compararse en cada

ciclo con la condición. • Sentencia es la expresión o proceso que se ejecuta dentro del ciclo.

Ejemplo: for (int i = 1; i <= 5; i++) { Console.WriteLine(i); } Una vez vistos los temas referentes a las sentencias de control cíclicas, te invito a que realices los ejercicios que se te presentan en los textos para una mejor comprensión. Estos ejercicios son de gran importancia por que muestran cómo es que funcionan éstas estructuras de control, además de que podrás tomarlo de referencia para realizar las actividades de la unidad y muchos otros ejercicios que necesites.



Tabla. Ejemplo de sentencia WHILE en C#:

static void Main(string[] args) { int n; Console.WriteLine("Introduce el valor de N"); n = int.Parse(Console.ReadLine()); Console.WriteLine("La suma es: " + calcular(n)); Console.ReadKey(); } public static double calcular(int n) { int i=1; double suma=0; while (n>=i) { suma = suma + (1.0/i); i++; } return suma; }



Tabla. Ejemplo de sentencia DO-WHILE en C#:

static void Main(string[] args) { int n; Console.WriteLine("Introduce la cantidad de numeros"); n = int.Parse(Console.ReadLine()); calcular(n); } public static void calcular(int n) { int i=1; int mayor=0; int menor=0; int valor; double suma=0; do { Console.WriteLine("Introduce el valor" + i); valor = int.Parse(Console.ReadLine()); if (i == 1) { mayor = valor; menor = valor; suma = suma + valor; } else { if (valor > mayor) { mayor = valor; } if (valor < menor) { menor = valor; } suma = suma + valor; } i++; } while (n >= i); suma = suma / n; Console.WriteLine("El numero mayor es: " + mayor); Console.WriteLine("El numero menor es: " + menor); Console.WriteLine("El promedio es: " + suma); Console.ReadKey(); }



Tabla. Ejemplo de sentencia for en C#:

Ahora, retoma a los autores que se mencionan en esta unidad y realiza los diversos ejercicios que has visto, no sólo en los temas de ésta unidad, si no que relaciones tus programas con temas de las unidades pasadas. Revisa a Ceballos, F. (2007, pp. 47, 57-59), que muestra de forma clara y específica, definiciones de las estructuras de control cíclicas, además de la forma en que se declaran y se utilizan; esto lo hace con base en ejemplos simples que te ayudarán a lograr una mejor comprensión del tema, te invito a que realices los ejercicios presentados. Sharp John & Jagger Jon (2002, pp. 73 - 78), muestran la definición de estas estructuras, pero se enfoca más a su utilidad, mencionando ciertas características a éstas y presentando ejemplos que podrás realizar para una mejor comprensión.

static void Main(string[] args) { int n; Console.WriteLine("Introduce la cantidad de numeros a leer"); n = int.Parse(Console.ReadLine()); Console.WriteLine("El numero mayor es: " + calcular(n)); Console.ReadKey(); } public static int calcular(int n) { int i; int valor = 0; int mayor = 0; for (i = 1; i <= n; i++) { Console.WriteLine("Introduce el numero" + i); valor = int.Parse(Console.ReadLine()); if (i == 1) { mayor = valor; } else { if (valor > mayor) mayor = valor; } } return mayor; }



Finalmente, en el sitio de MSDN (2012), encontrarás tanto definiciones como explicaciones; pero lo más importante es que: ahí podrás encontrar pequeños ejercicios que te ayudarán a complementar el tema, realízalos para reforzar el conocimiento. Cierre de la unidad Durante el desarrollo de la unidad revisaste el manejo de estructuras de control, tales como la sentencia IF y SWITCH-CASE, utilizada para tomar ciertas decisiones dentro de un programa; sin embargo, también nos enfocamos a conocer las estructuras cíclicas tales como los bucles, WHILE, DO-WHILE y FOR, utilizados en la realización de expresiones sentencia dentro de un programa repetidas veces hasta que se cumpla una condición booleana. Al concluir esta unidad (Estructuras de control), concluimos también con la materia Programación .Net 1. Por tal motivo se espera que cada uno de los temas vistos durante la materia hayan sido entendidos de forma clara, ya que serán aplicados en programas derivados de problemas reales, en los cuáles podrás implementar todo lo hasta aquí visto. Si te quedo duda en algunos de los temas estudiados, te invito a que retomes tus notas y materiales de consulta, repásalos a la vez que realizas los ejercicios nuevamente, ya que esto te ayudará a tener un aprendizaje significativo sobre la Programación .NET. Para saber más… Si deseas saber más acerca de los temas vistos en ésta unidad, revisa el MSDN de Microsoft o a cada uno de los autores que se presentan en las fuentes de consulta. https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/ Charles, Petzold (2006), Manual de referencia .NET Book Zero, Recuperado de: http://www.charlespetzold.com/dotnet/ Fuentes de consulta

Ceballos, Fco. Javier (2007). Enciclopedia de Microsoft Visual C#. 2da. Ed. México: Ed. Alfaomega Ra-MA.



MSDN Microsoft (2017). Guía de programación en C#. Recuperado de: https://docs.microsoft.com/es-es/dotnet/csharp/programming-guide/

Shart, John Shart & Jagger, Jon (2002). Microsoft VISUAL C#. NET. Aprenda ya. España: Ed. Mc Graw Hill.

Carrera: Desarrollo de software Semestre 5

Documents

Transcript of Carrera: Desarrollo de software Semestre 5