ingeniería en desarrollo de software cuatrimestre 07 ... · aplicaciones mediante comandos de...

Ingeniería en Desarrollo de software

Cuatrimestre 07

Asignatura:

Programación .NET 1

Clave: 150930726

Unidad 3. Estructuras de control

Programación .NET I Unidad 3. Estructuras de control

2

Índice

PRESENTACIÓN DE LA UNIDAD ........................................................................................................................ 3

PROPÓSITOS DE LA UNIDAD ............................................................................................................................ 3

COMPETENCIA ESPECÍFICA ............................................................................................................................... 3

TEMARIO DE LA UNIDAD.................................................................................................................................. 3

TEMA 3.1. ESTRUCTURAS DE CONTROL SELECTIVAS ....................................................................................... 4

TEMA 3.2. ESTRUCTURAS DE CONTROL CÍCLICAS ............................................................................................10

CIERRE DE LA UNIDAD .....................................................................................................................................17

PARA SABER MÁS… .........................................................................................................................................18

FUENTES DE CONSULTA ..................................................................................................................................18


3

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


4

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

cualesquiera 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.

Tema 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 la 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).


5

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

{


}

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)

{


}


6

else

if

{


}

else if

{


}

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;

}


7

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(); } } }


8

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(); } }


9

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"; } }


10

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: http://msdn.microsoft.com/es-es/library/67ef8sbd(v=vs.80).aspx e

ingresa a ella.

Para que reafirmes el tema presentado te invito a que realices la Actividad 1. Estructuras de

control, además de la Actividad 2. Cuadro sinóptico estructuras de control y selectivas

ambas actividades te servirán para identificar características esenciales de éstas

estructuras. Para finalizar con el presente tema, realiza la Actividad 3. Programa

Estructuras de control selectivas, que tiene como finalidad el que utilices las estructuras de

control selectivas.

Tema 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).

http://msdn.microsoft.com/es-es/library/67ef8sbd(v=vs.80).aspx


11

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).

Ésta 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.


12

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.


13

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.


14

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;

}


15

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


{

int n;

Console.WriteLine("Introduce la cantidad de numeros");


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();

}


16

Tabla. Ejemplo de sentencia for en C#:

Ahora, retoma a los autores que se mencionan en ésta 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.


{

int n;

Console.WriteLine("Introduce la cantidad de numeros a leer");


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;

}


17

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.

Para que reafirmes el tema presentado, realiza la Actividad 4. Programa Estructura de

control cíclica, en dónde pondrás en práctica lo estudiado y aprendido en éste tema, ahí

utilizarás las estructuras tales como while y for esto con la finalidad de reforzar

conocimientos en cuanto a programación de los temas presentados.

Autoevaluación

Para reforzar los conocimientos relacionados con los temas que se abordaron en esta

tercera unidad del curso, es necesario que resuelvas la Autoevaluación de la unidad.

Para realizar esta actividad, abre tu archivo de Actividades de la unidad 3.

Finalmente la Evidencia de aprendizaje, que engloba temas el punto 1 y 2 de ésta unidad.

Es de suma importancia que realices esta actividad ya que en ella se integra todo lo

aprendido en cada tema, si tienes alguna duda al momento de su realización, deberás de

retomar el tema.

Autorreflexiones

Además de enviar tu trabajo de la Evidencia de aprendizaje, es importante que ingreses al

foro Preguntas de Autorreflexión y consultes las preguntas que tu Facilitador(a) presente, a

partir de ellas, debes elaborar tu Autorreflexión en un archivo de texto llamado

DPRN_U3_ATR_XXYZ. Posteriormente envía tu archivo mediante la herramienta

Autorreflexiones.

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 ésta 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


18

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.


Charles, Petzold (2006), Manual de referencia .NET Book Zero, Recuperado de:

http://www.charlespetzold.com/dotnet/DotNetBookZero11.pdf

Fuentes de consulta

Ceballos, Fco. Javier Ceballos (2007), Enciclopedia de Microsoft Visual C#, 2da. Edición,

México, Ed. Alfaomega Ra-MA.

MSDN Microsoft, Guía de programación en C# (2012), recuperado de la siguiente dirección


Shart, John Shart & Jagger, Jon Jagger (2002), Microsoft VISUAL C#. NET, APRENDA YA,

España, Ed. Mc Graw Hill.


ingeniería en desarrollo de software cuatrimestre 07 ... · aplicaciones mediante comandos de...

Documents