Tabla de contenidos
1. INTRODUCCIÓN A .NET...4
1.1. OBJETIVOS... 4
1.1.1. Mapa del Curso...4
1.2. QUE ES .NET ... 5
1.3. QUE ES C# (SHARP) ... 6
2. ENTORNO DE DESARROLLO ...7
2.1. OBJETIVOS... 7
2.1.1. Mapa del Curso...7
2.2. EL COMPILADOR
... 8
2.3. LOS ARCHIVOS FUENTES (“*.CS”)... 8
2.4. COMO ESTÁ FORMADO EL FRAMEWORK .NET ... 9
3. SINTAXIS Y SEMÁNTICA DE C# ...11
3.1. OBJETIVOS... 11
3.1.1. Mapa del Curso...11
3.2. VARIABLES Y CONSTANTES
... 12
3.2.1. Que es una variable ...12
3.2.2. Que es una constante ...13
3.3. TIPOS DE DATO
... 15
3.3.1. Introducción ...15
3.3.2. Tipos de datos básicos ...18
3.4. CONSTRUCCIONES DEL LENGUAJE... 19
3.4.1. Introduccion ...19
3.4.2. Sentencias...19
3.4.3. Bloques de código ...19
3.5. OPERADORES
... 21
3.5.1. Que es un operador...21
3.5.2. Que es un Operador?...22
3.5.3. Operaciones aritméticas ...22
3.5.4. Operaciones lógicas...22
3.5.5. Operaciones relacionales ...23
3.5.6. Operaciones de asignación...23
3.5.7. Operaciones con cadenas ...24
3.5.8. Operador condicional...24
3.6. INSTRUCCIONES DE CONTROL DE FLUJO
... 26
3.6.1. Introduccion ...26
3.6.2. Instrucción if...else ...27
3.6.3. Instrucción switch ...28
3.6.4. Instrucción while...30
3.6.5. Instrucción do...while...32
3.6.6. Instrucción for...33
3.6.7. Instrucción break ...35
3.6.8. Instrucción continue...35
3.6.9. Instrucción return ...36
3.6.10. Instrucción goto ...37
3.7. COMENTARIOS... 39
3.7.1. Que es un comentario ...39
4. ARREGLOS ...41
4.1. OBJETIVOS... 41
4.1.1. Mapa del Curso...41
4.1.2. Descripción ...42
4.1.3. Metas ...42
4.2. INTRODUCCION
... 43
4.3. ARREGLOS DE UNA DIMENSION
... 43
4.4. OPERACIONES DE ACCESO A ARREGLOS
... 44
5. INTRODUCCIÓN A LA PROGRAMACIÓN VISUAL ...45
5.1. OBJETIVOS... 45
5.1.1. Mapa del Curso...45
5.2. QUE ES LA PROGRAMACIÓN VISUAL
... 46
5.3. LOS WINDOWS FORMS
... 46
5.4. COMPONENTES
... 47
5.5. PROPIEDADES
... 47
5.6. EVENTOS... 48
6. LABORATORIOS...49
6.1. OBJETIVOS... 49
6.1.1. Mapa del Curso...49
6.2. RECOMENDACIONES
... 50
6.3. LAB 1 - UTILIZACIÓN DE LA ESTRUCTURA DE CONTROL IF... 50
6.3.1. Ejercicio 1 ...50
6.3.2. Ejercicio 2 ...50
6.3.3. Ejercicio 3 ...51
6.4. LAB 2 - UTILIZACIÓN DE LA ESTRUCTURA DE CONTROL WHILE ... 52
6.4.1. Ejercicio 1 ...52
6.4.2. Ejercicio 2 ...52
6.4.3. Ejercicio 3 ...52
6.4.4. Ejercicio 4 ...52
6.4.5. Ejercicio 5 ...52
6.4.6. Ejercicio 6 ...52
6.4.7. Ejercicio 7 ...53
6.4.8. Ejercicio 8 – BONUS!...53
6.4.9. Ejercicio 9 – BONUS!...53
6.5. LAB 3 - UTILIZACIÓN DE LA ESTRUCTURA DE CONTROL FOR ... 54
6.5.1. Ejercicio 1 ...54
6.5.2. Ejercicio 2 ...54
6.5.3. Ejercicio 3 ...54
6.5.4. Ejercicio 4 ...54
6.5.5. Ejercicio 5 ...54
6.5.6. Ejercicio 6 ...54
6.5.7. Ejercicio 7 ...55
6.5.8. Ejercicio 8 ...55
6.5.9. Ejercicio 9 ...55
6.5.10. Ejercicio 10 – BONUS!...56
6.5.11. Ejercicio 11 – BONUS!...56
6.6. LAB 4 - UTILIZACIÓN DE VECTORES
... 57
7. INTRODUCCIÓN AL PARADIGMA DE OBJETOS ...62
7.1. OBJETIVOS... 62
7.1.1. Mapa del Curso...62
7.1.2. Descripción ...63
7.1.3. Metas ...63
7.2. ACERCA DE ESTE CAPITULO - IMPORTANTE ... 64
7.3. CONCEPTOS
... 64
7.3.1. Introducción ...64
7.3.2. Por que Objetos? ...65
7.3.3. Objetos como Tipos de Datos ...66
7.3.4. Conceptos básicos (clase, objeto, encapsulación) ...66
7.3.5. Propiedades (variables)...67
7.3.6. Métodos (funciones)...68
7.4. HERENCIA
... 69
7.4.1. Introducción ...69
7.4.2. Características ...70
7.5. VISIBILIDAD... 71
7.5.1. Encapsulamiento...71
1.
Introducción a .NET
1.1. Objetivos
1.1.1. Mapa del Curso
1. Introducción a .NET
2. Entorno de Desarrollo
3. Sintaxis y Semántica de C#
4. Arreglos
5. Introducción a la Programación Visual
6. Laboratorio
1.2. Que es .NET
Realmente, el concepto de .NET (“dotNET” o “punto NET”) es demasiado amplio, así que lo resumiremos en pocas palabras : Es una plataforma de desarrollo multi-lenguaje, que está pensada para correr sobre distintos entornos operativos, y que pretende unificar los distintos paradigmas de la programación (escritorio, cliente-servidor, WEB, etc.) en un mismo ambiente de trabajo.
.NET está formado por cuatro componentes principales, a saber :
1. El CLR (Common Language Runtime). Es el entorno de ejecución para las aplicaciones que pueden haber sido escritas en alguno de los diferentes lenguajes que cumplen con los requisitos sintácticos y semánticos de .NET .- 2. El MSIL (Microsoft Intermediate Language). Representa el código objeto al que
es transformado el código fuente escrito en cualquiera de los lenguajes aceptados por .NET. Estos , que luego va a ser compilado a nativo por el compilador JIT (Just In Time) que provee la CLR en tiempo de ejecución.
3. La biblioteca de clases .NET Framework . Es una extensísima colección de clases base, para todos los propósitos imaginables, que es aceptada y usada por todos los lenguajes e IDEs que corren sobre .NET
4. El entorno de programación (IDE) . Es el ambiente de trabajo propiamente dicho que puede constar de herramientas de de diseño, editores, debugeadores y diversos asistentes, para que el programador pueda diseñar, escribir y probar sus aplicaciones. Existen varios (Sharp Develop, RAD Studio, etc.), pero nosotros en este curso y posteriores usaremos el propio de Microsoft : Visual Studio.
1.3. Que es C# (Sharp)
C# (se pronuncia “se sharp”), es un lenguaje que pretende reunir lo mejor de los diversos lenguajes que compilan a nativo(C/C++, Object Pascal, ADA, etc.), y de aquellos interpretados (Java, Perl, etc.) en uno solo, y que además, pueda correr sobre diversos sistemas operativos. Al respecto, existe un proyecto paralelo al desarrollo de .NET de Microsoft, que se denomina “Mono” que transportó el lenguaje C# y gran parte del framework .NET a Unix/Linus/Solaris.
C# toma gran parte de la sintaxis de C/C++, y muchas de las características de Eiffel (un lenguaje de laboratorio que ideó Bertrand Meyer), poniendo a disposición del desarrollador un potente lenguaje 100% orientado a objetos. Si bien el CLR, acepta muchos otros lenguajes, el framework .NET está 100% escrito en C# ; por lo tanto ES EL LENGUAJE BASE PARA .NET.
2.
Entorno de Desarrollo
2.1. Objetivos
2.1.1. Mapa del Curso
1. Introducción a .NET
2. Entorno de Desarrollo
3. Sintaxis y Semántica de C#
4. Arreglos
5. Introducción a la Programación Visual
6. Laboratorio
2.2. El compilador
Cuando se instala en cada computadora el SDK de Microsoft .NET, se crea el directorio c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\ , dentro del cual se alojan los compiladores de línea. En nuestro caso el compilador para C# es “csc.exe” que puede ser invocado desde la línea de comandos (Inicio|Ejecutar|cmd). Cuando se invoca al compilador pasándole como parámetro un nombre de archivo cualquiera con la extensión “.cs”, convierte a este en un archivo *.exe (ejecutable), pero este NO es un ejecutable NATIVO (es decir autónomo), sino que necesita del framework .NET con el CLR instalado en la misma maquina, para poder correr.
2.3. Los archivos fuentes (“*.cs”)
Los archivos de “código fuente” no son mas que archivos de texto plano, que contienen las líneas del programa en C#, con las instrucciones que cada programador quiere que la aplicación lleve a cabo. Deben cumplir con las normas sintácticas del lenguaje, caso contrario, el compilador detecta los errores y no genera el ejecutable.
/*
* Nombre de archivo : saludo.cs * Autor : Claudio Zwitkovits * /
// Clase de inicio del programa public class Hola
{
// “Main” indica la ejecucion del programa public static void Main()
{
// escribir en la consola
System.Console.WriteLine(“Hola a todos !!!”) ; }
}
Para compilar este programa, solo hay que ir a la línea de comandos y tipear :
csc saludo.cs y esto generará el ejecutable “saludo.exe” que mostrará en la consola el mensaje “Hola a todos !!!”
2.4. Como está formado el framework .NET
La arquitectura del framework .NET, es la implementación del CLI (Common Language Runtime) por parte de Microsoft para los lenguajes C#, Visual Basic, J#, ASP, y Jscript, mas varios paquetes que dan soporte a interfaces de usuario, acceso a datos , XML y WEB agrupadas en una Librería de Clase Base (BCL) que está formada por cientos de tipos de datos. Esta librería está escrita en MSIL, por lo que puede usarse desde cualquier lenguaje cuyo compilador genere MSIL. A través de las clases suministradas en ella es posible desarrollar cualquier tipo de aplicación, desde las tradicionales aplicaciones de ventanas, consola o servicio de Windows NT hasta los novedosos servicios Web y páginas ASP.NET..
Dada su amplitud ha sido necesario organizar las clases en ella incluida en espacios de
nombres que agrupen clases con funcionalidades similares. Por ejemplo, los espacios de
nombres más usados son:
Espacio de nombres
Utilidad de los tipos de datos que contiene
System Tipos muy frecuentemente usados, como los los tipos
básicos, tablas, excepciones, fechas, números aleatorios, recolector de basura, entrada/salida en consola, etc.
System.Collections Colecciones de datos de uso común como pilas, colas,
listas, diccionarios, etc.
System.Data Manipulación de bases de datos. Forman la denominada
arquitectura ADO.NET.
System.IO Manipulación de archivos y otros flujos de datos.
System.Net Realización de comunicaciones en red.
System.Reflection Acceso a los metadatos que acompañan a los módulos de
código.
System.Runtime.Remoting Acceso a objetos remotos.
System.Security Acceso a la política de seguridad en que se basa el CLR.
System.Threading Manipulación de hilos de ejecución.
System.Web.UI.WebControls Creación de interfaces de usuario basadas en ventanas
para aplicaciones Web.
System.Windows.Forms Creación de interfaces de usuario basadas en ventanas
para aplicaciones estándar.
3.
Sintaxis y Semántica de C#
3.1. Objetivos
3.1.1. Mapa del Curso
1. Introducción a .NET
2. Entorno de Desarrollo
3. Sintaxis y Semántica de C#
4. Arreglos
5. Introducción a la Programación Visual
6. Laboratorio
3.2. Variables y constantes
3.2.1. Que es una variable
Una variable reperesenta una posición en memoria en el que se puede almacenar un valor de un determinado tipo al que se le da un cierto nombre. Para poderla utilizar sólo hay que definirla indicando cual será su nombre y cual será el tipo de datos que podrá almacenar, lo que se hace siguiendo la siguiente sintaxis:
<tipoVariable> <nombreVariable>;
Una variable puede ser definida dentro de una definición de clase, en cuyo caso se la denominaría campo. También puede definirse como un variable local a un método, que es una variable definida dentro del código del método a la que sólo puede accederse desde dentro de dicho código. Otra posibilidad es definirla como parámetro de un método, que son variables que almacenan los valores de llamada al método y que, al igual que las variables locales, sólo puede ser accedidas desde código ubicado dentro del método. El siguiente ejemplo muestra como definir variables de todos estos casos:
Class GestorClientesApp{ public static void Main(){
string Nombre; // Declaración de la variable nombre, que es de tipo string
Console.Write("¿Cómo se llama el cliente? "); Nombre = Console.ReadLine();
En este sencillo programa, el compilador reservará memoria para la variable Nombre. En la ejecución del mismo primero preguntaría por el nombre del cliente y, después de haberlo escrito nosotros, nos diría cómo se llama. Algo así (“Mi cliente se llama Antonio” es lo que hemos escrito nosotros durante la ejecución del programa):
¿Cómo se llama el cliente? Antonio Mi cliente se llama Antonio
También podemos inicializar el valor de una variable en el momento de declararla, sin que esto suponga un obstáculo para poder modificarlo después:
int num=10;
3.2.2. Que es una constante
De otro lado tenemos las constantes también hacen que el compilador reserve un espacio de memoria para almacenar un dato, pero en este caso ese dato es siempre el mismo y no se puede modificar durante la ejecución del programa.Un ejemplo claro sería almacenar el valor de pi en una constante para no tener que poner el número en todas las partes donde lo podamos necesitar. Se declaran de un modo similar a las variables, basta con añadir la palabra const en la declaración.
using System;
namespace Circunferencia1{ class CircunferenciaApp{ public static void Main(){
const double PI=3.1415926; // Esto es una constante double Radio=4; // Esto es una variable
Console.WriteLine("El perímetro de una circunferencia de radio {0} es {1}", Radio,
2*PI*Radio);
Console.WriteLine("El área de un círculo de radio {0} es {1}", Radio, PI*Math.Pow(Radio,2));
} } }
La salida en la consola de este programa sería la siguente:
El perímetro de una circunferencia de radio 4 es 25,1327408 El área de un círculo de radio 4 es 50,2654816
3.3. Tipos de dato
3.3.1. Introducción
El sistema de tipos de datos suele ser la parte más importante de cualquier lenguaje de programación. El uso correcto de los distintos tipos de datos es algo fundamental para que una aplicación sea eficiente con el menor consumo posible de recursos. Actualmente, muchos de los lenguajes orientados a objetos proporcionan los tipos agrupándolos de dos formas: los tipos primitivos del lenguaje, como números o cadenas, y el resto de tipos creados a partir de clases. Esto genera muchas dificultades, ya que los tipos primitivos no son y no pueden tratarse como objetos, es decir, no se pueden derivar y no tienen nada que ver unos con otros. Sin embargo, en C# (más propiamente en .NET Framework) contamos con un sistema de tipos unificado, el CTS (Common Type System), que proporciona todos los tipos de datos como clases derivadas de la clase de base System.Object (incluso los literales pueden tratarse como objetos). Sin embargo, el hacer que todos los datos que ha de manejar un programa sean objetos puede provocar que baje el rendimiento de la aplicación. Para solventar este problema, .NET Framework divide los tipos en dos grandes grupos: los tipos valor y los tipos referencia.
Cuando se declarara variable que es de un tipo valor se está reservando un espacio de memoria en la pila (stack) para que almacene los datos reales que contiene esta variable. Por ejemplo en la declaración:
int num =10;
Se está reservando un espacio de 32 bits en la pila (una variable de tipo int es un objeto de la clase System.Int32), en los que se almacena el 10, que es lo que vale la variable. Esto hace que la variable “num” se pueda tratar directamente como si fuera de un tipo primitivo en lugar de un objeto, mejorando notablemente el rendimento. Como consecuencia, una variable de tipo valor nunca puede contener null (referencia nula). Durante la ejecución de un programa, la memoria se distribuye en tres bloques: la pila, (stack), el montón (heap) y la memoria global. La pila es una estructura en la que los elementos se van apilando, de modo que el último elemento en entrar en la pila es el primero en salir (estructura LIFO, o sea, Last In First Out). El montón es un bloque de
memoria contiguo en el cual la memoria no se reserva en un orden determinado como en la pila, sino que se va reservando aleatoriamente según se va necesitando. Cuando el programa requiere un bloque del montón, este se sustrae y se retorna un puntero (varaible que contiene direcciones de memoria) al principio del mismo. La memoria global es el resto de memoria de la máquina que no está asignada ni a la pila ni al montón, y es donde se colocan el método main y las funciones que éste invocará. En el caso de una variable que sea de un tipo referencia, lo que se reserva es un espacio de memoria en el montón para almacenar el valor, pero lo que se devuelve internamente es una referencia al objeto, es decir, un puntero a la dirección de memoria que se ha reservado. En este caso, una variable de un tipo referencia sí puede contener una referncia nula (null).
¿Porqué esta “separación” de tipos y posiciones de memoria?, porque una variable de un tipo valor funcionará como un tipo primitivo siempre que sea necesario, pero podrá funcionar también como un tipo referencia, es decir como un objeto, cuando se necesite que sea un objeto. Hacer esto en otros lenguajes, como Java, es imposible, dado que los tipos primitivos en Java no son objetos. Mas adelante ampliaremos estos conceptos.
Los tipos de datos básicos son ciertos tipos de datos tan comúnmente utilizados en la escritura de aplicaciones que en C# se ha incluido una sintaxis especial para tratarlos. Por ejemplo, para representar números enteros de 32 bits con signo se utiliza el tipo de dato System.Int32 definido en la BCL, aunque a la hora de crear un objeto a de este tipo que represente el valor 2 se usa la siguiente sintaxis:
System.Int32 a = 2;
Dado lo frecuente que es el uso de este tipo también se ha predefinido en C# el alias int para el mismo, por lo que la definición de variable anterior queda así de compacta:
int a = 2;
System.Int32 no es el único tipo de dato básico incluido en C#. En el espacio de nombres System se han incluido todos estos:
Tipo Descripción Bits Rango de valores Alias
SByte Bytes con signo 8 [-128, 127] Sbyte Byte Bytes sin signo 8 [0, 255] byte
Int64 Enteros largos 64 [-9.223.372.036.854.775.808,
9.223.372.036.854.775.807] Long UInt64 Enteros largos sin signo 64
[0-18.446.744.073.709.551.615] Ulong Single Reales con 7 dígitos de precisión 32 [1,5×10-45 - 3,4×1038] Float
Double Reales de 15-16 dígitos de precisión 64 [5,0×10-324 - 1,7×10308] double
Decimal Reales de 28-29 dígitos de precisión 128 [1,0×10-28 - 7,9×1028] decimal
Boolean Valores lógicos 32 true, false Bool Char Caracteres Unicode 16 [‘\u0000’, ‘\uFFFF’] Char String Cadenas de caracteres Variable El permitido por la memoria String Object Cualquier objeto Variable Cualquier objeto Object
3.3.2. Tipos de datos básicos
Pese a su sintaxis especial, en C# los tipos básicos son tipos del mismo nivel que cualquier otro tipo del lenguaje. Es decir, heredan de System.Object y pueden ser tratados como objetos de dicha clase por cualquier método que espere un System.Object, lo que es muy útil para el diseño de rutinas genéricas que admitan parámetros de cualquier tipo y es una ventaja importante de C# frente a lenguajes similares como Java donde los tipos básicos no son considerados objetos.
El valor que por defecto se le da a los campos de tipos básicos consiste en poner a cero todo el área de memoria que ocupen. Esto se traduce en que los campos de tipos básicos numéricos se inicializan por defecto con el valor 0, los de tipo bool lo hacen con false, los de tipo char con ‘\u0000’ (carácter nulo), y los de tipo string y object con null. Para los casos de los tipos de variables numéricas se puede especificar (durante la asignación de un valor), el tipo de dato numérico de ese valor mediante el uso de
sufijos
Los sufijos para los valores literales de los distintos tipos de datos numéricos son los siguientes:
• L (mayúscula o minúscula): long ó ulong, por este orden;
• U (mayúscula o minúscula): int ó uint, por este orden;
• UL ó LU (independientemente de que esté en mayúsuculas o minúsculas):
ulong;
• F (mayúscula o minúscula): single;
• D (mayúscula o minúscula): double;
3.4. Construcciones del lenguaje
3.4.1. Introduccion
Cuando se desarrolla un programa, luego de declarar las variables, constantes, clases, etc., se debe especificar que hacer con/entre estos elementos, para ello iremos escribiendo : líneas (para C# cada línea de código termina con un “;” – punto y coma).
3.4.2. Sentencias
Una sentencia es una orden que se le da al programa para realizar una tarea específica, esta puede ser: mostrar un mensaje en la pantalla, declarar una variable (para reservar espacio en memoria), inicializarla, llamar a un método, etc. Para C# cada sentencia termina con un “;” (punto y coma) . Normalmente, las sentencias se ponen unas debajo de otras, aunque sentencias cortas pueden colocarse en una misma línea. He aquí algunos ejemplos de sentencias :
int x=10; usingSystem.IO;
Console.WriteLine("Hola Mundo");
En C#, los caracteres espacio en blanco se pueden emplear libremente.Es muy importante para la legibilidad de un programa la colocación de unas líneas debajo de otras empleando tabuladores. El editor del IDE nos ayudará plenamente en esta tarea sin apenas percibirlo
3.4.3. Bloques de código
Un bloque de código es un grupo de sentencias que se comportan como una unidad. Se los usa para indicar el comienzo y fin de un conjunto de líneas (sentancias) de código. Por lo general, se los usa para delimitar namespaces, clases, estructuras, enumerados y
métodos. Un bloque de código está limitado por las llaves de apertura “{“ y cierre “}”. He aquí un ejemplo de uso :
Static void main() {
Linea1;
Linea2;
}
Cada una de esas líneas, implica una expresión que el compilador de C# analizará, verificando que su sintaxis sea la correcta. Para ello disponemos de los operadores.
3.5. Operadores
3.5.1. Que es un operador
Un operador en C# es un símbolo formado por uno o más caracteres que permite realizar una determinada operación entre uno o más datos y produce un resultado. A continuación se describen cuáles son los operadores incluidos en el lenguaje clasificados según el tipo de operaciones que permiten realizar, aunque hay que tener en cuenta que C# permite la redefinición del significado de la mayoría de los operadores según el tipo de dato sobre el que se apliquen, por lo que lo que aquí se cuenta se corresponde con los usos más comunes de los mismos:
• Un operador es una expresión que produce otro valor (así como las funciones o construcciones que devuelven un valor).
• Existen operadores de comparación, de negación o de incremento y decremento.
• Las operaciones matemáticas se comportan de igual manera en PHP. Las operaciones * y / tienen precedencia sobre la suma y la resta y se pueden utilizar paréntesis para expresiones mas complejas.
• Un operador es un símbolo especial que indica al compilador que debe efectuar una operación matemática o lógica.
• En todo lenguaje de programación existen un conjunto de operadores que permiten realizar operaciones con los datos. Nos referimos a operaciones aritméticas, comparaciones, operaciones lógicas y otras operaciones (por ejemplo, concatenación de cadenas, operaciones algebraicas entre valores números, etc.).
3.5.2. Que es un Operador?
• Un operador es un símbolo especial que indica al compilador que debe efectuar una operación matemática o lógica.
• En todo lenguaje de programación existen un conjunto de operadores que permiten realizar operaciones con los datos. Nos referimos a operaciones aritméticas, comparaciones, operaciones lógicas y otras operaciones (por ejemplo, concatenación de cadenas, operaciones algebraicas entre valores números, etc.).
3.5.3. Operaciones aritméticas
Los operadores aritméticos incluidos en C# son los típicos de suma (+), resta (-), producto (*(-), división (/) y módulo (%) También se incluyen operadores de “menos unario” (–) y “más unario” (+).
3.5.4. Operaciones lógicas
Se incluyen operadores que permiten realizar las operaciones lógicas típicas: “and” (&& y &), “or” (|| y |), “not” (!) y “xor” (^)
Los operadores && y || se diferencia de & y | en que los primeros realizan evaluación perezosa y los segundos no. La evaluación perezosa consiste en que si el resultado de evaluar el primer operando permite deducir el resultado de la operación, entonces no se evalúa el segundo y se devuelve dicho resultado directamente, mientras que la evaluación no perezosa consiste en evaluar siempre ambos operandos. Es decir, si el primer operando de una operación && es falso se devuelve false directamente, sin evaluar el segundo; y si el primer operando de una || es cierto se devuelve true directamente, sin evaluar el otro.
3.5.5. Operaciones relacionales
Se han incluido los tradicionales operadores de igualdad (==), desigualdad (!=), “mayor que” (>), “menor que” (<), “mayor o igual que” (>=) y “menor o igual que” (<=)
3.5.6. Operaciones de asignación
Para realizar asignaciones se usa en C# el operador =, operador que además de realizar la asignación que se le solicita devuelve el valor asignado. Por ejemplo, la expresión a = b asigna a la variable a el valor de la variable b y devuelve dicho valor, mientras que la expresión c = a = b asigna a las variables c y a el valor de b (el operador = es asociativo por la derecha)
También se han incluido operadores de asignación compuestos que permiten ahorrar tecleo a la hora de realizar asignaciones tan comunes como:
temperatura = temperatura + 15; // Sin usar asignación compuesta temperatura += 15; // Usando asignación compuesta
Las dos líneas anteriores son equivalentes, pues el operador compuesto +=
asigna a su primer operando el valor que tenía más el de su segundo
operando (o sea, le suma el segundo operando) Como se ve, permite compactar bastante el código.
Aparte del operador de asignación compuesto +=, también se ofrecen operadores de asignación compuestos para la mayoría de los operadores binarios ya vistos. Estos son: +=, -=, *=, /=, %=, &=, |=, ^=, <<= y >>=. Nótese que no hay versiones compuestas para los operadores binarios && y ||.
Otros dos operadores de asignación incluidos son los de incremento(++) y decremento (--) Estos operadores permiten, respectivamente, aumentar y disminuir en una unidad el valor de la variable sobre el que se aplican. Así, estas líneas de código son equivalentes:
temperatura = temperatura + 1; //Sin asignación compuesta ni incremento temperatura += 1; //Usando asignación compuesta
temperatura++; //Usando incremento
Si el operador ++ se coloca tras el nombre de la variable (como en el ejemplo) devuelve el valor de la variable antes de incrementarla, mientras que si se coloca antes, devuelve el valor de ésta tras incrementarla; y lo mismo ocurre con el operador --. Por ejemplo:
c = b++; // Se asigna a c el valor de b y luego se incrementa b c = ++b; // Se incrementa el valor de b y luego se asigna a c
La ventaja de usar los operadores ++ y -- es que en muchas máquinas son más eficientes que el resto de formas de realizar sumas o restas de una unidad, pues el compilador puede traducirlos en una única instrucción en código máquina1.
3.5.7. Operaciones con cadenas
Para realizar operaciones de concatenación de cadenas se puede usar el mismo operador que para realizar sumas, ya que en C# se ha redefinido su significado para que cuando se aplique entre operandos que sean cadenas o que sean una cadena y un carácter lo que haga sea concatenarlos. Por ejemplo, ″Hola″+″ mundo″ devuelve ″Hola mundo″, y ″Hola mund″ + ′o′ también.
3.5.8. Operador condicional
Es el único operador incluido en C# que toma 3 operandos, y se usa así:
<condición> ? <expresión1> : <expresión2>
El significado del operando es el siguiente: se evalúa <condición> Si es cierta se devuelve el resultado de evaluar <expresión1>, y si es falsa se devuelve el resultado de evaluar <condición2>. Un ejemplo de su uso es:
En este ejemplo, si el valor de la variable a es superior a 0 se asignará a b el valor de a, mientras que en caso contrario el valor que se le asignará será 0. Hay que tener en cuenta que este operador es asociativo por la derecha, por lo que una expresión como a?b:c?d:e es equivalente a a?b:(c?d:e)
No hay que confundir este operador con la instrucción condicional if que se tratará en el Tema 8:Instrucciones, pues aunque su utilidad es similar al de ésta, ? devuelve un valor e if no.
3.6. Instrucciones de control de flujo
3.6.1. Introduccion
Hemos visto hasta ahora que los programas van ejecutando las líneas de código con orden. Sin embargo, hay muchas situaciones en las que es preciso alterar ese orden, o bien puede ocurrir que sea necesario que se efectúen una serie de operaciones que pueden ser distintas en otras circunstancias. Por ejemplo, si el programa pide una clave de acceso, deberá continuar con la ejecución normal en caso de que la clave introducida por el usuario sea correcta, y deberá salir del mismo en caso contrario. Pues bien: para todas estas cuestiones que, por otra parte, son muy frecuentes, tenemos las Instrucciones de control de flujo.
En C# contamos con varios tipos de estas instrucciones :
• Las instrucciones condicionales (if…else, switch) son instrucciones que
permiten ejecutar bloques de instrucciones sólo si se da una determinada condición.
• Las instrucciones iterativas (while, do, for, foreach) son instrucciones que
permiten ejecutar repetidas veces una instrucción o un bloque de instrucciones mientras se cumpla una condición. Es decir, permiten definir bucles donde ciertas instrucciones se ejecuten varias veces.
• Las instrucciones de salto (break, continue, return, goto) permiten variar el
orden normal en que se ejecutan las instrucciones de un programa, que consiste en ejecutarlas una tras otra en el mismo orden en que se hubiesen escrito en el fuente.
3.6.2. Instrucción if...else
La instrucción if permite ejecutar ciertas instrucciones sólo si de da una determinada condición. Su sintaxis de uso es la sintaxis:
if (<condición>) { <instruccionesIf> } Else { <instruccionesElse> }
El significado de esta instrucción es el siguiente: se evalúa la expresión <condición>, que ha de devolver un valor lógico. Si es cierta (devuelve true) se ejecutan las <instruccionesIf>, y si es falsa (false) se ejecutan las <instruccionesElse> La rama else es opcional, y si se omite y la condición es falsa se seguiría ejecutando a partir de la instrucción siguiente al if. En realidad, tanto <instruccionesIf> como <instruccionesElse> pueden ser una única instrucción o un bloque de instrucciones.
using System; class HolaMundoIf {
public static void Main(String[] args) { if (args.Length > 0) { Console.WriteLine(“Hola {0}!”, args[0]) ; } Else { Console.WriteLine(“Hola mundo!”); } } }
Si ejecutamos este programa sin ningún argumento veremos que el mensaje que se muestra es ¡Hola Mundo!, mientras que si lo ejecutamos con algún argumento se mostrará un mensaje de bienvenida personalizado con el primer argumento indicado.
3.6.3. Instrucción switch
La instrucción switch permite ejecutar unos u otros bloques de instrucciones según el valor de una cierta expresión. Su estructura es:
switch (<expresión>) {
case valor1: Sentencias1; <siguiente accion>; case valor2: Sentencias2; <siguiente accion>; case valor3: Sentencias3; <siguiente accion>; default: Sentencias4;
El significado de esta instrucción es el siguiente: se evalúa <expresión>. Si su valor es <valor1> se ejecuta el <bloque1>, si es <valor2> se ejecuta <bloque2>, y así para el resto de valores especificados. Si no es igual a ninguno de esos valores y se incluye la rama default, se ejecuta el <bloqueDefault>; pero si no se incluye se pasa directamente a ejecutar la instrucción siguiente al switch.
Los valores indicados en cada rama del switch han de ser expresiones constantes que produzcan valores de algún tipo básico entero, de una enumeración, de tipo char o de tipo string. Además, no puede haber más de una rama con el mismo valor.
En realidad, aunque todas las ramas de un switch son opcionales siempre se ha de incluir al menos una. Además, la rama default no tiene porqué aparecer la última si se usa, aunque es recomendable que lo haga para facilitar la legibilidad del código.
El elemento marcado como <siguienteAcción> colocado tras cada bloque de instrucciones indica qué es lo que ha de hacerse tras ejecutar las instrucciones del bloque que lo preceden. Puede ser uno de estos tres tipos de instrucciones:
goto case <valori>; goto default; break;
Si es un goto case indica que se ha de seguir ejecutando el bloque de instrucciones asociado en el switch a la rama del <valori> indicado, si es un goto default indica que se ha de seguir ejecutando el bloque de instrucciones de la rama default, y si es un break indica que se ha de seguir ejecutando la instrucción siguiente al switch.
El siguiente ejemplo muestra cómo se utiliza switch:
using System;
{
public static void Main(String[] args) {
if (args.Length > 0) switch(args[0]) {
case “José”: Console.WriteLine(“Hola José. Buenos días”); break; case “Paco”: Console.WriteLine(“Hola Paco. Me alegro de verte”); break;
default: Console.WriteLine(“Hola {0}”, args[0]); break; }
else
Console.WriteLine(“Hola Mundo”); }
}
Este programa reconoce ciertos nombres de personas que se le pueden pasar como argumentos al lanzarlo y les saluda de forma especial. La rama default se incluye para dar un saludo por defecto a las personas no reconocidas.
3.6.4. Instrucción while
La instrucción while permite ejecutar un bloque de instrucciones mientras se de una cierta instrucción. Su sintaxis de uso es:
while (<condición>) {
<instrucciones>
Su significado es el siguiente: Se evalúa la <condición> indicada, que ha de producir un valor lógico. Si es cierta (valor lógico true) se ejecutan las <instrucciones> (sentencia) y se repite el proceso de evaluación de <condición> y ejecución de <instrucciones> hasta que deje de serlo. Cuando sea falsa (false) se pasará a ejecutar la instrucción siguiente al while. En realidad <instrucciones> puede ser una única sentencia o un bloque de sentencias.
Un ejemplo cómo utilizar esta instrucción es el siguiente:
using System;
class HolaMundoWhile {
public static void Main(String[] args) {
int actual = 0; if (args.Length > 0)
while (actual < args.Length) { Console.WriteLine(“¡Hola {0}!”, args[actual]); actual = actual + 1; } else Console.WriteLine(“¡Hola mundo!”); } }
En este caso, si se indica más de un argumento al llamar al programa se mostrará por pantalla un mensaje de saludo para cada uno de ellos. Para ello se usa una variable
while. Para mantenerla siempre actualizada lo que se hace es aumentar en una unidad su valor tras cada ejecución de las <instrucciones> del bucle.
Por otro lado, dentro de las <instrucciones> de un while pueden utilizarse las siguientes dos instrucciones especiales:
• break;: Indica que se ha de abortar la ejecución del bucle y continuarse
ejecutando por la instrucción siguiente al while.
• continue;: Indica que se ha de abortar la ejecución de las <instrucciones> y
reevaluarse la <condición> del bucle, volviéndose a ejecutar las <instrucciones> si es cierta o pasándose a ejecutar la instrucción siguiente al while si es falsa.
3.6.5. Instrucción do...while
La instrucción do...while es una variante del while que se usa así:
Do {
<instrucciones>
} while(<condición>);
do ... while está especialmente destinado para los casos en los que haya que ejecutar las <instrucciones> al menos una vez aún cuando la condición sea falsa desde el principio, como ocurre en el siguiente ejemplo:
using System;
class HolaMundoDoWhile {
public static void Main() {
String leído; Do {
Console.WriteLine(“Clave: “); leído = Console.ReadLine();
} while (leído != “José”);
Console.WriteLine(“Hola José”); }
}
Este programa pregunta al usuario una clave y mientras no introduzca la correcta (José) no continuará ejecutándose. Una vez que introducida correctamente dará un mensaje de bienvenida al usuario.
3.6.6. Instrucción for
La instrucción for realiza un bucle determinado número de veces. Consta de tres partes La sentencia inicialización se ejecuta al comienzo del ciclo
La condición que se evalúa al entrar al buclé y luego al comienzo de cada iteración. La modificación se ejecuta al final de cada iteración, y previene que no se entre un bucle infinito (se ejecuta al final de cada iteración).
escribir los tipos de bucles más comúnmente usados en programación. Su sintaxis es:
for (<inicialización>; <condición>; <modificación>) {
<instrucciones>
El significado de esta instrucción es el siguiente: se ejecutan las instrucciones de <inicialización>, que suelen usarse para definir e inicializar variables que luego se usarán en <instrucciones> (sentencias). Luego se evalúa <condición>, y si es falsa se continúa ejecutando por la instrucción siguiente al for; mientras que si es cierta se ejecutan las <instrucciones> indicadas, luego se ejecutan las instrucciones de <modificación> -que como su nombre indica suelen usarse para modificar los valores de variables que se usen en <instrucciones>- y luego se reevalúa <condición> repitiéndose el proceso hasta que ésta última deje de ser cierta.
En <inicialización> puede en realidad incluirse cualquier número de instrucciones que no tienen porqué ser relativas a inicializar variables o modificarlas, aunque lo anterior sea su uso más habitual. En caso de ser varias se han de separar mediante comas (,), ya que el carácter de punto y coma (;) habitualmente usado para estos menesteres se usa en el for para separar los bloques de <inicialización>, <condición> y <modificación> Además, la instrucción nula no se puede usar en este caso y tampoco pueden combinarse definiciones de variables con instrucciones de otros tipos.
Con <modificación> pasa algo similar, ya que puede incluirse código que nada tenga que ver con modificaciones pero en este caso no se pueden incluir definiciones de variables. Como en el resto de instrucciones hasta ahora vistas, en <instrucciones> puede ser tanto una única instrucción como un bloque de instrucciones. Además, las variables que se definan en <inicialización> serán visibles sólo dentro de esas <instrucciones>.
La siguiente clase es equivalente a la clase HolaMundoWhile ya vista solo que hace uso del for para compactar más su código:
using System;
class HolaMundoFor {
public static void Main(String[] args) {
if (args.Length > 0)
for (int actual = 0; actual < args.Length; actual++) Console.WriteLine(“¡Hola {0}!”, args[actual]); else
Console.WriteLine(“¡Hola mundo!”); }
}
Al igual que con while, dentro de las <instrucciones> del for también pueden incluirse instrucciones continue; y break; que puedan alterar el funcionamiento normal del bucle.
3.6.7. Instrucción break
Ya se ha visto que la instrucción break sólo puede incluirse dentro de bloques de instrucciones asociados a instrucciones iterativas o instrucciones switch e indica que se desea abortar la ejecución de las mismas y seguir ejecutando a partir de la instrucción siguiente a ellas. Se usa así:
break;
Cuando esta sentencia se usa dentro de un try con cláusula finally, antes de abortarse la ejecución de la instrucción iterativa o del switch que la contiene y seguirse ejecutando por la instrucción que le siga, se ejecutarán las instrucciones de la cláusula finally del try. Esto se hace para asegurar que el bloque finally se ejecute aún en caso de salto.
Además, si dentro una cláusula finally incluida en de un switch o de una instrucción iterativa se usa break, no se permite que como resultado del break se salga del finally.
3.6.8. Instrucción continue
Ya se ha visto que la instrucción continue sólo puede usarse dentro del bloque de instrucciones de una instrucción iterativa e indica que se desea pasar a reevaluar
directamente la condición de la misma sin ejecutar el resto de instrucciones que contuviese. La evaluación de la condición se haría de la forma habitual: si es cierta se repite el bucle y si es falsa se continúa ejecutando por la instrucción que le sigue. Su sintaxis de uso es así de sencilla:
continue;
En cuanto a sus usos dentro de sentencias try, tiene las mismas restricciones que break: antes de salir de un try se ejecutará siempre su bloque finally y no es posible salir de un finally incluido dentro de una instrucción iterativa como consecuencia de un continue.
3.6.9. Instrucción return
Esta instrucción se usa para indicar cuál es el objeto que ha de devolver un método. Su sintaxis es la siguiente:
return <objetoRetorno>;
La ejecución de esta instrucción provoca que se aborte la ejecución del método dentro del que aparece y que se devuelva el <objetoRetorno> al método que lo llamó. Como es lógico, este objeto ha de ser del tipo de retorno del método en que aparece el return o de alguno compatible con él, por lo que esta instrucción sólo podrá incluirse en métodos cuyo tipo de retorno no sea void, o en los bloques get de las propiedades o indizadores. De hecho, es obligatorio que todo método con tipo de retorno termine por un return. Los métodos que devuelvan void pueden tener un return con una sintaxis espacial en la que no se indica ningún valor a devolver sino que simplemente se usa return para indicar que se desea terminar la ejecución del método:
return;
Nuevamente, como con el resto de instrucciones de salto hasta ahora vistas, si se incluyese un return dentro de un bloque try con cláusula finally, antes de devolverse el objeto especificado se ejecutarían las instrucciones de la cláusula finally. Si hubiesen varios bloques finally anidados, las instrucciones de cada uno es ejecutarían de manera ordenada (o sea, del más interno al más externo) Ahora bien, lo que no es posible es
3.6.10. Instrucción goto
La instrucción goto permite pasar a ejecutar el código a partir de una instrucción cuya etiqueta se indica en el goto. La sintaxis de uso de esta instrucción es:
goto <etiqueta>;
Como en la mayoría de los lenguajes, goto es una instrucción maldita cuyo uso no se recomienda porque dificulta innecesariamente la legibilidad del código y suele ser fácil simularla usando instrucciones iterativas y selectivas con las condiciones apropiadas. Sin embargo, en C# se incluye porque puede ser eficiente usarla si se anidan muchas instrucciones y para reducir sus efectos negativos se le han impuesto unas restricciones:
• Sólo se pueden etiquetar instrucciones, y no directivas preprocesado, directivas
using o definiciones de miembros, tipos o espacios de nombres.
• La etiqueta indicada no pueda pertenecer a un bloque de instrucciones anidado
dentro del bloque desde el que se usa el goto ni que etiquete a instrucciones de otro método diferente a aquél en el cual se encuentra el goto que la referencia. Para etiquetar una instrucción de modo que pueda ser destino de un salto con goto basta precederla del nombre con el que se la quiera etiquetar seguido de dos puntos (:) Por ejemplo, el siguiente código demuestra cómo usar goto y definir una etiqueta:
using System; class HolaMundoGoto {
public static void Main(string[] args) {
for (int i=0; i<args.Length; i++) { if (args[i] != “salir”) Console.WriteLine(args[i]); else goto fin: } fin: ;
} }
Este programa de ejemplo lo que hace es mostrar por pantalla todos los argumentos que se le pasen como parámetros, aunque si alguno de fuese salir entonces se dejaría de mostrar argumentos y se aborta la ejecución de la aplicación. Véase además que este ejemplo pone de manifiesto una de las utilidades de la instrucción nula, ya que si no se hubiese escrito tras la etiqueta fin el programa no compilaría en tanto que toda etiqueta ha de preceder a alguna instrucción (aunque sea la instrucción nula)
Nótese que al fin y al cabo los usos de goto dentro de instrucciones switch que se vieron al estudiar dicha instrucción no son más que variantes del uso general de goto, ya que
default: no es más que una etiqueta y case <valor>: puede verse como una etiqueta un
tanto especial cuyo nombre es case seguido de espacios en blanco y un valor. En ambos casos, la etiqueta indicada ha de pertenecer al mismo switch que el goto usado y no vale que éste no la contenga pero la contenga algún switch que contenga al switch del goto.
3.7. Comentarios
3.7.1. Que es un comentario
Un comentario es texto que se incluye en el código fuente para facilitar su lectura a los programadores y cuyo contenido es, por defecto, completamente ignorado por el compilador. En C# hay dos formas de escribir comentarios. La primera consiste en encerrar todo el texto que se desee comentar entre caracteres /* y */ siguiendo la siguiente sintaxis: /*<texto>*/
3.7.2. Utilización de comentarios
Estos comentarios pueden abarcar tantas líneas como sea necesario. Por ejemplo:
/*
Esto es un comentario
que ejemplifica cómo se escribe comentarios de varias líneas */
No es posible anidar comentarios de este tipo. Es decir, no vale escribir comentarios como el siguiente:
/* Comentario contenedor /* Comentario contenido */ */
Dado que muchas veces los comentarios que se escriben son muy cortos y no suelen ocupar más de una línea, C# ofrece una sintaxis alternativa más compacta para la escritura este tipo de comentarios en las que se considera como indicador del comienzo del comentario la pareja de caracteres // y como indicador de su final el fin de línea. Por tanto, la sintaxis que siguen estos comentarios es: // <texto>
Y un ejemplo de su uso es:
// Este es un comentario de una sola línea
Estos comentarios de una sola línea sí que pueden anidarse sin ningún problema. Por ejemplo, el siguiente comentario es perfectamente válido:
4.
Arreglos
4.1. Objetivos
4.1.1. Mapa del Curso
1. Introducción a .NET
2. Entorno de Desarrollo
3. Sintaxis y Semántica de C#
4. Arreglos
5. Introducción a la Programación Visual
6. Laboratorio
4.1.2. Descripción
En este capitulo usted verá:• Una introducción a los vectores
• Creación de los vectores
• Usos de los vectores
4.1.3. Metas
Al final de este capitulo usted será capaz de:
• Dominar los conceptos de vectores
4.2. Introduccion
Hasta ahora hemos aprendido un montón de cosas con respecto a las variables, pero siempre teníamos que saber con antelación el número de variables que el programa iba a necesitar. Sin embargo, habrá situaciones en las que no sea posible determinar este número hasta que el programa no se esté ejecutando. Pues bien, para solucionar estas dificultades contamos con los arrays.
4.3. Arreglos de una dimension
Un array es una variable que puede almacenar varios valores simultáneamente. Cada uno de estos valores se identifica mediante un número al cual se llama índice. Así, para acceder al primer elemento del array habría que usar el índice cero, para el segundo el índice uno, para el tercero el índice dos, y así sucesivamente. Se lo decalra de la siguiente forma :
tipo[] variable;
Es muy parecido a como se declara una variable normal, sólo que hay que poner corchetes detrás del tipo. En C# los arrays son objetos derivados de la clase System.Array. Por lo tanto, y esto es muy importante, cuando declaramos un array en C# este aún no se habrá creado, en consecuencia, antes de poder usarlos habrá que instanciarlos, como si fuera cualquier otro objeto. Veamos un breve ejemplo :
string[] nombres; // Declaración del array
nombres = new string[3]; // Instanciación del array
En efecto, el array nombres será utilizable únicamente a partir de su instanciación, y podrá tener un maximo de tres elementos (0, 1 y 2). Notesé que indice del array comienza de CERO (0) y NO de uno (1), por lo cual el índice del último elemento es siempre el TotalElementos menos uno (3-1=2)
4.4. Operaciones de acceso a arreglos
Una array es un conjunto de ordenado de objetos de tamaño fijo. Para acceder a cualquier elemento de este conjunto se aplica el operador postfijo [] sobre la tabla para indicar entre corchetes la posición que ocupa el objeto al que se desea acceder dentro del conjunto. Es decir, este operador se usa así:
[<posiciónElemento>]
Un ejemplo de su uso en el que se asigna al elemento que ocupa la posición 3 en una tabla de nombre tablaPrueba el valor del elemento que ocupa la posición 18 de dicha tabla es el siguiente:
5.
Introducción a la Programación visual
5.1. Objetivos
5.1.1. Mapa del Curso
1. Introducción a .NET
2. Entorno de Desarrollo
3. Sintaxis y Semántica de C#
4. Arreglos
5. Introducción a la Programación Visual
6. Laboratorio
5.2. Que es la programación visual
Hasta ahora, todos los ejemplos que hemos visto y hecho, fueron aplicaciones de “consola”, es decir, el usuario interactúa con una interfaz de pantalla plana de caracteres, que no tiene ningún contenido gráfico. Ademas, el tipo de programación que se aplica a estas interfaces es imperativa, puesto que es el programador quien le impone las opciones al usuario final.
Pero desde el advenimiento de las computadoreas “Apple” (Macintoch), con su interface gráfica, y luego pasando por los sucesivos Windows (3, 95, 98, 2000, XP, Vista) , la interfaz gráfica de usuario (GUI) pasó a ser el standard en el 90 % de las computadoras. Este tipo de interface, permite interactuar al usuario con un programa de una forma visual, y ademas, el usuario final es quien decide que hacer con una determinada aplicación o cualesquiera otra que tenga disponible. Por ello, en este tipo de interfaces, la programación es por eventos, es decir el programador escribe el código para cada evento que produzca el usuario final.
5.3. Los Windows Forms
La plataforma .NET cuenta con una librería para interfaces gráficas: WinForms. Esta librería provee un conjunto de componentes para “armar” formularios visuales.
El componente principal, es el “form” que cuenta con un encabezado, en donde están los botones de cerrar, maximizar y minimizar; un borde que permite mover y cambiar de tamaño el formulario; y un cuerpo (canvas) sobre el cual se van colocando los componentes que conformarán la inteface visual propiamente dicha.
5.4. Componentes
El IDE del Visual C# 2008 posee un “Cuadro de herramientas” (ToolBox), que contiene una vasta colección de componentes y/o controles (visuales y no visuales), agrupados por categorías.
La forma de trabajo habitual, es elegir uno o mas componentes de esta paleta e ir arrastrando y soltando el/los controles sobre el formulario; luego cada uno de estos tiene sus propiedades y eventos.
Los controles son lo esencial cuando se programa con ventanas ya que sin estos lo único que podremos hacer será mostrar una ventana vacía y no tendríamos posibilidad de permitirle al usuario una interacción con la solución.
Los controles que utilizaremos en este curso son:
Botón: Levanta un evento cuando el usuario clickea el botón.
Etiqueta: Provee información en tiempo de ejecución o texto descriptivo para un control.
Caja de texto: Permite al usuario que escriba texto y provee edición multi-línea y enmascara las palabras claves.
Todos estos y los demás controles (clases) tienen Propiedades, Metodos y Eventos.
5.5. Propiedades
Las propiedades son el equivalente a variables que tienen los controles para poder fijar sus características como tamaño, posición, color, fuente, etc. Estas propiedades se pueden ver a través del “Inspector de propiedades” que contiene el IDE.
5.6. Eventos
Los eventos, son rutinas (procedimientos o funciones) que contienen los controles, para cada uno de los posibles sucesos (hacer click en un botón, mover el Mouse, pulsar una tecla, escribir un texto, etc.) que produzca el usuario.
El programador escribe en el cuerpo de la rutina la acción que va a llevar a cabo en caso que se produzca ese evento (suceso). Por ejempplo, cuando el usuario cliquea sobre un boton “cerrar”, el programador escribirá un “Form1.Close()” (cierre del formulario activo), haciendo que el formulario desaparezca de pantalla. Los eventos, también se encuentran en el “Inspector de propiedades” del IDE.
6.
Laboratorios
6.1. Objetivos
6.1.1. Mapa del Curso
1. Introducción a .NET
2. Entorno de Desarrollo
3. Sintaxis y Semántica de C#
4. Arreglos
5. Introducción a la Programación Visual
6. Laboratorio
6.2. Recomendaciones
• Para realizar los laboratorios se recomienda:
• Armar un archivo nuevo por cada ejercicio
• Tener el código fuente explicado en clase a mano para poder hacer referencia si
fuese necesario
• Tener los ejercicios ya realizados a mano para poder tomarlos como base si
fuese necesario
6.3. Lab 1 - Utilización de la estructura de control IF
6.3.1. Ejercicio 1
Dado el siguiente código:
Integer nro1 = 100, nro2 = 500, nro3 = 250; Informar cual de los tres números es mayor
Requisito: se necesita tener conocimiento del operador de comparación = y la utilización de if anidados
6.3.2. Ejercicio 2
Dado el siguiente código:
Integer a = 10, b=-2, c=5; // hay 2 nros positivos y 1 negativo Informar la multiplicación de los dos números positivos
6.3.3. Ejercicio 3
Dado el siguiente código: String usuario = “Pepito”; String clave = “educacionIT”; Informar los siguientes casos:• si usuario=“pepito” y clave =”educacionIT” informar “Bienvenio pepito!”
• si usuario=”pepito” y clave no es “educacionIT” informar “El usuario no
coincide con la contraseña”
• si usuario no es “pepito” informar “El usuario no existe!”
Requisito: se necesita tener conocimiento de como armar una variable de tipo String
6.4. Lab 2 - Utilización de la estructura de control
WHILE
6.4.1. Ejercicio 1
Imprimir los números del 1 al 10 uno abajo del otro
6.4.2. Ejercicio 2
Imprimir los números del 1 al 10 salteando de a 2 uno abajo del otro
6.4.3. Ejercicio 3
Imprimir los números del 10 al 1 uno abajo del otro
6.4.4. Ejercicio 4
Imprimir los números del 1 al 10 sin imprimir números 2,5 y 9 uno abajo del otro Requisito: se necesita tener conocimiento del operador AND y del operador NOT
6.4.5. Ejercicio 5
Imprimir los números del 1 al 30 sin imprimir números entre el 10 y el 20 uno abajo del otro
Requisito: se necesita tener conocimientos del operador OR
6.4.6. Ejercicio 6
6.4.7. Ejercicio 7
Imprimir la suma de los números pares del 1 al 25
Requisito: se necesita tener conocimientos del operador RESTO
6.4.8. Ejercicio 8 – BONUS!
Imprimir la multiplicación de los números impares que se encuentran entre -10 y 10
6.4.9. Ejercicio 9 – BONUS!
Imprimir la suma de los números pares mayores a 9 y menores a 20 que se encuentran entre el 1 y el 30
6.5. Lab 3 - Utilización de la estructura de control
FOR
6.5.1. Ejercicio 1
Imprimir los números del 1 al 10 uno abajo del otro
6.5.2. Ejercicio 2
Imprimir los números del 1 al 10 salteando de a dos uno abajo del otro
6.5.3. Ejercicio 3
Imprimir los números del 10 al 1 uno abajo del otro
6.5.4. Ejercicio 4
Imprimir la suma de los números impares del 1 al 10
6.5.5. Ejercicio 5
Imprimir la suma de la multiplicación de los números del 1 al 5 con la resta de los números del 1 al 5
6.5.6. Ejercicio 6
Imprimir la siguiente figura: @
@ @ @
6.5.7. Ejercicio 7
Imprimir la siguiente figura: @ @@ @ @@ @
6.5.8. Ejercicio 8
Imprimir la siguiente figura: @ @@ @@@ @@@@ @@@@@
6.5.9. Ejercicio 9
Imprimir la siguiente figura: @@@@@
@@@@ @@@ @@ @
6.5.10. Ejercicio 10 – BONUS!
Imprimir la siguiente figura:@ @@ @@@ @@@@ @@@ @@ @
6.5.11. Ejercicio 11 – BONUS!
Imprimir la siguiente figura: @@@@@@@@ @ @@@ @@@@@
6.6. Lab 4 - Utilización de Vectores
6.6.1. Ejercicio 1
Dado el vector [10,20,5,15,30,20]
a. informar el vector de la forma: "Indice: X, Valor: Y" b. totalizar el vector e informar el total
c. informar el contenido de las posiciones impares (por ejemplo, las posiciones 1,3,5,etc)
d. informar el mayor número
e. informar cuantas veces aparece el número 20
6.6.2. Ejercicio 2
Dado el vector inflacion [0.8, 0.1, 0.3, 0.4, 0.3, 0.6, 0.5, 0.3, 0.7, 0.3, 0.2, 0.9] Cada item del vector representa la inflación de un mes de tal manera que el primeritem del vector que es 0.8 representa la inflación de Enero, y el ultimo item del vector que es 0.9 representa la inflación de diciembre. Se pide:
a. informar la inflacion anual
b. informar la inflacion mas baja, junto con el numero de mes. Por ejemplo: Mes 2 = 0.1
c. informar la inflacion mas alta, junto con el numero de mes. Por ejemplo: Mes 12 = 0.9
6.6.3. Ejercicio 3 – BONUS!
Agregar los cambios que resulten necesarios al ejercicio anterior para que en los puntos b y c se informe la inflación junto con el nombre del mes. Por ejemplo: Mes FEBRERO = 0.1
6.7. Lab 5 – Introducción a Interfaz Grafica de
Usuario
6.7.1. Ejercicio 1
Etapa #1 - Construcción de la Interfaz Grafica
Armar la siguiente ventana en forma grafica:
La caja de texto para el usuario deber llamarse txtUsuario La caja de texto para la contraseña debe llamarse txtContrasena El boton de login debe llamarse btnLogin
El boton de limpiar debe llamarse btnLimpiar
Etapa #2 – Programación de Eventos
Se deberán programar los eventos de los botones para que realice un determinado procesamiento en caso de ser presionados.
Al presionar el botón Limpiar se deberán limpiar:
• la caja de texto usuario
• la caja de texto contraseña
• la etitqueta correspondiente a la información
Al presionar el botón Login se deberá corrobar que sea un usuario valido. El usuario valido es aquel que tiene usuario = “pepito” y contraseña = “educacionIT”.
Informar los siguientes casos:
• si usuario=“pepito” y clave =”educacionIT” informar en la etiqueta
información la frase “Bienvenio pepito!”
• si usuario=”pepito” y clave no es “educacionIT” informar en la etiqueta
información la frase “El usuario no coincide con la contraseña”
• si usuario no es “pepito” informar en la etiqueta información la frase “El
6.7.2. Ejercicio 2
Construir una calculadora con una interface gráfica de usuario (con WinForms y los controles que correspondan).
Esta deberá contener un display superior en donde se muestran los números introducidos y su resultado, los diez dígitos (0 al 9) numéricos y las cuatro operaciones básicas (+ , - , * , /) y el signo “=” (igual), como muestra la siguiente imagen:
Se debera programar que al presionar cualquiera de los numeros se debera ir llenando el display con el numero presionado. Debe soportar agregar numeros con decimales No es necesario realizar la programación de las operaciones suma, resta, multiplicación y division
7.
Introducción al Paradigma de Objetos
7.1. Objetivos
7.1.1. Mapa del Curso
1. Introducción a .NET
2. Entorno de Desarrollo
3. Sintaxis y Semántica de C#
4. Arreglos
5. Introducción a la Programación Visual
6. Laboratorio
7.1.2. Descripción
En este capitulo usted verá:
• Conceptos del paradigma de programación orientado a objetos.
• Los conceptos sobre Clase y sobre Objetos.
• Los conceptos sobre Herencia de Clases
• Aspectos de ocultamiento de información y visibilidad.
7.1.3. Metas
Al final de este capitulo usted será capaz de:
• Conocer las definiciones del paradigma de objetos.
• Dominar los conceptos de Clases, Objetos, Instancias y Herencias.
