ingeniería en desarrollo de software cuatrimestre 07 ... · aplicaciones mediante comandos de...
Post on 01-Oct-2018
219 Views
Preview:
TRANSCRIPT
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
Programación .NET I Unidad 3. Estructuras de control
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
Programación .NET I Unidad 3. Estructuras de control
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).
Programación .NET I Unidad 3. Estructuras de control
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
{
(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);
}
Programación .NET I Unidad 3. Estructuras de control
6
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;
}
Programación .NET I Unidad 3. Estructuras de control
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(); } } }
Programación .NET I Unidad 3. Estructuras de control
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(); } }
Programación .NET I Unidad 3. Estructuras de control
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"; } }
Programación .NET I Unidad 3. Estructuras de control
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).
Programación .NET I Unidad 3. Estructuras de control
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.
Programación .NET I Unidad 3. Estructuras de control
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.
Programación .NET I Unidad 3. Estructuras de control
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.
Programación .NET I Unidad 3. Estructuras de control
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;
}
Programación .NET I Unidad 3. Estructuras de control
15
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();
}
Programación .NET I Unidad 3. Estructuras de control
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.
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;
}
Programación .NET I Unidad 3. Estructuras de control
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
Programación .NET I Unidad 3. Estructuras de control
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.
http://msdn.microsoft.com/es-es/library/67ef8sbd(v=vs.80).aspx
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
http://msdn.microsoft.com/es-es/library/67ef8sbd(v=vs.80).aspx
Shart, John Shart & Jagger, Jon Jagger (2002), Microsoft VISUAL C#. NET, APRENDA YA,
España, Ed. Mc Graw Hill.
top related