curso c net introduccion 20junio2011
TRANSCRIPT
Conozca las ventajas del entorno de desarrollo.Comprenda los tipos de objetos, ciclos y sentencias.Aplique los controles comunes para Windows.Aprenda con ejemplos sencillos y prácticos.
Introducción a VisualStudio
Estimado lector:
Agradezco su interés por aprender este interesante lenguaje, durante este proceso trataré de explicar de la manera mas amena como puede mejorar sus aplicaciones con C#.NET y diferentes componentes de hardware, también narraré algunas experiencias de aplicaciones en las que he participado como desarrollador.
Espero los libros sean de su agrado y útiles para sus proyectos.
Atte.Ing. Aaron Castro Bazúa
Acerca de este libro
El libro nace de una necesidad de aplicar el lenguaje C#.NET en proyectos de automatización con un enfoque práctico, el objetivo es recopilar temas y experiencias que faciliten al lector el aprendizaje con un enfoque a sistemas de automatización.
La presentación de los temas se plantean como una charla personal entre instructor y lector.
Acerca del autor
Egresado de Ingeniería Electrónica por el Instituto Tecnológico de Sonora en 2003, estudió programación a partir de 1995 con Turbo C y VisualBasic, desde entonces ha desarrollado prototipos y proyectos involucrando hardware electrónico e industrial, módulos multimedia con flash y bases de datos, actualmente se desempeña como Freelance en el campo de soluciones a la medida integrando C#.NET.
Simbología
TipsRepresenta algún tip interesante que debemos tener en cuenta
Significa una comparación entre el antiguo Visualbasic y C#.NET
Este símbolo aparece cuando explicamos un concepto con lenguajesencillo o una analogía.
VB (90’s) comparado con C#
En Lenguaje Terrícola
Anécdotas
VB C#
Para una lectura más amena utilizararemos estos símbolos para dar énfasis a notas especiales.
En estos párrafos narraremos alguna anécdota relacionada con el tema tratado.
Transición de Visualbasic (98) a C#.net .............................. 1Origen de .NET.......................................................................2Conceptos básicos de la plataforma y POO ..........................3Métodos, Propiedades e interfaz............................................4Interfaz de desarrollo IDE .....................................................5 Barra de Herramientas ................................................................6El editor de código .....................................................................7Propiedades y eventos en controles .....................................8Argumentos en controles ......................................................9Explorador de soluciones ....................................................10Comentarios, nodos y regiones ...........................................11El depurador (debugger) ......................................................12Tipos de dato y sus rangos ..................................................13Tipo Carácter y string ...........................................................14Tipo Int, Byte, Bool y Float ...................................................15Operadores aritméticos y lógicos .........................................17Operadores bits, asignación y creadores de objetos............18Conversión de datos.............................................................19Ámbito de variables...............................................................20Flujo de programa, ciclos y decisiones .................................21Declaración de funciones .....................................................22Sentencia IF...........................................................................25Sentencia GoTo.....................................................................25Operador AND y sentencia IF ...............................................26Operador OR y sentencia IF..................................................27Ejemplo con "La Prueba de Turing" ......................................29Sentencia Switch ..................................................................32Ciclo For ...............................................................................34Ciclo For Each y While................................................................36Ciclo Do While ......................................................................37Excepciones Try, Catch, Finally ............................................38
Control Button ...................................................................44Control ImageList.......................................................................45El Textbox y el método replace .............................................47Control Label y ListBox..........................................................48Control CheckBox y NumericUpDown ..................................49Control RadioButton y GroupBox ..........................................50Control PictureBox.................................................................51Control ComboBox y Timer....................................................52Control HScrollBar, VScrollBar y ProgressBar.......................54Control DataGridView y TabControl ......................................55Control SerialPort..................................................................56Mensajes y cuadros de dialogo ............................................57Ejemplo con un control Timer ...............................................60
Ámbito de variables.....................................................................41Convención de nombres para variables y controles ............42
ContenidoIntroducción
IDE
Tipos de datos
ÁmbitoFlujo de programa
Sentencias
Ciclos
Controles comunes
Ejemplo
Evolución de lenguajes y antecedentes de .NET
De Turbo C, Pascal a C#.NETSi usted aprendió a programar con lenguajes orientados a procedimientos como Turbo C, Turbo Pascal, Clipper, etc. este libro le ayudará a emigrar a la programación orientada a objetos de una manera sencilla con ejemplos de aplicaciones prácticas.
De VisualBasic (98) a C#.NETAsí que aprendió a programar en VisualBasic, que versión ¿4, 5, 6?, que tiempos aquellos cuando el compilador nos dejaba jugar a programar sin muchas restricciones y poco nos preocupaba la gestión interna del lenguaje, dado que este libro tiene un enfoque principalmente a ingenieros en electrónica permítame compartir algo…
En el 95 fue mi primer contacto con Turbo C y debo decir que desde que sentí que podía hacer que la maquina “pensara” no me pude despegar de este mundo tan interesante llamado programación, crear videojuegos fue la mejor manera de ganar entusiasmo, durante esos días teníamos la limitante de ejecutar en ambiente DOS, agregar mouse y gráficos era una tarea laboriosa y casi artesanal, fueron 3 años de aplicar el lenguaje en diferentes proyectos escolares y salvar mi vida gracias al legendario Turbo C… hasta que llego un el día que me presentaron a VisualBasic, al ver la interfaz pensé… ¿y donde esta el editor?, después al arrastrar controles y configurar sus gráficos sin programar fue un autentico “Shock”.
VisualBasic(98) ¿Cómo puede ser tan sencillo?.Cualquier persona que tuvo la experiencia de pasar de lenguajes por procedimientos a un lenguaje como VisualBasic se hace esta pregunta, crear la interfaz sin tener que programar fue un gran avance en el mundo de la programación y durante el 93 al 2000 fue una época de rediseño de sistemas muy interesante, la moda era emigrar de ambiente DOS a Windows, también tomaron auge otros competidores como Delphi y Java, sin embargo los programadores de automatización optaron por VisualBasic y gran cantidad de sistemas de monitoreo comunicados con PLC's están muy bien implementados con este lenguaje, hago énfasis por que fue muy criticado en ambientes de informática e ingeniería en sistemas, lo consideraban muy limitado y un “lenguaje de juguete”, la razón: demasiada sencillez genera malos hábitos de programación.
Los problemas…Una situación común en el área de sistemas es cuando se tiene que retomar el código fuente de otro programador, como desarrollador me ha pasado en muchas ocasiones, a veces es por que los sistemas no se cotizan bien y el programador cliente entran en conflictos económicos con su cliente, la verdad es complicado cotizar y poner límites a un sistema, implementar una propuesta al pie de la letra en tiempo y costo es un verdadero arte. El problema fue que VisualBasic complico esta situación, retomar un código de otra persona sin tener documentación o “Los Planos” de un sistema es realmente caótico, ¿y esta variable para que es?, ¿Por qué hizo esto? Era mejor así , ¡Para que tantos timers! ¡No puedo depurar! (solo recuerdos), al final la mayoría prefería decir al cliente que tenía que reiniciar el sistema con una frase estilo Hollywood… ok voy a hacer su sistema… “pero a mi manera”.
1
Evolución de lenguajes y antecedentes de .NET
Tipos de programación y la transición a objetosEmigrando de VisualBasic (eventos) a C#.NET (objetos):
Muy bien, usted esta decidido a evolucionar, cuando se programa por eventos solo se ponen a trabajar los controles disponibles, sin embargo en VB no era común crear nuestros objetos por que la mayoría de los libros no promovían esta tendencia y los programadores podían crear sus sistemas sin necesidad de seguir la filosofía de objetos.
¿Puedo programar en C# sin crear mis Clases (objetos)?La respuesta es Si, pero trataremos de erradicar esa práctica y dejar a un lado los malos hábitos que pudo dejar VB, aún en esta nueva plataforma y sus restricciones todavía podemos crear un caos de código.
Una nueva forma de razonar…Ahora con C#.NET conoceremos una forma mas natural de pensar en un sistema de control o monitoreo, también cuestiones internas del compilador que no se mostraban en VB y algunos conceptos nuevos como multihilos, herencia, polimorfismo, encapsulamiento, abstracción, etc.
La plataforma .NETLa primera versión de toda la gama de lenguajes .NET vio la luz entre el 2000 y 2002, durante esta etapa se puso a prueba su versiones Beta y 1.0, con la moda se dio a conocer una nueva palabra “Framework”, en Java esto se conoce como “Maquina Virtual”, sin embargo no solo es un intérprete, permite que gran variedad de lenguajes generen binarios compatibles entre si, de todos ellos el que ha ganado mas popularidad es sin duda C#.NET.
De donde surge C#.NETPor el concepto de máquina virtual que comparte con Java para algunas comunidades es una especie de copia, personalmente creo que viene inspirado en Delphi por dos razones:
1.- Mismo arquitecto: Anders Hejlsberg2.- Delphi incorporó un IDE para formularios Web y de Escritorio antes de la plataforma .NET (1997).
Cabe destacar que gran cantidad de programadores de Delphi cambiaron a C# por estas razones.
2
El Fin de VisualBasic (98)VisualBasic volvió a nacer con la plataforma .NET, muchas son las razones por las que Microsoft decidió crear su nueva generación de lenguajes y plataforma, personalmente creo que fue una gran herramienta que solo tenía el error de consentir demasiado al programador restando crédito a su eficiencia, los sistemas han evolucionado en gran parte por el auge de Internet, los antiguos diagramas de flujo ya no pueden representar la totalidad de la operación de un sistema, otros estándares como UML (Unified Modeling Language) se han diseñado especialmente para la programación orientada a objetos y las nuevas tendencias, esto fue la razón primordial del gran cambio en Visualbasic y su hermano C#.NET.
3
C# y el OpensourceEl mundo del OpenSource también se sintió atraído por C#, el Mexicano Miguel de Icaza y su proyecto MONO se encuentran actualmente implementando en forma paralela su compilador C# para Linux, otra buena razón para confiar en este lenguaje.
Anécdota:En una conferencia le preguntaron a Icaza, ¿un programador puede pasar de .NET a Mono?En ese tiempo Mono no tenia debugger y la dificultad al programar era mayor, su respuesta fue...“Depende que tan hombre eres”.
La Filosofía de .NETHasta el momento tenemos claro que C#.NET es una evolución a los entornos de programación y sigue cobrando fuerza, pero... ¿a que se refiere la plataforma y el tan nombrado framework?.
Acerca del FrameworkLo que en Java se conoce como “máquina virtual” en .NET se convierte en el “Framework”, son simplemente archivos que permiten que se ejecute la plataforma en las PC’s con windows, cada cierto tiempo salen nuevas versiones del Framework (1.1, 2.0, 3.5, 4, etc), es necesario tenerlos instalados con sus respectivos parches (SP1, SP2, etc) para que funcionen nuestros proyectos.
Programación Orientada a Objetos en C#.NET
¿Que es una Clase?
La popularidad de la programación orientada a objetos se debe a los buenos resultados al momento de construir, rediseñar y dar soporte a un sistema.
Un programador que viene de un lenguaje por procedimientos con Turbo C o Ensamblador debe acostumbrarse a nuevos vocablos y una forma diferente de idealizar el proyecto.
Consideraciones generales si usted esta acostumbrado a programar por procedimientos... Las librerías reutilizables ahora las llamaremos Las funciones ahora las llamaremos Las variables que tiene cada Método de una Clase se llaman
Clases.Métodos.
Propiedades.
Una clase es la definición de las características concretas de un determinado tipo de objetos. Es decir, de cuáles son los datos y los métodos de los que van a disponer todos los objetos de ese tipo.
En lenguaje terrícola...Las ventajas primordiales de .NET es que se pueden elegir varios lenguajes y combinar los ejecutables que genera cada uno, es decir una parte de un proyecto puede estar hecho en C#.NET, otra en VisualBasic.NET o Delphi.NET y compartir el código sin problema, esto se debe a que todo se convierte a un lenguaje intermedio (MSIL) que estandariza el código antes de convertirlo en lenguaje máquina.
! Iniciemos !Abrimos VisualStudio y elegimos un proyecto en C# para windows forms.
4
¿Donde obtener C#?Existen versiones “express” de VisualStudio que son gratis y las podemos obtener por Internet en el portal de Microsoft, para este libro nos basamos en la versión 8 y el Framework 3.0.
Clases en lenguaje terrícola...Una Clase define el comportamiento y descripción de cualquier cosa, un objeto material (carro, martillo, mesa), un concepto (cuenta bancaria, deuda, impuestos ) o un ser vivo (humano, perro, delfín).
Métodos de una ClaseLos métodos son las funciones privadas o públicas que dan “vida” a nuestro código, es común que el nombre de estos métodos sea un verbo como “Encender”, “Apagar”, “Encontrar”, etc. Las Clases pueden tener infinidad de métodos en los cuales se debe razonar muy bien su labor y como interactúa con otros métodos y propiedades internos.
Propiedades de una Clase
Vamos a centrarnos en el tema de Clases una vez que dominemos la programación estructurada.
Las propiedades son todas las variables privadas o públicas con las que realiza sus operaciones cada Clase, por ejemplo para un Objeto “Persona” sus propiedades pueden ser: Edad, Peso, Estatura, etc. En el caso de un proceso industrial donde modelamos el comportamiento de un Motor las propiedades pueden ser valores como Corriente, Voltaje, Caballos de Fuerza. etc.
Visualstudio.NET
Visualstudio y su entorno de desarrollo integrado (IDE).El IDE es nuestro panel de desarrollo donde tenemos todos los componentes necesarios para nuestro sistema: formularios, panel de propiedades y proyectos, editor, depurador, acceso a servidores de datos, componentes, clases, etc.
En VisualStudio se facilita mucho el desarrollo por que nos proporciona mensajes al momento de codificar, depurar y configurar.
5
Es una interfaz muy fácil de personalizar, podemos ajustar tamaños y el acomodo de los paneles, en lo personal recomiendo ajustar la pantalla como se muestra en la imagen:
El panel de proyectos y propiedades al lado derecho son los mas importantes para desarrollar fácilmente.
HerramientasFormularios
Propiedades
Ventana de Proyectos
Barra de herramientasEn la barra de herramientas tenemos todos nuestros controles comunes y aparte podemos agregar otros mas especializados dando clic derecho sobre la barra y la opción “elegir elementos”.
6
Como ejemplo tenemos el control Shockwave Flash que no viene como parte de los objetos comunes pero será útil en nuestro curso.
Visualstudio.NET
El editor de código Visualstudio tiene muchas ventajas, es muy cómodo y fácil de organizar, nos ayuda al momento de programar ya que muestra posibilidades a medida que vamos tecleando, tiene otras bondades como mostrarnos las partes del código que genera, acomodar las llaves, crear regiones y organizar mejor nuestro código.
7
Al momento de aprender a usar VS provoca confusión todo el código “extra” que nos muestra el editor, en los tiempos de VisualBasic (98) esto no se mostraba al usuario, ahora Microsoft decidió abrir parte de su código y dejarnos ver sus interiores para comprender mejor el lenguaje.VB C#
Primeros pasos con C#.NET
Antes de empezar a crear nuestras interfaces es importante definir dos conceptos:
Glosario de palabras comunesCompilar: Proceso de convertir el texto o código de nuestro programa a un lenguaje máquina.Instancias: Son objetos que derivan de una clase.Framework: Es un conjunto de ensamblados que permiten que funcione .NET en una PC.Cast: Es el vocablo utilizado para conversión de datos.
Tiempo de diseño:
Tiempo de ejecución:
Es cuando nos dedicamos a dibujar la interfaz arrastrando y configurando objetos sin ejecutar el programa.
Es cuando compilamos con éxito y nuestro programa esta ejecutándose.
Concepto de PropiedadLas propiedades son características que tienen todos los controles, por ejemplo un Botón (Button) puede ser color rojo, tener una coordenada x=50, y=100 , estas propiedades nos definen la vista gráfica del control pero también existen otras para dar comportamiento a nuestro control, por ejemplo:
8
La sintaxis para leer o establecer propiedades por medio de código en C# es la siguiente:
El ícono nos permite elegir las propiedades del objeto, mientras que el nos permite ver los eventos posibles en ese control.
Concepto de Evento
Enabled.- nos dice si el control esta habilitado para operar, sus valores son (true, false).
Visible.- Permite ocultar el diseño en tiempo de ejecución, sus valores son (true, false).
Autosize.- Permite que el control se ajuste al tamaño del texto.
Todas estas propiedades se pueden establecer mientras diseñamos la pantalla o bien durante la ejecución.
Un evento son las posibles reacciones que tiene un control y permiten ejecutar código, por ejemplo el evento clic de un usuario, arrastrar el mouse sobre un control, etc. Cada control tiene variedad de eventos en común con otros objetos o especialmente diseñados.
En el caso de un Botón es sencillo acceder a su evento Click, solo seleccionamos la casilla y hacemos doble Click para entrar al código.
Como podemos ver VS nos escribe parte del código.
Vamos a hacer un ligero paréntesis comparándolo con la programación orientada a eventos de VisualBasic 98:
9
Si usted manejo VB recuerda que los botones de llamaban comandos y el código generado por VS en un evento Click solo mostraba el nombre “Command1“ seguido de _Click(), por alguna razón no era necesario conocer como el compilador trabajaba internamente, tal vez esa fue la clave de la sencillez y éxito de VisualBasic, con C# cambia nuestra manera de trabajar con un lenguaje, ahora podemos entender mas a fondo que hace el compilador, para empezar nos muestra dos parámetros extra en el evento Click: ( object sender, EventArgs e)
Para probar estos argumentos vamos a utilizar el botón previamente dibujado y en el evento KeyPress del textBox1 escribimos:
Por ejemplo en un textBox los argumentos que manda el evento keypress son los caracteres:
Ejecutando nuestro programa con observamos como pasamos el valor de un control a otro.
VB C#
La pregunta es… ¿para que nos sirven?object sender: nos permite saber cual objeto esta generando el evento, en este caso el botón.
EvenArgs e: Nos permite conocer datos que trae el objeto que nos provoco en evento.
El IDE también genera líneas en la clase del diseñador Form1.Designer.cs, el código generado corresponde a la configuración de propiedades del botón y el evento que tenemos registrado (Click), ahora VisualStudio nos permite ver y modificar su código interno.
10
En Visualbasic el código del diseñador era completamente oculto al usuario.
El entorno de desarrollo de Visualstudio:
Explorador de SolucionesEl explorador de soluciones nos permite acceder a todos nuestros formularios, clases y variedad de elementos para nuestro sistema.
VB C#
Para este ejemplo solo contamos con un formulario (Form1.cs) pero se pueden tener mayor cantidad, inclusive crear una solución con varios proyectos que a su vez tengan sus propios formularios.
La carpeta de Referencias contiene las librerías que ocupa nuestro programa, en adelante vamos a poner énfasis en esta carpeta ya que incorporaremos controles como Flash y componentes para conexión con PLC’s.
El Program.cs es como la chispa de encendido de cualquier programa en C#, crea la primera instancia de nuestro formulario de inicio, a su vez se invoca el método que dibuja los gráficos iniciales de nuestro programa, es decir ejecuta las líneas de Form1.Designer.cs.
11
Sobre el EditorEl editor de VisualStudio posee muchas ventajas para estructurar un programa, le presento 3:
Comentarios en C#: Los comentarios es una buena práctica al desarrollar, nos permite explicar el funcionamiento de alguna instrucción o función de nuestro programa, en VisualStudio tienen un color verde y para agregarlos tecleamos dos diagonales “ “, con esto VS pone en color verde el texto y lo deja sin validez para la lógica del compilador.
Si deseamos agrupar varias líneas de comentarios agregamos /*al inicio y */ al final, ejemplo:
//
Uso de nodos: Los nodos son otra característica de VS para hacer mas sencilla la lectura del código, cada vez que se agrupa un evento o función por medio de las llaves “{ }” se genera un nodo con el símbolo , si presionamos el código encerrado se reduce a una sola línea, con esto es más sencillo encontrar porciones del programa en las que estamos trabajando y dejar en una sola línea las que ya están validadas.Ejemplo para un evento Load:
Uso de Regiones:A diferencia de los nodos, las regiones las define el usuario y pueden agrupar secciones de nodos, las sintaxis es:
nuestro texto#region#endregion
Al presionar el nodo nos queda
Como podemos observar toda la región queda acotada a una sola línea y conserva el texto que definimos: “Funciones de Monitoreo”.El uso de regiones es otra buena práctica para organizar nuestro programa, corregir errores y agregar funciones.
Iniciando con la consola de C#.NETVamos a pausar la explicación de los formularios de
windows para centrarnos en los tipos de datos, sentencias y ciclos al estilo antiguo, con la consola de C#.NET.
Iniciando con la consola de C#.NETCreamos un nuevo proyecto del tipo “Aplicación de Consola”.
Dejamos por un momento este proyecto, ahora vamos a una parte interesante en todos los compiladores: El Depurador.
El Depurador (debugger)En 1947 la inventora del primer compilador Grace Hooper, se encontraba trabajando en la "supercomputadora" electromecánica Mark II, un día al estar operando se registro un error que impedía el avance de los comandos, los operadores buscaron entre los "pasillos" de la máquina y alguien dijo ¡Es un bicho!, refiriendose a una palomilla atrapada en un relevador, desde entonces se conocen como "bugs" a los errores que impiden que se ejecute un programa y el nombre "debugger" a la herramienta para encontrarlos.
El Depurador se encuentra en el menú principal.El “Bicho” quedo almacenado para la Historia en el libro de apuntes del sistema. Fuente: U.S. Naval Historical Center Online Library Photograph NH 96566-KN
12
Trabajar con la consola de C# es parecido al ambiente MS-DOS antiguo, como se puede observar el proyecto solo se compone de las propiedades, referencias y la clase básica: Program.cs
Tipos de datos y prácticas con el depuradorEn este capítulo estudiaremos conceptos básicos del lenguaje concentrados en sus tipos de datos, operadores, conversión y consejos sobre la mejor manera de asignar un nombre a los controles.
Es muy importante tener bien claro estos conceptos por que sentarán las bases del lenguaje, en C# todas las variables son objetos por lo cual analizaremos métodos implícitos que nos ahorrarán tiempo de codificación.
Me interesa que a usted le quede muy claro como se va ejecutando cada línea de código, para esto vamos aplicar el depurador (debugger) de VisualStudio.Detalles a considerar sobre la codificación en C#:
VB C#Diferencias con VB (98)El lenguaje si distingue entre mayúsculas y minúsculasEn C# no existe el tipo Variant El tipo Float es el equivalente a Single o Double en VisualBasic
Tipos de dato en C#El tipo de dato depende de la información que vamos a guardar, es importante una buena elección para no desperdiciar memoria y hacer lento el sistema.
En esta tabla se presentan los tipos de C# y sus rangos posibles de valor.
C# Tipo Rangosbyte -128 a 127short -32768 a 32767int -2147483648 a 2147483647long -9223372036854775808 a 9223372036854775807byte 0 a 255ushort 0 a 65535uint 0 a 4294967295ulong 0 a 18446744073709551615float Aprox. ±1.5 x 10-45 a ±3.4 x 1038 con 7 decimalesdouble Aprox. ±5.0 x 10-324 a ±1.7 x 10308 con 15 o 16 decimalesdecimal Aprox. ±1.0 x 10-28 a ±7.9 x 1028 con 28 o 29 decimaleschar Cualquier carácter unicote, ocupa 16 bit
¿Qué tipo de dato elegir?Si usted va a guardar información de tipo texto el indicado es el String, observe los ejemplos...
La sintaxis básica es: Nombre de variableTipo de dato
13
14
Tipos de datos más comunes:
String
String
Tipo de dato Char (Carácter)Nos permite almacenar un carácter “Unicode”, por lo regular guardamos letras. Ejemplo:
¿Qué es Unicode?Es una tabla que asigna un código a cada uno de los más de cincuenta mil símbolos para alfabetos europeos, ideogramas chinos, japoneses, coreanos y muchas otras formas de escritura, aparte tiene mas de mil símbolos especiales.
Tipo de dato (Cadena)Los tipos String nos permiten almacenar cadenas de caracteres donde el tamaño depende de la cantidad que ocupe, la sintaxis de declaración es:
NuestroDato;
Algo interesante con C# es que todos los tipos de dato tienen algún método que nos puede ser útil, para el tipo String tenemos el substring() que nos permite reemplazar datos de una cadena, ejemplo: En la clase program de nuestro proyecto de consola escriba el siguiente código:
Vamos a practicar con el Depurador. Agregue un punto de interrupción en el costado izquierdo dando Click y en el menú principal elija Depurar/ Paso a paso por procedimientos o bien F10.
La depuración nos permite ver “en cámara lenta” como funciona nuestro programa.
Cuando se ejecuta la línea del punto de interrupción posicionamos el Mouse en la variable “nuevotexto” y podemos ver como se reemplazo la palabra “VisualStudio” por “VS”.
Recuerda en C# todos losdatos son objetos, por lotanto tienen sus métodos y nos permiten ahorrar mucho tiempo.
15
Tipo de Dato (Entero)Los datos enteros nos sirven para almacenar números entre -2147483648 y 2147483647, por lo cual son muy utilizados para información que no tenga puntos decimales, comúnmente se aplica para guardar el índice en una base de datos, almacenar números de pedidos y cualquier valor que no implique decimales.
Ejemplo:
Int
Detalle importante:Cuando dividimos un dato entero entre un entero siempre nos regresa un entero, esto puede generar errores difíciles de detectar como lo muestra el ejemplo:
Tipo de Dato Los datos tipo Byte tiene un rango de valor entre 0 y 255 con números enteros positivos, es recomendable guardar valores que no excedan ese rango, ejemplos:
Por el enfoque electrónico de este curso la variable tipo la utilizaremos bastante.
Tipo de Dato Cuando ocupamos almacenar un valor que solo tiene dos opciones: el tipo es el mas indicado, la sintaxis es la siguiente:
Tipo de Dato (Punto flotante)
Las variables tipo Float tienen un rango entre 1.5*10-45 a 3.4*1038 con 7 decimales, su utilidad se da con cualquier valor que implique decimales. La sintaxis es la siguiente:
Constantes en C#Cuando ocupamos declarar una constante escribimos antes de la declaración del tipo de dato:
Byte
Byte
Bool true/false Bool
Float
const
17
Operadores y SentenciasEl símbolo de un operador nos permiten manipular datos de 5 maneras distintas, en C# tenemos 5 tipos: · Aritméticos
· Lógicos· Nivel de bits· Asignación· Condicional· Relacional· De conversión· De creación de objetos
Son la suma (+), resta (-), multiplicación (*), división (/) y módulo (%)
Ejemplo: Una sumatoria de números tipo Byte para conformar un dato tipo Int
El mismo operador nos sirve para concatenar cadenas:Las siguientes líneas son exactamente lo mismo.
Permiten realizar las operaciones lógicas típicas: “and” (&& y &), “or” (|| y |), “not” (!) y “xor” (^)
Asignando un punto de interrupción se puede comprobar:
Operadores Aritméticos:
Operadores lógicos
+
Los operadores lógicos son comúnmente utilizados en la sentencia IF donde permiten agrupar condiciones.En el siguiente capítulo vamos a crear dos ejemplos.
18
Operadores de nivel de bits
Como es necesario algo de teoría sobre números binarios vamos a explicar este operador en un ejemplo posterior.
Operadores de asignación
En nuestro curso vamos a tener comunicación con hardware que nos permitirá enfocarnos en lógica de bits, para esto utilizaremos los operadores a nivel bit de C#, los mas comunes son:
“and” (&) “or” (|) “not” (~) “xor” (^) desplazamiento a izquierda (<<) desplazamiento a derecha (>>)
El operador << desplaza a izquierda rellenando con ceros, mientras que el tipo de relleno realizado por >> depende del tipo de dato sobre el que se aplica: si es un dato con signo mantiene el signo, en caso contrario rellena con ceros.
Son los operadores que permiten asignar valores de una variable a otra.
Por ejemplo: a = b; //asigna a la variable a el valor de la variable b
Los operadores de asignación también pueden ser compuestos: +=, -=, *=, /=, %=, &=, |=, ̂ =, <<= 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.
Operadores de creación de objetosEl operador más típicamente usado para crear objetos es new, que se usa así:
<nombreTipo>(<parametros>)
Por el momento no vamos a entrar en detalles, solo debemos recordar que “new” es un operador y cuando implementemos nuestros objetos vamos a comprender su utilidad.
new
19
Cuando se trata de convertir datos debemos a acostumbrarnos a que cada variable es un objeto, quiero poner énfasis a este tema por que personalmente me resulto confuso comprenderlo, en los anteriores lenguajes que había utilizado como Turbo C y VisualBasic (98) las variables simplemente se entendían como un alojamiento de memoria con un tipo de dato, ahora en C# por el hecho de ser objetos tienen métodos interesantes, trataré de guiarlo en estos nuevos conceptos.
Uno de los métodos básicos de conversión es .toString(), al principio cuando uno codifica en C# nos parece que ahora tenemos que teclear mas para hacer lo mismo.
VB
VB
C#
C#
Ahora vamos a conocer como podemos cambiar el tipo de dato a diferentes variables.
Ejemplo: ¿Recuerda como se convertía un dato entero en una cadena con VisualBasic (98)?
Sencillo verdad, la misma operación en C# luce de esta manera:
Se puede observar que la diferencia esta en el método ToString que nos toma un segundo extra teclearlo.
En el caso de valores numericos se utiliza el operador de conversión “Cast”, para usarlo debemos preceder la expresión con un paréntesis del tipo al que se desea convertir.
Por ejemplo, si valor1 es una variable de tipo long y se desea almacenar su valor dentro de una variable de tipo int llamada valor2, habría que convertir previamente su valor a tipo int así:
Conversión de Datos
Cast (conversión de datos)
20
¿Se puede usar el Cast para convertir un entero en cadena?
Nos marca error, la forma correcta es utilizando el método toString.
En el caso de datos numéricos algunos no ocupan métodos de conversión, ejemplo:
Lo resolvemos con un Cast:
¿Como convertimos una cadena en un entero?El Método “Parse” nos permite hacerlo siempre y cuando la cadena solo contenga números:
Para probar como se puede dar el error agregamos una letra al número:
En temas posteriores vamos a crear rutinas para evitar este tipo de problemas o mejor dicho “Exceptions”.
21
Flujo de programa, ciclos y decisionesEn este capítulo estudiaremos las sentencias que permiten que las computadoras “razonen”, con varios ejemplos vamos a comprender la sentencia , y para darle a nuestros programas la habilidad de cuestionarnos y resolver nuestros problemas.
Para comprender mejor el uso de las sentencias vamos a olvidarnos un poco de los controles de Windows y regresaremos en el tiempo a las aplicaciones de consola, ¡no se preocupe!, se va a sentir un mejor programador.
La mayoría de los libros sobre C# comienzan con la consola, decidí empezar con un poco de formularios y controles para facilitar su primer contacto con el lenguaje. Las aplicaciones de consola nos permiten evaluar mejor la funcionalidad de nuestros objetos sin distraernos con la parte gráfica, el legendario Turbo C operaba de la misma manera y aún en ambiente MSDOS le mostraré que puede ser algo interesante y estimulante.
Si usted le pregunta a un informático de los años 70's u 80's le dirá que ya no existen los verdaderos programadores, su argumento es que todo es mas sencillo ahora, no hay que preocuparse tanto por la memoria y velocidad de procesamiento, existen generadores de código, infinidad de librerías, bibliografía en Internet, etc. Sin embargo los sistemas también se han complicado, un videojuego como el antiguo “Pong” comparado a los juegos 3d actuales que poseen inteligencia artificial, simulación de física, multiusuarios y captura de movimiento da crédito a los nuevos programadores.
Bien, volviendo a la realidad, iniciamos un nuevo proyecto del tipo consola, vamos nombrarlo EjemplosConsola con el Framework 3.5.
If Switch GoTo
22
Flujo de programa y funcionesRecuerde que en una aplicación de consola no tenemos ventanas ni controles, por lo tanto el explorador de proyectos solo nos muestra:
Si damos Click en Program.cs nos aparece:
Las funciones se crean a criterio del programador y pueden tener cualquier nombre y estructura, en objetos vamos a llamarlas métodos, tienen la misma sintaxis que los lenguajes por procedimientos pero su razonamiento es diferente, un método siempre forma parte de una clase y modifica sus propiedades internas.
Para utilizar funciones debemos hacer una declaración y escribir nuestro código adentro, para utilizar dicha función solo hay que llamarla por el mismo nombre con que fue declarada.
La sintaxis básica para declarar una función es:
tipo de retorno (parámetros) {
}
Declaración de una Función
Ámbito Nombre
Declaración y llamadas a funciones
23
Declaración:
La sintaxis para mandarla llamar es:
En este caso es una llamada sin parámetros y la función regresa sin valor, la manera correcta de utilizar métodos (funciones) es cuando les asignamos ligeras tareas y operan como una especie de caja negra.
Vamos a ver un ejemplo muy sencillo, en la funciónInicio() que acabamos de escribir vamos a mandar llamar otra función que va a realizar la tarea de calcular el voltaje con la fórmula:
Por lógica nuestra función ocupa dos datos para realizar la fórmula (corriente y resistencia) por lo tanto nuestra función debe tener dos parámetros, dado que la corriente por lo regular son valores con decimales usaremos un y para la resistencia los valores , otro detalle es que al multiplicar un flotante por un entero necesitamos el resultado del Voltaje en otro flotante con eso damos a nuestra función un valor de retorno.
Es importante que la variable Volt tenga el mismo tipo de dato de la función ( ), el comandopermite regresar el valor a otra variable al momento de llamar la función.
En la función Inicio tecleamos la llamada a funciónCalculaVoltaje, note que VisualStudio ya reconoce que existe esa función y le muestra los parámetros y el tipo de dato:
Voltaje= Corriente x Resistencia.
Float Int
Float return
Debe quedar de esta manera:
Declaración y llamadas a funciones
24
Funciones y ciclosAl ejecutar puede observar que la función hace su tarea y regresa el resultado, en este caso mandamos datos fijos pero si deseamos ingresarlos por consola el código es el siguiente:
Si usted disfruta la programación sin ocupar formularios o controles permítame decirle, nació para programar.
If
Sentencia IF ELSE
If
Bien, ahora que conocemos el manejo de la consola vamos con la “neurona” básica que permite pensar a las máquinas, la sentencia .
La sentencia es la forma básica de establecer una condición, su sintaxis básica es:
if( condición ) { instrucciones; } else { instrucciones; }
Una de las ventajas de la programación por procedimientos es como va guiando al usuario en el ingreso de los datos, también es la mejor manera de aprender a programar y razonar, hago este comentario por que en aplicaciones con formularios se comete mucho el error de sobrecargar de controles una interfaz y no dar al usuario un camino para el flujo de operación.
Ejemplos de ciclos con la consola de C#.NET
25
Sentencia IFLa sentencia IF nos permite comparar valores y decidir el camino, es un comando básico en cualquier lenguaje de programación. Cuando la condición que acompaña al no se cumple el programa salta a la opción .Reutilizando la función de inicio tecleamos el siguiente ejemplo:
IfElse
En la línea del tenemos la condición:
“Si la variable edad es menor o igual a 17” entra a los corchetes del , en caso contrario entra al .
Algunas combinaciones de cómo se pueden combinar los operadores en la sentencia .
If
IfElse
If
Operador Significado == Es igual a ¡= No es igual a < Es menor que <= Es menor o igual que > Es mayor que >= Es mayor o igual que
La sentencia tiene una extensión para sus opciones denominada n el siguiente ejemplo vamos a utilizarla con algunos métodos para cadenas y operadores.
If Else If, e
Sentencia GoTo
En los 70’s y 80’s fue un comando fundamental en el lenguaje QBasic, personalmente no recomiendo su uso, una mala implementación de esta sentencia puede provocar el famoso “código spaghetti”.
La sentencia nos permite hacer saltos incondicionales a diferentes regiones del programaGoto .
Ejemplos de sentencias con la consola de C#.NET
26
La sintaxis es la siguiente: goto <etiqueta>; etiqueta: //se pone en el lugar donde vamos a saltar
Ejemplo:usingusingusingusingnamespace
classstatic void string
private static void
goto
System; System.Collections.Generic; System.Linq; System.Text;
ConsoleApplicationSentencias{ { Main( [] args) { funcionInicio(); } funcionInicio() { repite: .WriteLine( ); .ReadLine(); repite; } }}
Program
ConsoleConsole
"Esto no tiene fin, desea continuar? presione una tecla..."//detiene la pantalla
//hace un salto incondicional a la etiqueta "repite"
Como se puede ver en el ejemplo por ser un salto incondicional es riesgoso su uso, cuando un programa mal diseñado se “cicla” es común que el culpable sea el GoTo.
Ejemplos de sentencias con la consola de C#.NET
El operador And y Sentencia IF
Escriba el siguiente código en un nuevo proyecto de consola.usingusingusingusingnamespace
class
static void string
private static void
stringbytestring
if
else
System; System.Collections.Generic; System.Linq; System.Text;
ConsoleApplicationSentencias{ { Main( [] args) { funcionInicio(); } funcionInicio() { carrera = ; edad = 32; idioma = ; ((edad <= 35) && (carrera == ) && (idioma == )) { .WriteLine( ); } { .WriteLine( ); } .Read(); } }}
Program
Console
Console
Console
//almacenamos valores en nuestros objetos (variables): carrera, edad e idioma.
//si todas las comparaciones nos devuelven True entramos a la sentencia If
"Finanzas"
"Inglés"
"Finanzas" "Inglés""Muy bien, usted cumple con el perfil del puesto"
"Lo sentimos, usted no cumple con el perfil requerido"
En este caso cumple con todas las condiciones.
¿Qué pasa si alguna de las tres variables no cumple?
Cambiamos la variable edad por 40.
Al depurar paso por paso observamos que la siguiente condición no se va a cumplir:
Ahora obtenemos:
Como observamos el operador AND nos ayuda a comparar varias condiciones a la vez.
Al ejecutar nos muestra:
El operador “||” (OR):Este operador nos permite agrupar condiciones y habilitar la entrada al código con el cumplimiento de cualquiera de las comparaciones.
usingusingusingusing
namespace
class
static void string
System; System.Collections.Generic; System.Linq; System.Text;
ConsoleApplicationSentencias
{ { Main( [] args) { funcionInicio(); }
//en este ejemplo utilizamos la sentencia OR combinada con un IF
Program
27
funcionInicio() { activaciónSensor1 = ; activaciónSensor2 = ; activaciónSensor3 = ; ((activaciónSensor1 == ) || (activaciónSensor2 == ) || (activaciónSensor3 == )) { .WriteLine( ); } { .WriteLine( ); } .ReadLine(); } }}
private static void
bool truebool truebool true
if truetruetrue
else
//declaramos 3 objetos tipo bool con un valor predeterminado
//si cualquiera de los 3 sensores se activa se ejecuta el interior del If
//detiene la consola esperando un carácter
Console
Console
Console
"Se activo la Alarma"
"Alarma en espera, sensores inactivos"
Al ejecutar nos genera...
Si agregamos un punto de interrupción se puede observar como se evalúa cada comparación.
Por ser un operador OR basta con cualquiera de las tres condiciones que se cumpla para que se active la alarma.Para dejar en claro el ejemplo modificamos los tres valores de sensor1, sensor2 y sensor3 para comprobar que entra a la sentencia ELSE.
28
Un poco de Historia…Alan Turing fue un pionero en establecer las bases de la computación moderna, la “Prueba de Turing” consiste en chatear con una computadora sin darse cuenta que un programa es el que responde, la hipótesis es que si una máquina se comporta en todos los aspectos como inteligente, entonces debe ser inteligente.
La sentencia tiene una extensión para sus opciones denominada su función nos permite comparar mayor cantidad de opciones y en caso de no cumplirse ninguna entrar al .
En el siguiente ejemplo vamos a utilizarla con algunos métodos para cadenas y operadores.
Ejemplo:Para hacer algo más interesante vamos a hacer un sencillo programa imitando la famosa “Prueba de Turing”.
If Else IfElse
,Sentencia Else If
Hasta el momento conocemos diferentes maneras de combinar operadores con la sentencia If, ahora conoceremos otra modalidad...
Creamos un nuevo proyecto de tipo consola y escribimos el siguiente código.
using usingusingusing
namespace
class
static void string
private static void
string
string
string
string
if
else
System; System.Collections.Generic; System.Linq; System.Text;
EjemplosConsola{ { Main( [] args) { funcionInicio(); } funcionInicio() { .WriteLine( ); .WriteLine( ); .WriteLine( ); r = .ReadLine(); .Clear(); .WriteLine( ); nombre = .ReadLine(); .WriteLine( + nombre +
); respuesta = .ReadLine(); auxrespuesta = respuesta; respuesta = respuesta.Replace( , ); respuesta = respuesta.ToLower(); (respuesta.Contains( )) { .WriteLine(
); } { .WriteLine(auxrespuesta +
); }
//un ligero chat imitando "La Prueba de Turing" (funciona con minúsculas)
//guardamos lo que escribe el usuario en “r”//limpia la pantalla
//leemos el valor de consola
//leemos el valor de consola//guardamos la respuesta en otra variable antes de quitar espacios
//con el replace eliminamos todos los espacios
//convertimos todo en minúsculas//con el método Contains de nuestro objeto respuesta se puede analizar la cadena
//si en la respuesta viene la palabra "si" o "SI"
Program
ConsoleConsoleConsole
ConsoleConsoleConsole
ConsoleConsole
Console
Console
Console
"Simulación de la Prueba de Turing (use minúsculas)""* * * * * * * * * * * * * * * * * * * * * * * * * * *""Presione cualquier tecla para continuar"
"Saludos! hay alguien por ahi?, cual es su nombre?"
"Que tal " " como va con el curso?, le gusta C#?"
" " ""
"si""que bien!, hace la programación mas
interesante y entretenida"
“ ?? esperaba un sonado SI!, pronto le entenderá mejor... "
29
.WriteLine( ); respuesta = .ReadLine(); .WriteLine(
); .WriteLine( ); inicio: respuesta = .ReadLine(); respuesta = respuesta.Replace( , ); respuesta = respuesta.ToLower(); (respuesta.Contains( )) { .WriteLine( ); respuesta = .ReadLine(); .WriteLine(respuesta +
); } (respuesta.Contains( ) || respuesta.Contains( )) { .WriteLine( ); respuesta = .ReadLine(); respuesta = respuesta.Replace( , ); respuesta = respuesta.ToLower();
(respuesta.Contains( ) || respuesta.Contains( )) { .WriteLine( ); } (respuesta.Contains( ) || respuesta.Contains( ) || respuesta.Contains( )) { .WriteLine( ); } { .WriteLine( ); } } (respuesta.Contains( )) { .WriteLine( ); respuesta = .ReadLine(); respuesta = respuesta.Replace( , ); respuesta = respuesta.ToLower(); (respuesta.Contains( )) { .WriteLine( ); } { .WriteLine( ); } } { .WriteLine( );
inicio; } .WriteLine( ); .WriteLine(
); respuesta = .ReadLine(); } }}
ConsoleConsole
Console
Console
Console
ConsoleConsole
Console
Console
Console
Console
Console
Console
ConsoleConsole
Console
Console
Console
ConsoleConsole
Console
"y que tal el clima por alla? "
"aquí por ahora esta templado, buen día para pasear a mi perro"
"tiene mascota?"
" " ""
"si""como se llama su mascota"
" gracioso nombre, el mío se llama Viejo, es un rottweiler"
"tuve" "tenia""si? y que paso?"
" " ""
"murio" "enfermo""que mal :S "
"robaron" "extravio""perdio"
"a veces se alejan mucho y se pierden"
"... :S"
"no""no le gustan las mascotas?"
" " ""
"no""entiendo, no a todos nos gustan"
"aaa ok"
"? no entendi ¿tiene mascota?"
"*******************************************************""que tal mis respuestas,
¿Si parezco HUMANO?, SALUDOS!!"
////reutilizamos la variable respuesta
//sentencia Goto, salta aquí si no coincide una respuesta abajo//reutilizamos la variable respuesta
//con el método Contains de nuestro objeto respuesta se puede analizar la cadena//si en la respuesta viene la palabra "si" o "SI"
//reutilizamos la variable respuesta
// si responde con la palabras tuve o tenía
//if anidado//reutilizamos la variable respuesta
//en caso de no cumplirse las anteriores
//reutilizamos la variable respuesta
//cuando ninguna coincide, el goto hace que salte al inicio de la pregunta
//pausa al final
if
else if
if
else if
else
else if
if
else
else
goto
30
Algunas de las posibles salidas de este programa son:
Al ejecutar sale un mensaje de bienvenida y se espera hasta pulsar una tecla.
¡Muy bien, después de “socializar” un poco con la máquina vamos con la sentencia switch.
31
32
Sentencia Switch
Con la sentencia es posible elegir diferentes opciones de acuerdo a una variable, en otras palabras solamente una de las condiciones se puede cumplir, cuando el valor de la variable no corresponde con alguno de los casos se elige la opción . El comando corta el flujo de ejecución del , en C# siempre debe acompañar el final de cada caso.
(expresión-control) { expresion-constante1: ; expresion-constante2: ; : ; }
Los tipos de datos permitidos para la expresión de control son sbyte, byte, short, ushort, uint, long, ulong, char, string o un tipo enumeración (enumeration).
Creamos un nuevo proyecto tipo consola, vamos a programar un test con una pregunta y 4 opciones.
switch
default BreakSwitch
switch
case break
case break
default break
//sentencia//se sale del switch
//sentencia//se sale del switch
//cuando no se cumple ninguno de los otros casos//se sale del switch
usingusingusingusing
namespace
class
static void string
private static void
stringswitch
case
breakcase
break
System; System.Collections.Generic; System.Linq; System.Text;
EjemplosConsola{ { Main( [] args) { funcionInicio(); } funcionInicio() { .WriteLine(
); .WriteLine(
); .WriteLine( ); respuesta = ( .ReadLine()); (respuesta) { : .WriteLine(
); ; : .WriteLine(
); .WriteLine(
); ;
//ejemplo de la sentencia switch
//leemos el valor de consola
Program
Console
Console
ConsoleConsole
Console
Console
Console
" ¿A quien se le considera el primer programador(a) de la Historia? "
" a).- Alan Turing b) Ada Lovelace c)Von Neumann d) Grace Murray "
"Elija la letra correcta: (a,b,c,d) "
"a""Incorrecto, Turing es uno de
los pioneros de la informática moderna "
"b""¡Correcto!, Ada Lovelace nació en 1815
y trabajo con la máquina analítica de""Charles Babbage, es considerada la Madre
de los lenguajes de programación. "
: .WriteLine(
); .WriteLine( ); ; : .WriteLine(
); .WriteLine(
); ; : .WriteLine( ); ; } .ReadLine(); } }}
case
breakcase
breakdefault
break
"c""Incorrecto, Von Neumann trabajo en los
años 40's y 50's en la arquitectura ""básica de las computadoras. "
"d""Incorrecto, Grace Murray fue una gran
matemática que entre los años 50s y 60s""programo en la Mark 1 y desarrolló el
primer compilador de la historia, el A-0."
"Dato incorrecto, no existe tal opción. "
Console
Console
Console
Console
Console
Console //crea una pausa esperando un carácter
Al ejecutar nos puede generar las siguientes salidas:
Con la opción a:
Con la opción b:
Con una letra diferente a (a,b,c,d):
Como observamos el manejo de sentencias nos permite hacer “pensar” a la máquina, ahora vamos a conocer los ciclos en C#.NET.
33
34
El Ciclo For
El ciclo se utiliza para repetir una secuencia de instrucciones cuando conocemos la cantidad exacta de veces que se recorra cierta región de código.La sintaxis básica es:
for (inicialización; condición; incremento)
{
instrucciones
}
For
Al ejecutar obtenemos una cuenta hasta el 100.
Las reglas básicas para usar este ciclo son:
• La variable del ciclo debe ser entera.
• La variable siempre se inicializa adentro del ciclo y puede iniciar con cualquier número.
• No se puede alterar la variable del ciclo mientras se esta ejecutando el For.
35
El Ciclo ForEl valor del final del ciclo puede ser otra variable, no tiene que ser constante, ejemplo:
La variable puede incrementarse i++ o decrementarse i --, también se pueden fijar los pasos del salto.
En este ejemplo empieza en 100 y se va decrementando de 2 en 2 hasta llegar a cero.
¿Cómo detener un ciclo For?El nos permite cortar toda la ejecución restante del ciclo , no importa en repetición.Modificando el ejemplo anterior para contar hasta 10:
Al ejecutar observamos que cuando llega a 5 el provoca que el ciclo termine.
Ahora modificamos el por un :
Al ejecutar obtenemos que cuando el valor es 5 el interrumpe al ciclo.
Bien ahora vamos a conocer otra modalidad del ciclo .
Break For
break
break continue
continue
For
36
El Ciclo For EachEl ciclo es una variante muy útil para recorrer arreglos de variables y objetos, su cualidad primordial es que no es necesario conocer el fin del ciclo ni el incremento.
Vamos a declarar un arreglo de valores enteros, en el siguiente capítulo los trataremos en detalle.
La sintaxis es la siguiente:
Al ejecutar nos genera:
For Each
El Ciclo While El ciclo While es útil cuando el límite del ciclo puede variar, como la palabra lo dice “mientras” se cumpla la condición el ciclo continúa.
La sintaxis básica es:
while (<condición>)
{
<instrucciones> }
Si deseamos crear un ciclo infinito:
37
El ciclo se ejecuta hasta el momento que se presione algo…
Como puede observar el ciclo tiene su lado interesante, es importante cuidar como implementarlo para no generar ciclos infinitos.
While
El ciclo Do While tiene una ligera variante al While, primero ejecuta luego pregunta si debe continuar.
La sintaxis es: do
{
<instrucciones> }
El Ciclo Do While
En “lenguaje terrícola” este ciclo es como el viejo dicho, “es mejor pedir perdón que permiso”, primero ejecuta luego pregunta si puede volverlo a hacer.
En este ejemplo el programa ejecuta la instrucción y despues pregunta si el usuario desea volver a ejecutar.
Con el conocimiento de operadores, sentencias y ciclos tenemos las principales armas de programación en C#, aún nos faltan algunas variantes que aprenderemos cuando se ocupe.
38
Excepciones Try, Catch, Finally
Con el conocimiento de ciclos y sentencias tenemos las armas para ejecutar cualquier lógica, sin embargo los errores siempre obedecen a la Ley de Murphy, ¿Cómo encontrarlos?, no siempre se trata de errores humanos, existen errores técnicos de hardware, conexión, desbordamientos etc. C# nos facilita este trabajo con el manejo de “excepciones” las cuales son el grito de auxilio del sistema operativo cuando le piden algo imposible.
Algunos ejemplos de excepciones son: · División sobre cero (error humano)
· Conversión de un tipo de dato en otro sin operadores (error humano)· Abrir archivos corruptos (error de sistema)· Desconexión con redes o servidores (error de sistema o red)
Son comandos para detectar el error y manejarlo sin provocar una interrupción al sistema.Try, Catch
En “lenguaje terrícola” el comando Try es el “agente 007” para tareas riesgosas en C#, le permite reconocer un error y lidiar con él por medio del Catch.
La sintaxis básica es:
En el argumento del obtenemos el tipo de error, los más comunes son:Catch
ArgumentException:ArgumentNullException:
ArgumentOutOfRangeException:ArrayTypeMistmatchException:
COMException:DivideByZeroException:
IndexOutOfRangeException:InvalidCastException:
InvalidOperationException:InteropException:
NullReferenceException:OverflowException:
OutOfMemoryException:SEHException:
StackOverflowException:TypeInizializationException:
Pasado argumento no válido (base de excepciones de argumentos).Pasado argumento nulo.Pasado argumento fuera de rango.Asignación a tabla de elemento que no es de su tipo.Excepción de objeto COM.División por cero.Índice de acceso a elemento de tabla fuera del rango válido.Conversión explícita entre tipos no válida.Operación inválida en estado actual del objeto.Base de excepciones producidas en comunicación con código inseguro.Acceso a miembro de objeto que vale null.Desbordamiento dentro de contexto al momento de comprobar.Falta de memoria para crear un objeto con new.Excepción SHE del API Win32Desbordamiento de la pila, debido a un excesivo número de llamadas recurrentes.Excepción al inicializar los campos estáticos o el constructor estático de un tipo
39
Excepciones Try, Catch, Finally
Para ejemplificarlo vamos a hacer sufrir a la máquina…¿Que pasa si escribimos estas líneas?
Para remediarlo :
Ejecutando obtenemos:
También se puede obtener el tipo de error con el argumento “ex”:
En consola se puede ver el mensaje:
Excepciones Try, Catch, Finally
El bloque siempre se ejecuta no importando el error, es opcional utilizarlo, debe incluirse después de todos los bloques .
Ejemplo:
finallycatch
Convención de nombres y ejemplos de declaracionesEl concepto de convención de nombres es una manera de estandarizar la manera que se escribe un programa, como primera regla debemos tratar de usar un solo idioma en todo el proyecto, también adoptar nombres técnicos como “setPoint”, “On”, “Off”.
Otro detalle importante son los nombres de las variables y controles:
Para vamos a definir las siguientes reglas:
Todo en minúsculas y si son dos palabras separarlas por una mayúscula Usar la menor cantidad de palabras
Evitar abreviaciones confusas
nombrar una variable
Ejemplo:Para almacenar temperatura lo mas conveniente es que se defina de esta manera:
En resumen antes de empezar a programar debemos cuidar el nombramiento de nuestras variables, controles y posteriormente clases, métodos y propiedades.
Para es conveniente escribir el tipo de control de una manera abreviada y enseguida al nombre de la variable iniciando con mayúscula.
Ejemplos:
nombrar un control
40
Ámbito de variablesHaciendo memoria uno de los problemas que se daba con VisualBasic (98) era la falta de disciplina, para un programador sin buena instrucción era común declarar variables sin pensarlo e innecesarias, en ese sentido VB no era restrictivo y a la hora de buscar errores era un rompecabezas para todo el que tratara de re-internarse en el código, incluyendo el autor.VB C#
El buen manejo del ámbito divide el sistema en pequeñas tareas, cada objeto hace su trabajo cuando se requiere siempre y cuando reciba los parámetros que ocupa.
En C# los corchetes “{ }” determinan el ámbito donde de la variable conserva su valor.En este ejemplo tenemos 2 eventos (Form1_Load, timer1_Tick) y una función (funcionX), cada una tiene sus límites en base a corchetes, sin embargo la variable “contador” esta afuera de esos límites, por lo tanto su ámbito es válido todos los eventos y la función, sin embargo no pasa lo mismo para las variables internas ya que están limitadas por los corchetes.
VisualStudio nos permite localizar estos errores de ámbito antes de compilar el programa, observe como la variable contador puede ser manipulada por cualquier función o evento del programa, la razón es por que esta declarada en el ámbito de la clase Form1.
¡Cuidado!Es muy importante no declarar de variables públicas innecesarias, si usted tiene esa costumbre vamos a trabajar para dejarla a un lado, para realmente sacarle provecho a C# debemos encapsular las funciones y ver los programas como un conjunto de “cajas negras” que interactúan entre si.
41
42
El clásico “Hello World” lo vamos a hacer un poco modificadoDe la barra de herramientas arrastramos un control Button y un textBox, VS automáticamente les da un nombre, button1 y textBox1, mas adelante vamos a cuidar como nombrar nuestros
Vamos a dejar las propiedades como vienen y seleccionando el botón damos click en el icono para ver los eventos posibles, elegimos el evento Click.
Conociendo los controlesAbrimos un nuevo proyecto o retomamos el formulario anterior.
Botón de aceptar: Aceptar
CheckBox sobre el tipo de operación: Automatico
ComboBox que despliega Estados: Estados
Label que muestre lectura de corriente: Corriente
TextBox que reciba nombres: Nombre
HScrollBar para variar un setpoint: SetPoint
NumericStep para variar la edad: Edad
PictureBox con el fondo de pantalla: Fondo
btn
chk
cmb
lbl
txt
hscroll
nstep
pic
La ventaja de nombrar los controles de acuerdo a la función o variable permite una mejor comprensión del código.
Muchos controles manejan el evento Click, es importante el prefijo btn para no confundirlo.
43
Al dar doble click y entrar al editor VS nos muestra este código, observemos que no solo escribe lo referente al evento click, también agrega las directivas “using”, el “namespace”, la clase parcial del formulario y un método InitializeComponent, todo este código ahora se muestra al usuario para comprender mejor el funcionamiento interno.
¿Recuerda VB (98)?Para un ejemplo similar solo mostraba este código, en términos técnicos es lo mismo, debemos acostumbrarnos a ver solo lo que nos interesa y no confundirnos, con el tiempo toda la sintaxis nos será familiar.
VB C#Muy bien, vamos a programar un par de eventos para que ambos controles se envíen un saludo:
En el evento KeyPress del textBox1 escribimos.
44
Ejecutamos nuestro programa con:
Como podemos observar son dos métodos diferentes, el botón reacciona al evento Click y el textBox reacciona cuando se teclea cualquier cosa.
Ahora seleccionando el elegimos su evento click y escribimos Close();
Ahora para tener mas de funcionalidad agregamos otro botón y modificamos sus propiedades:
En su propiedad Name: btnSalir (el prefijo btn lo identifica como boton)
Propiedad Text: Salir
Ejecutamos el programa para probar el botón de salida
Existe otra alternativa para salir del programa como:
Ahora que conocemos lo básico de los eventos regresemos a estudiar cada control y sus propiedades.
Los eventos y propiedades del botón nos van a permitir accionar eventos y dar una atractiva interfaz a nuestros proyectos, como costumbre cada vez que nombremos a un control utilizaremos el prefijo “btn” en minúsculas seguido de la función, ejemplo: btnEncendido,
Para agregar mas realismo a nuestro botón podemos utilizar la propiedad Image, los tipos de archivo que maneja son gif, jpg, bmp, entre otros, en lo personal recomiendo el jpg si va a agregar alguna foto real del proceso, si se trata de gráficos sencillos utilizar el .gif, es importante no cargar archivos muy grandes ya que pueden hacer lento el sistema, en el libro referente a interfaces nos centraremos en imágenes vectoriales en Flash para hacer mas ligero y dinámico el monitoreo de nuestro proceso.
Como vamos a generar dos imágenes con extensión .gif en cualquier programa de diseño (recomiendo Coreldraw). Las dos imágenes vamos a incrustarlas en nuestro botón por medio del siguiente control
45
El control ImageList nos permite cargar secuencias de imágenes en nuestros controles, es muy útil para representar el estado de nuestras variables de manera gráfica, sin embargo no es un control visible en tiempo de ejecución, solo es una especie de conexión entre los controles visibles y las imágenes.
Al arrastrar el control a nuestro formulario podemos comprobar que se incrusta en la parte de abajo.
Vamos a nombrarlo imglistOnOff
Ahora nos vamos a la propiedad Images y en la colección agregamos nuestras dos imágenes con los como se muestra.
Ahora hacemos un ajuste en la propiedad ImageSize:
Ya podemos referenciar nuestro botón en su propiedad ImageList:
Por ser un botón de activación cada que el usuario lo presione nos aparece en estado Off por defecto y la propiedad ImageIndex del botón es 1.
46
Ahora con nuestro botón configurado vamos a programar un poco…Seleccionamos el botón y elegimos el evento MouseDown.
Con doble click accedemos al evento y escribimos:
Al ejecutar observamos que se cambia la imagen al presionar.
Para volver al estado anterior de la imagen, agregamos otro evento MouseUp
47
Ahora ya podemos simular un accionamiento de manera gráfica con nuestro botón.
El control TextBox será de gran utilidad para capturar datos de usuario, vamos a sacar provecho a algunos métodos implícitos que tiene para ahorrarnos tiempo.
Veamos algunas propiedades que nos serán útiles:
Multiline: Sirve para habilitar varias líneas de texto, en este libro lo aplicaremos en valores de parámetros que se ingresen por el operador o textos para algún reporte, no olvidemos que en sistemas de control el usuario captura muy poco, los valores vienen de dispositivos como sensores y actuadores.
Cuando habilitemos Multiline es conveniente utilizar la propiedad ScrollBars, de esa manera podemos escribir mas fácil sin hacer mas grande el textBox.
PasswordChar: Nos permite escribir contraseñas sin mostrar el texto escrito, por lo regular se configura con un asterisco “*”, es útil para las contraseñas de operador de ciertas partes de un sistema.
Ahora veamos un ejemplo:Imagine que diseño un programa que captura el reporte diario de los operadores del proceso, a usted le interesa conocer si se registro alguna falla, por lo tanto es natural buscar en el texto la palabra “falla”, esto se puede realizar con un sencillo método del textBox que nos permite buscar y reemplazar palabras con una sola línea de código.
Incorporamos un botón con el nombre: btnBuscar y a nuestro textBox lo nombramos txtReporte y en la propiedad text escribimos el siguiente texto.
48
En el evento Click del botón escribimos:
Al ejecutar obtenemos:
Existen otros métodos interesantes en el textBox que conoceremos mas adelante.
El control Label o “etiqueta” es básicamente para agregar letreros a nuestro programa, en este curso lo aplicaremos para títulos y mensajes.
El cuadro de lista tiene varias características interesantes, puede conectarse directamente a una base de datos y también tiene métodos de búsqueda.
Los datos de un ListBox pueden ser seleccionados pero no alterados mientras se ejecuta el programa, los “items” (elementos) se pueden agregar en tiempo de diseño mediante una colección:
Cada elemento debe ocupar una línea.
49
Los mismos datos se pueden agregar mediante este código:
Antes vamos a nombrarlo listboxUnidadesMedida y para ejecutar este código cuando se cargue nuestro programa utilizamos el evento Form_Load del formulario, para esto seleccionamos el formulario y damos doble Click.
Al ejecutar obtenemos el mismo resultado:
En nuestro curso vamos a utilizar este control para guardar historiales de alarmas y aprovechar sus métodos de búsqueda.
El control CheckBox o Casilla nos permite activar valores y mantener su estado de una manera sencilla, su propiedad Checked nos permite establecer un valor True o False y mantenerlo en el objeto, por tal motivo es importante asignar un nombre que se convierta en una variable, ejemplo: chkControlAutomatico:
Con la propiedad “appearance” convertimos la casilla en un botón que mantiene su estado presionado y es más sencillo de accionar.
El CheckBox nos será muy útil para variables que definen el estado y tiempo que dura un proceso , por ejemplo si esta activo un control automático, el muestreo de algún valor etc.
El NumericUpDown es un control muy útil para establecer rangos de números sin ocupar que el usuario los teclee, para fines de captura es más sencillo y nos ahorra tiempo en validaciones, sus propiedades Minimum y Maximun establecen los límites de valores que puede ofrecer, la propiedad Increment nos permite establecer los pasos de incremento o decremento del “Value” del control.Su evento más importante es: ValueChanged que se dispara cada vez que el usuario oprime las flechasEn nuestro curso lo aplicaremos para rangos conocidos de parámetros de alguna fórmula o configuración de dispositivos.
50
El RadioButton anteriormente llamado (option), tiene gran funcionalidad al momento de trabajar en grupo con otros de su misma clase, al momento de correr el programa C# se encarga de solo dejar uno de los objetos con un valor en “true”, para definir los grupos existen dos maneras:
Vamos a dibujar tres controles RadioButton arrastrándolos al formulario:
Ahora elegimos cualquiera de ellos y cambiamos su propiedad Checked= true.Desde el momento que son arrastrados al formulario se convierten en un grupo dependiente entre sí, podemos comprobarlo si cambiamos a otros RadioButton su propiedad Checked=true y el anterior se convertirá en False, en resumen solo uno de ellos puede tener el valor true.
¿Que pasa si ocupamos tener 2 o varios grupos?Para resolverlo tenemos el siguiente control:
El GroupBox actúa como un contenedor y nos sirve para agrupar controles especialmente el RadioButton.
Para utilizar el GroupBox debemos darle el área necesaria y arrastrar los controles en su interior.
El hecho de estar agrupados hace que solamente uno de ellos pueda tener el valor en verdadero.
El control GroupBox y los RadioButton serán muy útiles en nuestro curso para variables que solo pueden tener un valor, por ejemplo:
51
Cuando se trata de agregar imágenes a nuestra interfaz el control PictureBox es la mejor opción, acepta formatos .gif .bmp. jpg e inclusive con canal transparente .png.
Si la imagen tiene una escala mayor o menor podemos ajustar el tamaño presionando el triangulo superior derecho y la opción StrechImage.
Es importante señalar que no es conveniente agregar las imágenes en tiempo de diseño, lo mejor es hacerlo por código al momento de cargar el programa, la razón es por que el archivo ejecutable “.exe” puede quedar muy grande y no cumplir con su labor de “chispa de encendido” para el sistema.
Para agregar una imagen del disco duro utilizamos:
Es importante agregar la @ antes de la ruta para que funcione y el compilador entienda.
Existe un término en programación que debemos evitar “HardCode”, se refiere a datos fijos que se incrustan directamente en el código y se tiene que adaptar a cada máquina para que funcione, en nuestro ejemplo establecimos una ruta que puede variar dependiendo del sistema, si la PC donde se ejecuta no tiene el nombre unidad “C” por ejemplo “D” este código no funcionaría, la manera correcta es usar una ruta relativa a el lugar donde corre la aplicación, esto se logra colocando el archivo “fondo.jpg” en la carpeta bin\debug\ del nuestro sistema y modificando la instrucción:
Ahora la imagen forma parte de los archivos del sistema sin afectar el tamaño del ejecutable ya que carga por medio de código.
El control PictureBox tiene otras ventajas para realizar gráficos, mas adelante aplicaremos estas funciones.
La propiedad Image nos permite importar el archivo:
52
El ComboBox es parecido al RadioButton por contener los posibles valores que puede tener una variable con menos espacio en el formulario, por ejemplo si vamos a seleccionar un Estado de México el ComboBox es más conveniente que dibujar 32 RadioButton.
Su propiedad Items permite cargar la lista de elementos en tiempo de diseño.
Para agregar elementos por código se utilizar el método Items.Add();
El timer nos permite generar eventos periódicos con intervalos que podemos controlar, es control básico para rutinas de muestreo de datos, es un control que no se puede ver en tiempo de ejecución.Es importante cuidar el manejo de los timers si estamos buscando errores en nuestro programa, la razón es por que imposibilitan la depuración paso por paso si se encuentran activos, es recomendable solo utilizar uno y contar con algún control visible que permita deshabilitarlo.
Para entenderlo vamos a arrastrar tres elementos al formulario:
A cada uno la asignamos la propiedad Name como sigue:
También cambiamos los textos en el CheckBox y Label
timerMuestras
lblNumMuestras
chkMuestras
Activar Muestras
0
53
En la propiedad Interval del timerMuestras escribimos 1000, con esto forzamos a que cada 1000 milisegundos ósea cada segundo se genere un evento “Tick” en el Timer, aparte ponemos su propiedad Enabled = False para que se encuentre desactivado al iniciar el programa.
Lo que vamos a hacer en este ejemplo es activar un contador de tiempo, para esto ocupamos una variable con un ámbito público o global, la cual debemos declarar en la base de la clase form como se indica:
“Public static” permite que mantenga su valor en este formulario.
“int” indica que es un tipo de dato entero, entre 0 y 32767.
“numero” es el nombre que elegimos.“=0” es el valor inicial para nuestra variable número.
IMPORTANTELas variables públicas o globales solo deben declararse en casos muy especiales ya que pueden generar malos hábitos de programación.
Continuemos…Ahora damos doble click sobre el control chkMuestras y accedemos a su evento mas común: CheckedChanged.
Por último damos doble Click en el timer y accedemos a su evento “Tick” para escribir lo siguiente:
Al ejecutar obtenemos que el contador se activa mientras la casilla esta verificada:
54
Es importante cuidar el manejo de los timers si estamos buscando errores en nuestro programa, la razón es por que imposibilitan la depuración paso por paso si se encuentran activos, es recomendable solo utilizar uno y contar con algún control visible que permita deshabilitarlo.
El Timer será un control muy útil en nuestro curso, aprenderemos a utilizarlo sin provocar problemas en el depuración.
Los ScrollBar vertical y horizontal tienen las mismas funciones y propiedades, en nuestro curso los vamos a utilizar para establecer puntos de sintonía para el control, “setpoints”, sus propiedades Minimum y Maximun nos dan los rangos de su propiedad Value, a diferencia del NumStep el incremento se establece en la propiedad SmallChange y LargeChange que recomiendo tengan el mismo valor.
El control progressBar es muy útil para representar estados de avance en un proceso o el nivel de alguna variable, su propiedad “value” tiene el valor actual y para los rangos sus valores por defecto son Minimun=0, Maximum=100, los pasos o incrementos se definen por la propiedad “Step” el cual para este ejemplo vamos a mantener en 1.Para ver su funcionamiento arrastramos a nuestro formulario dos controles:
Los valores minimum para ambos son cero y maximum =100.El SmallChange y LargeChange para el HScrollBar debe ser 1.La propiedad “Step” del ProgressBar también debe ser 1.
Ahora dando doble Click sobre el HScrollBar escribimos este código en su evento Scroll.
Al ejecutar comprobamos lo sencillo que es controlar el avance de un ProgressBar.
55
El DataGridView nos permite conectarnos a una base de datos y darle un formato a la tabla sin necesidad de programar, aparte trae otras funciones para hacer consultas y organizar la información por fecha, nombre, valor, etc.
El TabControl es una especie de archivero de carpetas tipo contenedor que nos facilita la operación y diseño de nuestra interfaz, utilizando este control se pueden tener varios formularios incrustados y tener siempre a la mano el título de las secciones del sistema.
En la propiedad TabPages agregamos la colección de páginas y las propiedades individuales de cada página.
Los eventos de este control serán útiles para refrescar tablas de datos al momento de cambiar de página.
Al pulsar sobre el triangulo superior derecho accedemos a su panel de configuración, para esto ocupamos tener la base de datos lista para conectarse a nuestro control.
En nuestro curso nos va a servir para mostrar los datos guardados en la tabla de muestras.
56
El control SerialPort antes llamado “MsComm” nos permite comunicarnos por el puerto serial RS232, es un protocolo muy popular que nació en los 60's pero aún es muy utilizado en gran cantidad de aparatos industriales, médicos, etc.
Su ventaja es la sencillez de codificar el envío y recepción de información, para este curso lo vamos a implementar muestreando datos provenientes de una tarjeta con Microcontrolador y comunicándose con otras computadoras.
El puerto serial no viene en todas las tarjetas madre, la solución es usar un convertidor USB-RS232.
Propiedades focus y tabindex
Cuando un programa esta en ejecución entran en operación las propiedades Focus y tabIndex.
La propiedad Focus la define el usuario del sistema en el momento de elegir un control, por ejemplo si escribe algo en un textBox le brinda el enfoque a ese control, en resumen solamente un control puede tener el enfoque durante la ejecución de un programa.
La propiedad TabIndex se controla por la tecla “Tab” y permite dar una secuencia a la operación de los controles, cada control tiene un número donde se establece su turno con respecto al Tab, en sistemas de captura es muy práctico por que ahorra el uso del mouse para cambiar el “Focus” a otro control.
Durante este capítulo examinamos algunos de los controles mas comunes que no serán útiles en nuestro curso, los ejemplos destacaron las propiedades y eventos que mas nos interesan en cada control, recordemos que todo el libro se enfoca a prototipos prácticos y analogías útiles para sistemas de monitoreo y control electrónico.
Mensajes y cuadros de dialogo
57
En este capítulo aprenderemos las funcionalidad del MessageBox en su forma simple y como cuadro de dialogo.
El control MessageBox se aplica para dar mensajes emergentes al usuario y detener el programa en un lugar donde se requiere una decisión.
Su sintaxis es sencilla, damos doble Click en el formulario donde estamos trabajando y en el evento Form_Load escribimos:
Al ejecutar obtenemos:
Eso no es todo, el control nos ofrece mas métodos que podemos analizar si dejamos el paréntesis abierto como se muestra:
Son 21 métodos diferentes, si implementamos el 5 se puede agregar título al mensaje y un par de botones.
VB C#A diferencia de VisualBasic 98 el control MessageBox no permite configurarlo directamente para leer cadenas de texto del usuario, es decir si ocupamos agregar algún TextBox para ingresar un dato debemos implementarlo con un cuadro de dialogo.
Mensajes y cuadros de dialogoCuadros de Dialogo para introducir datos:Nos vamos al explorador de soluciones y en el proyecto que tenemos abierto vamos a agregar otro formulario de Windows.
vamos a nombrarlo frmDialogo:
Ahora nos debe aparecer con nuestro formulario inicial en la ventana de proyectos.
En el frmDialogo agregamos 4 controle :s con las siguientes propiedades
text: Nuevo SetPoint (solo un letrero)
name: txtSetPoint
name: btnAceptar, text: Aceptar, DialogResult= OK
name: btnCancelar, text: Cancelar, DialogResult= Cancel
58
59
Ahora vamos convertir nuestro formulario en un cuadro de dialogo:
Seleccionamos el frmDialogo y en su propiedad AcceptButton elegimos nuestro btnAceptar y CancelButton= btnCancelar.
En nuestro Form1.cs ocupamos un botón que nos mande llamar al cuadro de dialogo, arrastramos un y lo nombramos btnCuadroDialogo.
Ahora en el evento Click del btnCuadroDialogo escribimos:
Al ejecutar obtenemos:
Aun nos falta algo, ¿como obtenemos el valor del cuadro de texto (SetPoint)?
Acceso a controles desde otros formularios
Para esto damos doble Click sobre el formulario frmDialogo y escribimos una nueva función “TraeSetPoint”.
Con esta función de acceso público y de tipo String es posible tomar la propiedad del cuadro de texto txtSetPoint y retornarlo en la función.
60
Vamos por otro ejemplo con el control timer:En este programa vamos a simular que tenemos dos sensores de color y deseamos que el proceso se detenga cuando ambos colores sean iguales. Creamos un proyecto nuevo del tipo “formulario de windows” lo nombramos “ColoresRandom”. En nuestro formulario agregamos 2 label y 1 timer. Asignamos las siguientes propiedades “name” a los label: lblSensorA, lblSensorB. Para el timer Name: timerMuestra, Interval: 100, Enabled: true
Ahora modificamos la línea del primer mensaje y concatenamos las cadenas con la función traeSetPoint de nuestro frmDialogo.
Muy bien ya practicamos una manera de utilizar mensajes, funciones públicas, la sentencia IF y el intercambio de datos entre formularios.
Ejemplo con control Timer
61
Para simular los colores aplicaremos la función Random de C# en la cual la computadora nos manda números aleatorios de acuerdo a un rango especifico asignado en su propiedad “.Next”, es importante mencionar que no podemos predecir los valores que nos manda Random, puede tardar segundos o minutos en coincidir.
Otra función que vamos a implementar es .FromArgb(R,G,B) donde cada valor puede variar de 0 a 255 para formar los colores comunes, para hacer mas rápida la coincidencia solo vamos a controlar la gama del rojo.
En el inicio del editor adentro de la clase frmSensorColores creamos una instancia del objeto random con el nombre “coloresAleatorios”:
Color
En el evento Tick del timer tecleamos:
Bien, ahora ejecutamos :
El valor A=255 en la función “Color.FromArgb” se refiere al la propiedad Alpha, en este caso no fue utilizada.
Fin de capítulo 1
Conceptos de C#.NETIntroducción a VisualStudio
Tipos de DatosCiclos y SentenciasControles básicos
62