Rincón Matemático

Revista, Técnicas, Cursos, Problemas => Cursos del Rincón => Dictado de cursos del Rincón => Mensaje iniciado por: argentinator en 06 Enero, 2010, 08:48 pm

Título: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 06 Enero, 2010, 08:48 pm
Curso de C#

En el curso de C# que viene a continuación vamos a desarrollar la programación en C# desde cero.
Vamos a procurar que el curso le sea útil a todos los que se inscriban.
No es un curso para "torturar al pobre alumno con exámenes", sino para que todos salgamos aprendiendo lo que nos hace falta.
Aún así, algunos ejercicios puede que se les exija a los inscriptos, como para mantener la participación activa.

Las inscripciones se hacen aquí:
Inscripciones al curso de C# (http://rinconmatematico.com/foros/index.php/topic,28780.msg113163.html#msg113163).

Las consultas, comentarios y entregas de ejercicios van aquí:
Consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

En este thread se irá exponiendo el material de los sucesivos temas.
Mayormente me basaré en el libro: Visual C#: How to Program, Deitel, 2da Edicion (2005).
El temario del libro es éste:
Temario
  • 1. Introduccion a las computadoras, Internet y Visual C#
  • 2. Introduccion al IDE Visual C# 2005 Express Edition
  • 3. Introduccion a las aplicaciones C#
  • 4. Introducción a clases y objetos
  • 5. Sentencias de Control: Parte 1
  • 6. Sentencias de Control: Part3 2
  • 7. Metodos: Una mirada más profunda
  • 8. Arrays
  • 9. Clases y Objetos: Una mirada profunda
  • 10. Programación orientada a objetos: Herencia
  • 11. Polimorfismo, Interfaces y Sobrecarga de Operadores
  • 12. Manejo de Excepciones
  • 13. Conceptos GUI. Parte 1
  • 14. Conceptos GUI. Parte 2
  • 15. Multihilo
  • 16. Cadenas, Caracteres y Expresiones Regulares
  • 17. Gráficos y Multimedia
  • 18. Archivos y Flujos
  • 19. Lenguaje de Marcado Extensible (XML)
  • 20. Bases de datos, SQL y ADO.NET
  • 21. ASP.NET 2.0, Formas Web y Controles Web
  • 22.  Servicios Web
  • 23. Networking: Streams-Based Sockets and Datagrams
  • 24. Buscando y Ordenando
  • 25. Estructuras de Datos
  • 26. Genericos
  • 27. Colecciones
[cerrar]

Los capítulos 1 y 2 los vamos a hacer bien breves, porque queremos ir directamentea a lo que nos interesa, que es el lenguaje C#. En caso de que sea necesario, se pueden agregar más detalles de los capítulos 1 y 2 a medida que el curso avance.

Responsable: Argentinator
Inicio del curso: Enero 2010
Requisitos: Inscripción al curso, y cierto sentimiento de afinidad con la programación.
Duración: Por ahora está abierto.

Los que se inscriban tarde, traten de comenzar desde el principio, y no tendré inconvenientes en responder preguntas sobre asuntos más antiguos.

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 07 Enero, 2010, 02:27 am
1. Introducción a las computadoras, Internet y Visual C#

Este capítulo no lo voy a desarrollar en detalle, porque así podemos ir directo a lo que nos interesa, que es aprender a programar en C#.
En el transcurso del curso es posible que agreguemos aquí algunas notas generales.

En líneas generales, digamos que el C# es un lenguaje creado por Microsoft en el año 2000.
Está orientado al manejo de eventos, hereda la sintaxis de los potentes lenguajes C (estructurado de nivel cercano a la máquina) y C++ (superconjunto de C, orientado a objetos, de alto nivel).
También el C# tiene una amplia librería de funciones prefabricadas, muchas de las cuales son comunes a las utilizadas por el lenguaje Visual Basic (librería FCL), que también es un lenguaje desarrollado por Microsoft.

El lenguaje ha sido estandarizado en 2002, y luego ampliado por Microsoft a sucesivas versiones 2.0 y 3.0, que es la actual (2010).

Nosotros andaremos paso a paso, así que no nos preocuparemos demasiado por las diferentes versiones, hasta que sea absolutamente necesario.
El libro de Deitel en el que baso el curso corresponde a la versión 2.0, así que las ampliaciones de la versión 3.0 las estudiaremos de algún otro texto.

El lenguaje C# es multiplataforma. Esto quiere decir que los programas hechos en C# corren con los mismos resultados en todos los sistemas operativos (aunque la performance puede variar, pero esto ya no podemos controlarlo nosotros, pues depende de cada sistema).
Además, el C# permite interactuar con Internet vía el lenguaje estándar XML.
En su momento veremos esto en detalle.



Gracias a Topo23 y Mathtruco por los comentarios que siguen:

Nota: Para referise a C# verbalmente o en búsquedas en google, podemos decir o escribir "c sharp". El signo # sustituye al signo \( \sharp \) (sharp = sostenido), porque el "sharp" no es un caracter que se encuentre en los teclados corrientes. Así como "C++" significa "el lenguaje C incrementado" (una especia de humorada, ya que "++" es el operador de incremento en C), el "\( \sharp \)" evoca una nota musical medio tono más alto. Para más información podemos ver lo que dice la Wikipedia:

http://en.wikipedia.org/wiki/C_Sharp_(programming_language) (http://en.wikipedia.org/wiki/C_Sharp_(programming_language))

Dicen también que el signo "#" evoca un par de signos "++" mezclados sugiriendo que C# es una mejora sobre C++.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 07 Enero, 2010, 02:39 am
2. Introduccion al IDE Visual C# 2005 Express Edition

El libro de Deitel se apoya especialmente en el uso del editor Visual C# 2005 Express Edition para escribir los programas en C#.

La verdad es que no hace falta ningún editor especial, basta el bloc de notas, o incluso la misma línea de comandos (con el legendario comando COPY CON ...).
Sin embargo nosotros vamos a ver varias opciones de editores, y cómo aprovecharlos.
Veremos cómo trabajar con ó sin editores.

Lo importante es tener instalada en la PC la plataforma .NET, que es lo que permite que los programas C# sean interpretados y corran en el equipo.
Dicha plataforma se comunica con el sistema operativo, pero la interface con el usuario es siempre la misma. Un programa hecho en C# se compila para correr en .NET, y es .NET quien se encarga de hacer la interpretación final de las instrucciones traduciéndolas al sistema que reside debajo.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 07 Enero, 2010, 08:16 pm
Tema Anexo: Instalación de la Plataforma .NET en el sistema.

Como ya hemos dicho, los programas en C# pasan por una compilación previa a través de la plataforma .NET.
Veamos aquí cómo instalar dicha plataforma en nuestro equipo.

Instalación de .NET en el sistema operativo Windows.

Tarea obligatoria 1: A los usuarios de Windows, les dejo esta tarea obligatoria a efectuar en su equipo. En la sección de consultas (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161) tendrán que informar si pudieron o no realizar la instalación de la plataforma .NET.

Vayamos a la siguiente dirección de Internet (actualizado a enero 2010):

http://msdn.microsoft.com/en-us/netframework/default.aspx (http://msdn.microsoft.com/en-us/netframework/default.aspx)

y a continuación hacemos clic en "Install Now".
Esto nos permitirá descargar un archivo ejecutable que servirá luego para instalar la plataforma .NET en nuestro equipo.
Dependiendo de nuestro navegador, nos dará alguna opción de descarga, y cliqueamos en "Aceptar" o "Descargar", etc.
Cuando finaliza la descarga del archivo, lo buscamos dondequiera que haya bajado, y lo ejecutamos.
Sigamos todas las opciones de la instalación, y luego esperar a que finalice.

Si todo está bien, tendremos en nuestro disco duro la carpeta siguiente:

C:\WINDOWS\Microsoft.NET\Framework

En dicha carpeta se encuentran los compiladores de todas las versiones de .NET.
A la fecha (enero 2010), la última versión estable es la 3.5.
Para comprobarlo, abrimos el Explorador de Windows y buscamos la carpeta C:\WINDOWS\Microsoft.NET\Framework.
Allí han de figurar las carpetas v1.0.3705, v1.1.4322, v2.0.50727, v3.0, v3.5.

Ingresemos a la carpeta de la última versión v3.5 y echemos un vistazo.
Allí hay algunos archivos y programas.
Saltan a la vista el csc.exe y el vbc.exe.

El programa csc.exe es el c sharp compiler, o sea, compilador de c sharp.
En cada carpeta hay un compilador según la versión correspondiente.
El programa vbc.exe es el compilador para visual basic, lo cual a nosotros no nos interesará demasiado. Tan sólo tengamos en cuenta que visual basic y C# comparten muchas de sus librerías.



Pregunta: ¿Ya podemos correr cualquier programa escrito en C# en nuestro equipo?
Respuesta: Sí.

Sin embargo, las carpetas de .NET no están "visibles" desde cualquier punto del sistema.
Esto quiere decir que si invoco al compilador csc.exe, el sistema nos dirá algo como "csc no se reconoce como un comando o programa del sistema".

Esto se "podría" arreglar agregando las rutas de dichas carpetas en la variable de sistema PATH, en forma manual.
Pero nosotros no vamos a hacer esto.
Dejaremos que otro programa lo haga por nosotros... pero eso más tarde.

Por ahora, el compilador csc sólo está visible en la carpeta en donde reside.
Lo que haremos será trabajar directamente en la línea de comandos de Windows, y compilaremos los programas manualmente allí.

Claro esta que esta práctica no se recomienda, pero para iniciar nuestro camino de programación en C# nos vamos a permitir un poco de desorden.



Tarea Obligaroria 2. Crear un programa "Hola mundo" en C#.

Abrimos el programa "Bloc de notas".
Allí iniciamos la edición de un archivo de texto nuevo, y transcribimos lo siguiente:


class HelloWorld
{
   static void Main()
   {
      System.Console.WriteLine("Hola mundo!!!");
   }
}



Ahora procedemos a guardar el archivo. Hacemos clic en "Archivo", luego en "Guardar", y en la ventana que aparece "naveguemos" hasta la carpeta "Mis documentos", y una vez allí escribamos el siguiente nombre de archivo:

Holamundo.cs

No es importante el nombre que le pongamos al archivo (esto es distinto a las exigencias del lenguaje Java, por ejemplo).
Sin embargo, recomendamos poner la extensión .cs, que como habrán imaginado, significa c sharp.

Si el bloc de notas nos pone un cartel del estilo "Usted está cambiando la extensión del archivo ¿está seguro?", le respondemos que "Sí", y listo, hemos ya terminado nuestro primer programa en C#.

Ahora tenemos que hacerlo correr.
El problema es que desde donde está puesto, en la carpeta "Mis documentos", el compilador csc no está visible para el sistema.

Pasemos, pues, a la siguiente tarea.



Tarea obligatoria 3. Con ayuda del Explorador de Windows, dejemos abiertas dos ventanas, una con el contenido de la carpeta "Mis documentos" y otra con el contenido de la carpeta C:\WINDOWS\Microsoft.NET\Framework\v3.5.

Busquemos nuestro archivo recién creado Holamundo.cs en la carpeta "Mis documentos" y arrastrémoslo con el ratón hacia la carpeta C:\WINDOWS\Microsoft.NET\Framework\v3.5.

Si ahora queremos compilar nuestro programa, es probable que no podamos hacernos directamente en las ventanas del Explorador de Windows. Tendríamos que hacer alguna otra cosa...
Por ahora, vamos a lo más simple y directo.




En el futuro ya no podemos seguir ejecutando programas en la carpeta del compilador.
Debemos ser más prolijos.
Para ello, guardaremos nuestros proyectos en una carpeta destinada sólo a este fin.

Tarea obligatoria 4. Con ayuda del Explorador de Windows vamos hasta la carpeta C:\ y allí creamos una carpeta nueva con el nombre "Proyectos_C_Sharp".

Ingresemos a dicha carpeta, y creemos allí dentro otra carpeta, con el nombre "Holamundo1".
¿Por qué el "1"? Porque pronto haremos otros experimentos con el programa "hola mundo", para testear algunas variantes diferentes.
Ahora tomemos los dos archivos Holamundo.cs y Holamundo.exe y arrastrémoslos hasta el interior de la carpeta Holamundo1.



Instalación de .NET en el sistema operativo Linux y/o en otras plataformas.

Por ahora tendrán que esperarme un poco a que investigue cómo se siguen correctamente los pasos de instalación en otras plataformas.
Si alguien quiere compartir su experiencia será bienvenido.

De mi parte, deseo probar por mi propia cuenta, paso a paso las instalaciones alternativas, para poder explicarles bien cómo se hace. Tendrán que tenerme algo de paciencia.



Actividades: Hagan las tareas obligatorias 1, 2, 3 y 4, que si no me enojo.  :laugh:

Después que me cuenten cómo les ha ido, vamos a instalar algunos IDEs en el sistema.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 13 Enero, 2010, 04:31 am
Tema Anexo. Instalación de Entornos de Desarrollo Integrado.

Vamos a instalar y probar tres IDEs (Integrated Development Environment) en el sistema Windows para facilitar la edición, corrección y compilación de proyectos C#.

Han sido elegido tres programas de distribución y uso gratuito.

Estos entornos son:

Les voy a pedir que instalen los tres programas en vuestra PC para probarlos a todos.
Los primeros dos son importantes, yo diría fundamentales, y el tercero es para practicar con alguna alternativa diferente.
En las tareas abajo les explico todos los pasos.



Microsoft Visual C# Express Edition 2008 SP1 (Visual Studio 9.0): Lo bueno del Visual Studio es que está hecho por Microsoft, que es la misma empresa que ha desarrollado e impulsado la plataforma .NET y las distintas versiones de C#.
Siendo así, uno puede suponer que Visual Studio se halla armoniosamente integrado tanto a la plataforma .NET como al lenguaje C#, dando una buena experiencia de uso al programador.
Pero estos son sólo supuestos. Ya veremos cómo nos va, y daremos nuestra propia opinión.

Además, al instalar Visual Studio, el compilador csc, al que trabajosamente accedimos en la entrega anterior para ejecutar el programa Holamundo.cs, quedará accesible desde cualquier punto del sistema, y asimismo otras configuraciones se realizan automáticamente en las variables de entorno de Windows para tener pleno acceso a todas las funcionalidades de la plataforma .NET, sin tener que preocuparnos de hacer nosotros esa tarea.

Hay una versión del programa más completa, Visual Studio Professional, que es de pago, y nosotros no indagaremos allí.

MonoDevelop: Lo bueno de MonoDevelop es que es un proyecto de software de distribución y uso gratuito. Eso evita el riesgo de que a Microsoft o a alguna otra empresa se le ocurra cobrar por el uso de alguna parte de .NET o de C#,  como por ejemplo alguna colección de librerías.

El proyecto Mono también incorpora las librerías Gtk#, que sirven para implementar programas con interface gráfica (ventanitas, barras de control, menúes, íconos, etc.), lo que comunmente se conoce como aplicaciones GUI (Graphical User Interface).
Estas librerías funcionan en cualquier sistema operativo, y no están atadas a la API de Windows.

SharpDevelop: Es un IDE que corre en Windows y sirve para trabajar con varios lenguajes soportados en .NET. Su virtud es ser una alternativa gratuita al Visual Studio Professional, con algunas características adicionales.
Al parecer tiene también soporte para Mono. Ya veremos si es cierto...



En las siguientes tareas vamos a instalar y testear los IDEs.

Tarea obligatoria 1: Instalación del programa Microsoft Visual C# Express Edition 2008 SP1.


Tarea obligatoria 2: Instalación del IDE Monodevelop.

Para que el IDE de Mono pueda instalarse, se exige la previa instalación del Gtk#. Así que la instalación tiene dos partes.


Tarea obligatoria 3: Instalación del programa SharpDevelop.




Ahora tenemos que comprobar si todos estos IDEs funcionan correctamente.
Para las tareas que siguen, abramos en el explorador de Windows la carpeta en donde guardamos nuestro querido primer programa llamado Holamundo.cs.

Tarea obligatoria 4. Vamos a comprobar que el Visual Studio Express funciona correctamente.


Tarea obligatoria 5. Vamos a testear el IDE Monodevelop.


Tarea obligatoria 6. Vamos a testear finalmente el programa SharpDevelop.





Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 14 Enero, 2010, 09:18 am
3. Introduccion a las aplicaciones C#.

3.1 Introducción.

En el texto de Deitel se comienza a trabajar con aplicaciones que corren en la ventana de consola, también llamada Command Prompt (Símbolo de Sistema).

Nosotros vamos a seguir las indicaciones de este libro,
pero también vamos a agregar algo de programación GUI, al menos lo mínimo para que aparezca una ventanita más agradable que la ventana de consola.




Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 15 Enero, 2010, 12:41 am
3.2 Una aplicación simple en C#: Mostrar una línea de texto.

En esta sección Deitel introduce un programa muy similar a nuestro "Holamundo", así que obviaremos ese paso.
También explica todos los elementos básicos de un programa en C# apoyado en ese ejemplo elemental.

Por ahora no voy a entrar en la mayoría de esos detalles.
Prefiero que vayamos viéndolos a medida que hagamos programas cada vez más interesantes.

Sólo menciono rápidamente algunas cosas:

En esta entrega aprendamos a hacer dos cosas sencillas e importantes:


Lo que les voy a proponer es que hagamos lo mismo, pero de cuatro formas distintas: la primera forma será por línea de comandos, sin IDEs, a través de parámetros pasados al compilador. Las restantes tres formas, con cada uno de los tres IDEs que, si me hicieron caso, ya tienen instalados cada uno en su PC.
La tarea correspondiente a "por línea de comandos" será obligatoria, para que comprendamos que sólo el compilador csc basta para obtener el resultado deseado.
Las tareas correspondientes al "uso de IDEs" serán opcionales, porque son una mera comodidad del programador.


Tarea obligatoria 1. Escribamos en un editor de texto el siguiente programa, y guardémoslo con el nombre Bienvenido_GUI_SWF.cs, en una carpeta que tenga el nombre Bienvenido_GUI_SWF, dentro de nuestra carpeta de proyectos C:\Proyectos_C_Sharp\:


class Bienvenido_GUI_SWF
{
   static void Main( string[] args )
   {
      System.Windows.Forms.MessageBox.Show("Bienvenido al mundo de C#!" );
   }
}




Tarea obligatoria 2. Compilaremos manualmente el programa Bienvenido_GUI_SWF.cs.


Les voy a pedir que me cuenten cómo les ha ido con esto.
En mi caso, no tuve que hacer nada especial para que la ventanita del mensaje de bienvenida aparezca sin problemas. Si algo les ha fallado, avisen, y les digo cómo arreglarlo.

Tarea 3. Vamos a hacer la compilación desde el programa Visual Studio.


Tarea 4. Vamos a repetir lo mismo, usando ahora el IDE Monodevelop.


Tarea 5. Repetir lo mismo de antes, pero ahora con el SharpDevelop.


Traten de hacer un poco de todas estas cosas, y así me cuentan cómo les fue.

Sé que mostrar ese cartelito de bienvenida es una tontería, pero lo importante es que los programas compilen y corran, que todo funcione bien.

Les debo para la próxima hacer el mismo cartelito, pero con la librería GTK#.
Saludos




Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 16 Enero, 2010, 06:53 pm
3.3. Creando su aplicación sencilla en Visual C# Express.

Deitel explica en esta sección cómo usar lo básico del IDE Visual Studio.

Este tipo de cosas las voy a obviar, porque no corresponden específicamente al lenguaje C#, sino a un IDE.

Sin embargo, cabe destacar la característica de los IDEs modernos llamada IntelliSense.
Esta capacidad hace que el editor nos muestre información sobre los objetos y métodos que estamos invocando al momento de escribir código. Nos pone la lista de todos los métodos de una clase, nos informa de todas las maneras posibles de invocar un método, es decir, a través de distintas listas de parámetros, y así por el estilo.

Si esta característica nos molesta demasiado, se puede configurar en las opciones del programa.
Pero a medida que avancemos usando cada vez más herramientas, opciones y librerías, vamos a necesitar cada vez del IntelliSense.



Yo ya les he mostrado más o menos cómo se accede a las opciones básicas de cada uno de los IDEs que estamos probando.
Dejo en vuestras manos investigar todas las opciones de cada uno de ellos.

Aunque no voy a postear detalles sobre cómo se manejan los IDEs, siéntanse libres de preguntar sobre características de ellos que no entienden, o de cosas que no funcionan como se las esperan.
Yo no tengo mucha experiencia con estos IDEs, pero ya me doy bastante idea, y se parecen mucho a otros programas que he usado en la vida.
Así que pregunten lo que haga falta, que entre todos vamos a llegar a una solución.





Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 16 Enero, 2010, 11:22 pm
3.4. Modificando su aplicación sencilla.

En esta sección Deitel explica el uso de los métodos Write y WriteLine.
Estos métodos muestran texto en la consola de comandos.
Es un poco aburrido trabajar para mostrar resultados ahí, en esa ventana negra y fea.
Así que no voy a pedirles que hagan código para la consola, al menos por ahora.

Si alguna vez hacemos alguna aplicación que deba correr exclusivamente en consola, sabremos cómo hacerla.

Por ahora sólo les comento esto: el método System.Console.Write permite enviar información a la consola de comandos, dejando el cursor posicionado detrás del último caracter enviado.
Si se desea que el cursor vaya al inicio de la línea siguiente (retorno de carro y avance de línea) se debe usar el método System.Console.WriteLine.



Nuestros ejemplos de esta sección los haremos dentro de la GUI.
Para ello, abramos alguno de los IDEs y abramos el proyecto Bienvenido_GUI_SWF.
Accedemos al archivo Bienvenido_GUI_SWF.cs y lo guardamos con otro nombre (Archivo/Guardar Bienvenido_GUI_SWF.cs como...). El nuevo nombre que le pondremos será Bienvenido_GUI_SWF_2_EscChars.cs.

¿Por qué este nombre tan largo? Bueno, el sufijo Esc_Chars servirá para que en un futuro recordemos de un golpe de vista qué diablos tenía el archivo adentro, que en este caso será una práctica sobre Caracteres de Escape.

El número 2 es el número de versión del archivo.
No sólo es bueno recordar qué tenía el archivo adentro, sino también el orden en que los fuimos haciendo.

Esta nueva copia quedará guardada en la misma carpeta y el mismo proyecto que Bienvenido_GUI_SWF.cs. Puede que parezca algo desprolijo, pero por ahora es el camino más simple poner todo junto en un mismo lugar, para no estar haciendo todo el procedimiento de abrir un nuevo proyecto por cada tontería nueva que hagamos.

En un futuro aprenderemos a gestionar distintas versiones de un mismo programa en una forma más estandarizada, aprovechando las características del lenguaje C# a ese respecto.

Ahora modificamos tranquilos la nueva versión de archivo Bienvenido_GUI_SWF_2_EscChars.cs, de modo que quede así (he resaltado las líneas nuevas respecto a las que ya estaban):



class Bienvenido_GUI_SWF_2_Esc_Chars
{
   static void Main( string[] args )
   {
       System.Windows.Forms.MessageBox.Show("Bienvenido al mundo de C#!");
       System.Windows.Forms.MessageBox.Show("Probando Nueva Línea.\nFunciona?\nSí!");
       System.Windows.Forms.MessageBox.Show("Probando Tabulador.\tFunciona?\tSí!");
       System.Windows.Forms.MessageBox.Show("Probando Retorno de Carro.\rFunciona?\rSí!");
       System.Windows.Forms.MessageBox.Show("Probando Contrabarra.\\Funciona?\\Sí!");
       System.Windows.Forms.MessageBox.Show("Probando Comillas.\"Funciona?\"Sí!");
   }
}



Ejecutamos el programa (en Visual Studio es con Depurar/Iniciar sin depurar, y con Monodevelop es Ejecutar/Ejecutar).
Nos aparecerá el mismo cartelito de bienvenida de antes.
Pero ahora, haciendo clic en "Aceptar" sucesivamente, veremos cómo aparecen los cartelitos restantes.

Cada vez que deseamos enviar una frase a algún dispositivo, ventana, o lo que fuere, debemos poner una cadena de caracteres entre comillas dobles (" ... ").
Existen ciertos caracteres especiales que no pueden enviarse de forma natural, y para ello se han creado las secuencias de escape. Están pensadas para enviar un salto de línea, un tabulador, y quizá algunas cosas más.

Las secuencias de escape se indican en C# por medio del caracter de escape: \ (contrabarra ó barra invertida). Así, tenemos que:

El problema es que el caracter \ ahora lo tenemos ocupado mandando secuencias de escape, y así no podríamos enviarlo como un caracter normal.
Para poder hacer esto, se usa la secuencia de escape \\, que se encarga de imprimir en pantalla un caracter \.

Las comillas también las tenemos ocupadas haciendo de signo delimitador de las cadenas de caracteres, así que para poder enviar comillas como caracteres normales se usa la secuencia de escape \".



Asegurémonos de haber guardado los cambios al archivo anterior,
y seguidamente guardemos nuestro archivo Bienvenido_GUI_SWF_2_EscChars.cs con este otro nombre: Bienvenido_GUI_SWF_2.1_EscChars.cs.

Lo que vamos a hacer ahora es lo que muchos de ustedes están esperando: apelar a las sentencias using.
Vamos a agregar al principio del código la línea:

using System.Windows.Forms;

A las demás líneas, les quitaremos a todas el prefijo System.Windows.Forms..

Guardamos los cambios, y el resultado será lo siguiente:



using System.Windows.Forms;

class Bienvenido_GUI_SWF_2_EscChars
{
   static void Main( string[] args )
   {
       MessageBox.Show("Bienvenido al mundo de C#!");
       MessageBox.Show("Probando Nueva Línea.\nFunciona?\nSí!");
       MessageBox.Show("Probando Tabulador.\tFunciona?\tSí!");
       MessageBox.Show("Probando Retorno de Carro.\rFunciona?\rSí!");
       MessageBox.Show("Probando Contrabarra.\\Funciona?\\Sí!");
       MessageBox.Show("Probando Comillas.\"Funciona?\"Sí!");
   }
}




Al correr este programa, nos debe dar el mismo resultado que la versión anterior.

Lo que hemos hecho es indicarle al compilador que deseamos acceder directamente a todos los nombres que figuren en el espacio de nombres System.Windows.Forms, sin necesidad de poner todo el tiempo el prefijo
System.Windows.Forms. delante de cada instrucción.

Pero ahora que el panorama está más "limpio", podemos hacer una nueva versión.
Guardemos este archivo con otro nombre: Bienvenido_GUI_SWF_3_EscChars.cs.
Vamos a dejar toda la información, pero junta en un solo cartelito.
Además, al final de cada línea vamos a agregar un doble retorno de carro mediante \n\n.
Con el primer \n se logra avanzar a la línea siguiente, y con el segundo se logra poner una línea en blanco como separador.
El resultado es el siguiente:



using System.Windows.Forms;

class Bienvenido_GUI_SWF
{
   static void Main( string[] args )
   {
       MessageBox.Show("Bienvenido al mundo de C#!\n\n"  +
           "Probando Nueva Línea.\nFunciona?\nSí!\n\n"  +
           "Probando Tabulador.\tFunciona?\tSí!\n\n"  +
           "Probando Retorno de Carro.\rFunciona?\rSí!\n\n"  +
           "Probando Contrabarra.\\Funciona?\\Sí!\n\n"  +
           "Probando Comillas.\"Funciona?\"Sí!"
         );
   }
}




Notemos el uso del signo + para acomodar estéticamente bien las cadenas de texto. Sin eso, tendríamos que poner una muy larga cadena, toda ella en una sola línea, lo cual sería muy incómodo, ya que no nos cabría bien en la ventana de edición.
En cambio, sumando las cadenas como se muestra, se puede manejar el asunto con comodidad.
Notar que el operador + necesita ir "por fuera" de las cadenas, o sea, deben cerrarse y abrirse las comillas entre los sucesivos "sumandos".

Más adelante veremos justificadamente por qué las cadenas de caracteres pueden sumarse así.
Hay toda una artillería de la programación orientada a objetos detrás de ese simple acto de sumar cadenas, como se imaginarán...  ;)




Migrando nuestros programas GUI hacia GTK#.

Hasta ahora hemos venido usando la GUI del paquete System.Windows.Forms.
Aprovechemos para introducir la GUI de GTK#.

Como esta información no está en el libro de Deitel, tendremos que ir a la fuente, en la siguiente dirección de la página del Proyecto Mono:

http://www.go-mono.com/docs/ (http://www.go-mono.com/docs/)

Allí aparece a la izquierda una ventana de exploración de documentos.
Hay que hacer clic en Gnome libraries, y una vez que se abra el menú correspondiente, clic en Gtk.

También conviene que hagamos una visita al tutorial para principiantes:

http://www.mono-project.com/GtkSharpBeginnersGuide (http://www.mono-project.com/GtkSharpBeginnersGuide)

La librería a invocar se llama simplemente Gtk, y lo que deseamos hacer es poner en pantalla un cartelito, tal como hicimos antes.
Hacer esto no es tan directo como con System.Windows.Forms.

Es posible hallar una solución bastante simple, mediante el uso de Gtk.MessageDialog.
Aún así, este dichoso cartelito debe ponerse dentro de una "Ventana de aplicación", porque si no, no funciona. (A menos que alguno de ustedes sepa cómo).

Sea cual sea la verdad, aprovecharemos este escollo para ir aprendiendo algo de Ventanas de aplicación y Widgets.

Las aplicaciones GUI, como sabemos, corren en alguna ventana gráfica en la pantalla.
Hay una ventana principal asociada al programa, y nosotros tenemos que generarla con alguna sentencia C#.
Luego debemos agregar información a la ventana, y también ciertos "artilugios" como los típicos botones, listas de opciones, etiquetas, y un largo etc. Estos elementos se conocen con el nombre genérico de widgets.

Vayamos a nuestro ejemplo de aplicación:

Primero que nada, si tenemos algún proyecto abierto en el IDE, vamos a "Archivo/Cerrar solución", y guardamos los cambios pendientes si es que nos pregunta.

Abrimos un nuevo proyecto vacío con el nombre Bienvenido_GUI_GTK.
Creamos dentro del proyecto un nuevo archivo ("Proyecto/Agregar nuevo elemento...", "Archivo en blanco") y le ponemos el nombre Bienvenido_GUI_GTK.cs.

Escribamos directamente el programa y después veamos lo que hace.
En la ventana de edición del archivo transcribimos lo siguiente:



using Gtk;

class Bienvenido_GUI_GTK
{
    static void Main(string[] args)
    {
        Application.Init();

        //Crear la Ventana
        Window myWin = new Window("Bienvenidos a C# con Gtk! ");
        myWin.Resize(200, 200);

        //Crear una etiqueta y poner algún texto en ella   
        Label myLabel = new Label();
        myLabel.Text = "Bienvenidos a C#!!\n\nLinea\nTabulador\tContrabarra\\Comilla\"";

        //Agregar la etiqueta al formulario   
        myWin.Add(myLabel);

        //Mostrar todo
        myWin.ShowAll();

        //Iniciar bucle principal
        Application.Run();
    }
}



En la librería Gtk se define el objeto Application, y por eso nosotros no tenemos que definirlo.

Al llamar a Gtk.Application.Init() se prepara a la aplicación para permitir la carga de todas las ventanas de la aplicación y sus widgets. En modo de preparación, el usuario no ve ningún efecto en pantalla, y sólo se hacen los preparativos "detrás del telón" (se organiza la estructura de la aplicación sólo en memoria).

Al llamar a Gtk.Application.Run() comienza la aplicación a funcionar, (desde el punto de vista del usuario) mostrando todas las ventanas y widgets que se habían preparado.
Se crea un bucle infinito en el cual la aplicación espera órdenes del usuario, como ser, la presión de botones, la selección de un ítem, la escritura de una cadena de texto, etc.
Esto sigue así hasta que la aplicación termina. Esto en general ocurre por una orden del usuario (o haciendo CTRL-ALT-DEL  :P ).

Se ha agregado una sola ventana, la cual alberga un solo widget, que en este caso es una etiqueta con un mensaje de bienvenida, acompañado de un test de las secuencias de escape típicas.

Notemos cómo los widgets deben atarse a una ventana padre para funcionar.

Ahora bien.
Si ustedes han osado correr el programa anterior, notarán que el IDE les tira una ristra de errores.
Eso es porque hace falta agregar referencias, las de los paquetes que van a necesitarse de la librería Gtk.

Para eso, vamos al Explorador de proyectos o de soluciones, o como se llame, y a nuestro proyecto Bienvenido_GUI_GTK le agregamos la referencia gtk-sharp.
Hagamos el frustrado intento de correr el programa con este paquete ya añadido.

¡¡Veremos que sigue tirando errores !!  >:(

En vez de decirles yo cuáles son todos los paquetes necesarios, prefiero enseñarles cómo hacer para que ustedes "sepan" cuáles paquetes hay que agregar.
Vayan a la ventanita que muestra los enojosos mensajes de error.
Allí nos informa de las referencias que nos está haciendo falta agregar para que las cosas funcionen.
Nos pide que agreguemos glib-sharp y también atk-sharp.
Así que vamos de nuevo a Proyecto/Agregar referencias... y vamos agregando esos dos paquetes que faltan a las Referencias.
Con eso ya debiera ser suficiente para que nuestro programa corra.

Nota: El código que les he puesto arriba "se basa" en el tutorial de Gtk de la página del proyecto Mono que indiqué antes, pero no me funcionaba correctamente, así que puse al método Main como static.

Guardamos todo y nos vamos tranquilos a ver algo divertido en youtube.




Comentando líneas de un programa C#: En el último ejemplo, hemos puesto líneas precedidas por //. Esa doble barra diagonal significa que todo lo que figure a la derecha de ellas hasta el final de la línea es un comentario.
Esto quiere decir que el compilador de C# ignorará esas líneas, como si allí no hubiera sentencia alguna.
Esto sirve, como ya sabrán, para la documentación interna de nuestros programas.

También es posible usar comentarios multilínea, encerrándolos entre el par /* ... comentarios ... */. Por ejemplo:


/*  Ejemplo de
       varias líneas
         de comentarios
*/


Los comentarios del tipo /* ... */ se heredan del lenguaje C, y los del tipo // ... se heredan de C++.




Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 17 Enero, 2010, 07:57 pm
3.5. Formateando texto con Console.Write y Console.WriteLine.

Aunque he dicho que vamos a tratar de "no hacer aplicaciones sólo para la consola",
el tema que se desarrolla en esta sección necesita de los métodos Console.Write y Console.WriteLine, que envían información a la consola.

¿Es esto inconveniente? No lo creo.
Uno de los tópicos importantes de esta sección es el de cadenas de formato.
Esto es una de las características más antiguas de la familia de lenguajes C,C++,C#, y si aún sobrevive es porque es muy útil.
Podemos tomarlo, si queremos, como una práctica introductoria al tema más general de expresiones regulares.

Como no me gusta mucho el ejemplo del Deitel, voy a poner el mío propio.



Primero un poco de teoría.
Las funciones System.Console.Write y System.Consolo.WriteLine envían información a la consola a través de una lista de parámetros (o argumentos), el primero de los cuales es una cadena de formato.

La cadena de formato indica exactamente qué es la información que se va a enviar a la consola. Además, se usan caracteres especiales que indican características del formato de la cadena enviada.

Por ejemplo, si uno de los parámetros de la lista es un número, se puede decir cuántas cifras de ese número se desean mostrar, y si estará alineado a derecha o izquierda, con espacios extra, etc.

Para dar formato a los parámetros se hacen referencias a ellos mediante números en la cadena de formato, y mediante caracteres especiales se les transforma de alguna manera.
Veamos un ejemplo concreto, para entender toda esta jerigonza.

Creamos un proyecto vacío con el nombre Cadenas_Formato_Bañarse_en_el_rio, y dentro de él agregamos un archivo vacío con el nombre Cadenas_Formato_Bañarse_en_el_rio.cs. En este archivo, pegamos las siguientes líneas de código:



using System;

class Ba_narse_en_el_rio
{
   static void Main()
   {
     Console.Write("\n\n  No es lo mismo decir:\n\n\t\t");
     Console.Write(" 'yo me {0} en el {1}' que 'yo me {1} en el {0}'. \n\n", "río", "baño");

     Console.ReadLine();
   }
}




La primer sentencia Write es algo así como un mero título.
Observar que en vez de usar el método WriteLine para terminar la línea y pasar a una nueva línea de texto, he preferido el uso de la secuencia de escape \n en el método Write. Esto es cuestión de gustos. Yo siento que tengo más control usando Write.

A continuación viene otra sentencia Write.
La primer cadena que aparece allí es " 'yo me {0} en el {1}' que 'yo me {1} en el {0}'. \n\n". Esa es la cadena de formato.
Los siguientes parámetros se enumeran 0, 1, 2, etc.

Así, el parámetro "río" es el número 0,
y el parámetro "baño" es el número 1.

En la cadena de formato, se pone {0} para indicar el parámetro 0, luego {1} para indicar el parámetro 1, y así sucesivamente pueden también usarse {2},{3}, etc.

Estas etiquetas (por llamarlas de alguna forma) reciben el nombre de ítems de formato
Como se ve en el ejemplo, estos ítems pueden aparecer repetidos, e incluso en cualquier orden, dentro de la cadena de formato.
El ítem {0} será reemplazado por el parámetro 0,
el ítem {1} será reemplazado por el parámetro 1,
el ítem {2} será reemplazado por el parámetro 2,
y así sucesivamente.

En el ejemplo, el resultado obtenido al correr la aplicación será el siguiente:




  No es lo mismo decir:

                 'yo me río en el baño' que 'yo me baño en el río'.




Si bien las secuencias de escape pueden usarse dentro de cualquier cadena de caracteres en un programa C#, las cadenas de formato sólo son válidas en algunas funciones de la biblioteca de C#.

Guardemos el proyecto, y descansemos hasta la próxima entrega...




Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 22 Enero, 2010, 03:13 am
3.6. Otra aplicación C#: Sumando enteros.

Como siempre, haremos un poco más que lo propone Deitel en su libro.

En esta entrega haremos entrada, procesamiento y salida de datos.
Para entender claramente la mecánica, hacemos una aplicación simple en la consola.
Luego, haremos la misma aplicación, pero funcionando ya con ventanitas y controles de Windows, o sea, una aplicación GUI. Lo haremos en los dos estilos: System.Windows.Forms y Gtk#.

En general, hagamos estas apreciaciones:


Vuestra tarea consistirá en analizar los siguientes programas, copiarlos, correrlos, y ver si todo anda bien.



Aplicación aritmética para la consola.

El método que se usa en consola para recibir datos ingresados por el usuario es System.Console.ReadLine().
Al invocarlo, el usuario ingresa una cadena de caracteres, que es el resultado devuelto por el método... así que hay que convertirlo a número entero.
Esta conversión se hace, por ejemplo, con el método System.Convert.ToInt32().
La operación completa sería System.Convert.ToInt32( System.Console.ReadLine() ).
Declarando el espacio de nombres System podremos quitar los prefijos System. y aliviar un poco el aspecto de las sentencias.

Las variables se deben declarar antes de cualquier operación, y tendrán tipo int. Aquí va el código:


using System;

class Ejemplo_Aritmetica_Basica
{
   static void Main()
   {
     // --- Declaración de variables ---
     int x, y;
     int suma, resta, producto;

     // --- Ingreso de datos ---
     Console.Write("x = ?");
     x = Console.ToInt32( Console.ReadLine() );
     Console.Write("y = ?");
     y = Console.ToInt32( Console.ReadLine() );

     // --- Procesar y calcular ---
     suma = x + y;
     resta = x - y;
     producto = x * y;

     // --- Mostrar resultados ---
     Console.Write(" x+y = {0}\n x-y = {1}\n x.y = {2}\n\n", suma, resta, producto);
   }
}



Aplicación aritmética para la GUI con System.Windows.Forms.

El concepto es el mismo, sólo que ahora debemos definir objetos que permitan al usuario interactuar con una ventana de aplicación.

Primero les encargo unos preparativos:


Analicemos lo que hay que hacer, y después veamos el código al final.

Lo primero que se debe hacer es llamar al método Run.Application de la librería System.Windows.Forms.
Dicho método ejecuta el bucle de la aplicación bajo Windows, y se encarga de esperar acciones del usuario.
Se necesita crear un objeto de tipo "formulario" y "enganchárselo" al método Run.Application.
El usuario interactúa con una ventana de aplicación correspondiente a dicho formulario.

Los formularios tienen ciertas características básicas predefinidas,
que nososotros debemos invocar mediante herencia a la clase System.Windows.Forms.Form.
Una vez que hemos dado la descripción de nuestro formulario en una clase,
apenas ahí podremos ya crear un objeto de dicha clase para "atarlo" a Run.Application().

A nuestra clase-formulario le hemos dado el nombre Formulario_principal.
Al crear (instanciar) un objeto de dicha clase se invoca a su método del mismo nombre Formulario_principal(), el cual va construyendo todos los widgets que incluiremos en la aplicación.

Queremos que haya 3 widgets: una para albergar el valor de la variable x, otro para y, y un último en donde mostraremos información al usuario, incluyendo todos los resultados.

Los primeros dos serán widgets del tipo TextBox (caja-de-texto), y les pondremos los nombres caja_de_texto_x,caja_de_texto_y.
El de resultado será de tipo Label (etiqueta), y le pondremos el nombre etiqueta_resultado.

Estos objetos deben "atarse" al formulario de la aplicación.
Pero antes, es necesario crear dichos objetos.
Más aún, antes vamos a definir variables correspondientes al tipo de datos de esos objetos.

Supongamos que hemos ya creado los 3 widgets...
Antes de "atarlos" al formulario, es necesario también configurarlos un poco, para que la apariencia en la ventana sea la adecuada.

En particular, lo que vamos a hacer es que la etiqueta reaccione ante un click hecho por el usuario sobre ella. Cuando esto pase, la aplicación hará "algo", en este caso, "mostrar los resultados de los cálculos".

Para esto es menester que escribamos un método específico, en donde desarrollemos todos los cálculos que deseamos, y que se muestren además los resultados.
Este método lo hemos llamado etiqueta_resultado_Click,
y debemos "atarlo" de alguna manera al objeto etiqueta_resultado.
Esto se hace mediante System.Event_Handler (un manejador-de-eventos).

La aplicación es muy precaria en apariencia, porque se ha hecho hincapié en que su programación sea lo más simple posible.

Nótese la aparición del prefijo this. en todas partes.
Ese prefijo es una referencia a la propia clase en la que estamos "parados", en este caso, Formulario_principal.


using System;
using System.Drawing;
using System.Windows.Forms;

static class Aritmetica_con_GUI_SWF
{
    static void Main()
    {
         Application.Run(new Formulario_principal());
    }
}

public class Formulario_principal : Form
{
   // Declaración de las variables/objetos que serán widgets en la aplicación:
   private System.Windows.Forms.TextBox caja_texto_x;
   private System.Windows.Forms.TextBox caja_texto_y;
   private System.Windows.Forms.Label etiqueta_resultado;

   public Formulario_principal()
   {
      // Definiendo los widgets que irán en el formulario
      this.caja_texto_x = new System.Windows.Forms.TextBox();
      this.caja_texto_y = new System.Windows.Forms.TextBox();
      this.etiqueta_resultado = new System.Windows.Forms.Label();
   
      // Configuración inicial del widget "etiqueta_resultado"
      // Se activa "Autosize" para que se vea bien toda la información.
      // Se coloca un texto dando instrucciones. También allí se pondrán los resultados.
      // Se enlaza el evento Clic-del-ratón-en-la-etiqueta al evento etiqueta_resultado_Click.
      this.etiqueta_resultado.AutoSize = true;
      this.etiqueta_resultado.Text =
             "Ingrese valores para x e y, y luego\n click aquí para calcular resultado";
       this.etiqueta_resultado.Click += new System.EventHandler(this.etiqueta_resultado_Click);
   
       // Estas sentencias posicionan bien los widgets sin mucha complicación.
       this.caja_texto_x.Dock = System.Windows.Forms.DockStyle.Top;
       this.caja_texto_y.Dock = System.Windows.Forms.DockStyle.Top;
       this.etiqueta_resultado.Dock = System.Windows.Forms.DockStyle.Top;

       // Se pone un tamaño al formulario bastante grande para que entren sus componentes.
       this.ClientSize = new System.Drawing.Size(300, 200);
   
       // Se agregan los componentes (widgets) al formulario,
       // y en orden inverso, para que quede como queremos, sin mayor complicación.
       this.Controls.Add(this.etiqueta_resultado);
       this.Controls.Add(this.caja_texto_y);
       this.Controls.Add(this.caja_texto_x);
   }

   private void etiqueta_resultado_Click(object sender, EventArgs e)
   {
      int x = Convert.ToInt32(this.caja_texto_x.Text);
      int y = Convert.ToInt32(this.caja_texto_y.Text);
      int suma = x + y;
      int resta = x - y;
      int producto = x * y;

      this.etiqueta_resultado.Text =
            "      x = " + Convert.ToString(x) + "\n" +
            "      y = " + Convert.ToString(y) + "\n" +
            "x + y = " + Convert.ToString(suma) + "\n" +
            "x - y = " + Convert.ToString(resta) + "\n" +
            "x . y = " + Convert.ToString(producto) + "\n" +
            "\n Haga clic aquí para un nuevo recálculo.";
   }
}



Hemos puesto en color púrpura las líneas de comentarios.
Si lo desean, pueden ustedes borrar esas líneas para ver cómo queda el código limpio, sin comentarios. Se los pongo así en el spoiler:

Notemos que los cálculos se han hecho en las mismas líneas en que se hacen las declaraciones de las variables. Esto es perfectamente válido.
Se les da a las variables x, y, los valores extraídos de las cajas-de-texto,
y a las variables suma, resta, producto, se les asigna los resultados de las respectivas operaciones.

Mismo código sin comentarios

using System;
using System.Drawing;
using System.Windows.Forms;

static class Aritmetica_con_GUI_SWF
{
    static void Main()
    {
         Application.Run(new Formulario_principal());
    }
}

public class Formulario_principal : Form
{
   private System.Windows.Forms.TextBox caja_texto_x;
   private System.Windows.Forms.TextBox caja_texto_y;
   private System.Windows.Forms.Label etiqueta_resultado;

   public Formulario_principal()
   {
      this.caja_texto_x = new System.Windows.Forms.TextBox();
      this.caja_texto_y = new System.Windows.Forms.TextBox();
      this.etiqueta_resultado = new System.Windows.Forms.Label();
   
      this.etiqueta_resultado.AutoSize = true;
      this.etiqueta_resultado.Text =
             "Ingrese valores para x e y, y luego\n click aquí para calcular resultado";
       this.etiqueta_resultado.Click += new System.EventHandler(this.etiqueta_resultado_Click);
   
       this.caja_texto_x.Dock = System.Windows.Forms.DockStyle.Top;
       this.caja_texto_y.Dock = System.Windows.Forms.DockStyle.Top;
       this.etiqueta_resultado.Dock = System.Windows.Forms.DockStyle.Top;

       this.ClientSize = new System.Drawing.Size(300, 200);
   
       this.Controls.Add(this.etiqueta_resultado);
       this.Controls.Add(this.caja_texto_y);
       this.Controls.Add(this.caja_texto_x);
   }

   private void etiqueta_resultado_Click(object sender, EventArgs e)
   {
      int x = Convert.ToInt32(this.caja_texto_x.Text);
      int y = Convert.ToInt32(this.caja_texto_y.Text);
      int suma = x + y;
      int resta = x - y;
      int producto = x * y;

      this.etiqueta_resultado.Text =
            "      x = " + Convert.ToString(x) + "\n" +
            "      y = " + Convert.ToString(y) + "\n" +
            "x + y = " + Convert.ToString(suma) + "\n" +
            "x - y = " + Convert.ToString(resta) + "\n" +
            "x . y = " + Convert.ToString(producto) + "\n" +
            "\n Haga clic aquí para un nuevo recálculo.";
   }
}


[cerrar]

Observemos que tanto las variables para los widgets como los métodos del formulario, tanto el constructor Formulario_principal() como el de "reacción al click en la etiqueta", etiqueta_resultado_Click,
se deben declarar todos ellos dentro de la clase Formulario_Principal.

Cuando estudiemos más a fondo las clases y los objetos, así como los conceptos de la programación orientada a eventos y la programación GUI, comprenderemos mejor el fundamento de todo lo hecho.

Observemos también que tanto las cajas-de-texto como las etiquetas muestran exclusivamente información de tipo string, o sea, cadenas de caracteres.
Esto nos obliga a hacer una nueva conversión de tipo, pasando los resultados de tipo numérico a tipo cadena, mediante el método Convert.ToString().

Una última aclaración: para acomodar las widgets hemos usado una manera muy simple, que consiste en apilarlos lo más arriba posible de la ventana de aplicación (Top). Por ello hemos tenido que "atar" las widgets en orden inverso.



Aplicación aritmética para la GUI con Gtk#.

(Estoy teniendo problemas con la "tecnología", ando sin internet y se me queman los periféricos, ahhh!  :'(  :'(  :'( , así que les debo la versión de Gtk# para otro día.
Pueden rebuscárselas consultando los tutoriales que les puse en posts anteriores, o bien esperar a que yo haga y testee el programa, y se los pase.)




Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).
Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 24 Enero, 2010, 04:55 am
3.7. Conceptos de memoria.

De esta sección del Deitel me quedo sólo con uno de sus párrafos, en los que explica las características de una variable:

\( \bullet \) Una variable corresponde a una posición específica de la memoria de la computadora.

Las posiciones de la memoria están numeradas, pero los programadores C# no accedemos a ellas a través de esos números, cosa que sería muy engorrosa.
El acceso se hace indirectamente a través de un identificador definido por el programador.
Esto es bueno, porque así a la variable se le puede dar un nombre significativo que nos ayude en el diseño del programa. Ejemplos de identificadores: numero, x, y, edad, promedio, etc.

Las características de una variable son las siguientes:


No vamos a agregar más acerca de esta sección.
Pasemos a la siguiente.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).
Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 26 Enero, 2010, 02:38 am
3.8. Aritmética.

En esta sección Deitel introduce las operaciones aritméticas básicas en C#.
Hay toda una discusión sobre precedencia de operadores aritméticos.
Nosotros vamos a postergar estas cuestiones teóricas hasta entrar en el capitulo 4.

El libro propone hacer unos calculitos en la consola.
Lo que haremos será muy diferente a lo que propone el libro.
Vamos a desarrollar una aplicación GUI con System.Windows.Forms, que servirá para hacer operaciones aritméticas.

Más concretamente, vamos a hacer una modesta pero simpática calculadora.

Antes de lanzarnos a programar como locos, tenemos mucho trabajo previo con lápiz y papel.

\( \bullet \) Lo primero que debemos llevar a cabo es el diseño del proyecto.

Empecemos con el final: los objetivos:


(https://foro.rinconmatematico.com/index.php?action=dlattach;topic=28779.0;attach=5808)

Detalles de la calculadora:


Sobre la mecánica de los cálculos, hay varias posibilidades para construir una calculadora...
Lo que pretendemos hacer es:


Aclaración importante: los datos que usaremos para los cálculos serán números enteros. Concretamente, el tipo de los números será int.
Esto trae como consecuencia que las divisiones son "enteras", o sea, no tienen parte decimal.
Además, hay un rango limitado de valores, por lo que al poner números muy grandes podrán obtenerse resultados equivocados.
Toda especificidad técnica la postergamos a futuro...

En particular, si en los casilleros de números se colocan datos que no son números enteros, el programa terminará abruptamente con algún error.

Vamos a los detalles de la implementación.

El lenguaje C# trabaja con clases. Todo debe hacerse a través de una clase.
En particular, debe haber una clase donde resida el método Main, que es el punto de entrada del programa, o sea, el lugar donde el programa comienza a ejecutarse.
Allí pondremos una sola línea, que consistirá en una llamada al método que inicia la ventana de la aplicación para Windows, nuestro ya conocido Application.Run().

Click para ver código

static class VS0308GUISWF_Calculadora
{
  static void Main()
  {
      Application.Run( new Formulario_principal() );
  }
}


(El nombre VS0308GUISWF_Calculadora significa: "aplicación realizada en Visual Studio, captiulo 3, sección 8, GUI con System.Windows.Forms, Calculadora")
[cerrar]

Claro que, para llamar a ese método, hace falta haber definido una clase "formulario", que es una derivada de la clase System.Windows.Forms.Form.
En esa clase hay un método de "arranque", el constructor del mismo nombre de la clase del formulario. Allí pondremos todas las inicializaciones de los widgets de nuestra aplicación.

En el resto de la clase del formulario vamos a poner las declaraciones de unas variables internas de la clase, entre las que habrá variables para albergar los widgets y variables para efectuar las operaciones de la calculadora.
También escribiremos los métodos del formulario. Entre ellos los hay de dos tipos: los que corresponden a una "reacción" ante un evento en un widget (por ahora, simplemente hacer clic en un botón o una etiqueta), y métodos para manejar las operaciones de la calculadora.

Nuestra clase para el formulario se llamará Formulario_principal.
Veamos las declaraciones de las variables que albergarán los widgets:

Click para ver código

public class Formulario_principal : Form
{
     // ..............

    private TextBox caja_texto_a;
    private TextBox caja_texto_b;
    private TextBox caja_texto_c;
    private TextBox caja_texto_d;
    private TextBox caja_texto_e;
    private TextBox caja_texto_f;
    private TextBox caja_texto_z;
    private Label etiqueta_a;
    private Label etiqueta_b;
    private Label etiqueta_c;
    private Label etiqueta_d;
    private Label etiqueta_e;
    private Label etiqueta_f;
    private Label etiqueta_z;
    private Button boton_mas;
    private Button boton_menos;
    private Button boton_por;
    private Button boton_sobre;
    private Button boton_resto;
    private Button boton_igual;
    private Label informacion;
    private Label ayuda;
    private Button borrar_todo;
    private Button terminar_programa;

    // ........................
}



La palabra private se usa para encapsular los datos, esto es, para que las variables allí declaradas no sean visibles ni accesibles desde otras partes del programa.
Toda manipulación de esas variables deberá hacerse desde dentro de la clase Formulario_principal.

Los tipos de datos TextBox, Label, Button, son clases que están definidas en el espacio de nombres System.Windows.Forms.
La manera exacta de invocar a Label, por ejemplo, sería escribiendo System.Windows.Forms.Label.
Para evitarnos todo ese prefijo tan largo, basta que indiquemos al principio de nuestro programa que vamos a usar ese espacio de nombres, mediante una sentencia using:

using System.Windows.Forms;


[cerrar]

\( \bullet \) Si bien las variables que albergarán los widgets han sido declaradas... tienen un valor nulo aún. Se les debe adjudicar un objeto de la clase a la que cada uno pertenece. Ese objeto debe crearse mediante una sentencia new.

En el método constructor Formulario_principal() vamos a agregar las inicializaciones de todos esos widgets, empezando por las creaciones de los objetos correspondientes:

Click para ver código

public class Formulario_principal : Form
{
     // ..............

    public Formulario_principal()
    {
        // .........................

        this.caja_texto_a = new TextBox();
        this.caja_texto_b = new TextBox();
        this.caja_texto_c = new TextBox();
        this.caja_texto_d = new TextBox();
        this.caja_texto_e = new TextBox();
        this.caja_texto_f = new TextBox();
        this.caja_texto_z = new TextBox();
        this.etiqueta_a = new Label();
        this.etiqueta_b = new Label();
        this.etiqueta_c = new Label();
        this.etiqueta_d = new Label();
        this.etiqueta_e = new Label();
        this.etiqueta_f = new Label();
        this.etiqueta_z = new Label();
        this.boton_mas = new Button();
        this.boton_menos = new Button();
        this.boton_por = new Button();
        this.boton_sobre = new Button();
        this.boton_resto = new Button();
        this.boton_igual = new Button();
        this.informacion = new Label();
        this.ayuda = new Label();
        this.borrar_todo = new Button();
        this.terminar_programa = new Button();

        // .....................
   }
}

[cerrar]

Ahora que los objetos ya han sido creados, podemos configurarlos.
Para ello se les debe dar valores a los atributos de cada objeto.

Aquí van las inicializaciones:

Click para ver código

        //  .......................

        // Ancho en pixels de los widgets

        this.caja_texto_a.Width = 45;
        this.caja_texto_b.Width = 45;
        this.caja_texto_c.Width = 45;
        this.caja_texto_d.Width = 45;
        this.caja_texto_e.Width = 45;
        this.caja_texto_f.Width = 45;
        this.caja_texto_z.Width = 145;
        this.etiqueta_a.Width = 45;
        this.etiqueta_b.Width = 45;
        this.etiqueta_c.Width = 45;
        this.etiqueta_d.Width = 45;
        this.etiqueta_e.Width = 45;
        this.etiqueta_f.Width = 45;
        this.etiqueta_z.Width = 145;
        this.boton_mas.Width = 30;
        this.boton_menos.Width = 30;
        this.boton_por.Width = 30;
        this.boton_sobre.Width = 30;
        this.boton_resto.Width = 30;
        this.boton_igual.Width = 50;
        this.informacion.Width = 200;
        this.ayuda.Width = 400;
        this.ayuda.Height = 100;
        this.borrar_todo.Width = 200;
        this.terminar_programa.Width = 200;

        // Posición esquina sup. izq. widgets respecto formulario

        this.caja_texto_a.Location = new System.Drawing.Point(0,0);
        this.caja_texto_b.Location = new System.Drawing.Point(50, 0);
        this.caja_texto_c.Location = new System.Drawing.Point(100, 0);
        this.caja_texto_d.Location = new System.Drawing.Point(150, 0);
        this.caja_texto_e.Location = new System.Drawing.Point(200, 0);
        this.caja_texto_f.Location = new System.Drawing.Point(250, 0);
        this.caja_texto_z.Location = new System.Drawing.Point(0, 100);
        this.etiqueta_a.Location = new System.Drawing.Point(0, 20);
        this.etiqueta_b.Location = new System.Drawing.Point(50, 20);
        this.etiqueta_c.Location = new System.Drawing.Point(100, 20);
        this.etiqueta_d.Location = new System.Drawing.Point(150, 20);
        this.etiqueta_e.Location = new System.Drawing.Point(200, 20);
        this.etiqueta_f.Location = new System.Drawing.Point(250, 20);
        this.etiqueta_z.Location = new System.Drawing.Point(0, 120);
        this.boton_mas.Location = new System.Drawing.Point(100, 50);
        this.boton_menos.Location = new System.Drawing.Point(130, 50);
        this.boton_por.Location = new System.Drawing.Point(160, 50);
        this.boton_sobre.Location = new System.Drawing.Point(190, 50);
        this.boton_resto.Location = new System.Drawing.Point(220, 50);
        this.boton_igual.Location = new System.Drawing.Point(250, 50);
        this.informacion.Location = new System.Drawing.Point(0, 80);
        this.ayuda.Location = new System.Drawing.Point(0, 150);
        this.borrar_todo.Location = new System.Drawing.Point(0, 250);
        this.terminar_programa.Location = new System.Drawing.Point(0, 300);

       //  ......

[cerrar]

Mediante una sentencia using podríamos aliviar el uso excesivo del prefijo System.Drawing., pero no vamos a hacer esto...

Los espacios de nombres sirven para no mezclar identificadores definidos en contextos diferentes, a fin de tener orden y disponibilidad de identificadores.
Buscar el "alivio" a través de using atenta contra este orden.
Tratemos de no abusar de la sentencia using, llamando tan sólo a los espacios de nombres más corrientes en nuestras aplicaciones.

Los casilleros numéricos de nuestra calculadora contendrán inicialmente el valor "0".
Las etiquetas contendrán la información que les corresponde, así como los botones.
Esto lo inicializamos así:

Click para ver código

        // .............................

        this.caja_texto_a.Text = "0";
        this.caja_texto_b.Text = "0";
        this.caja_texto_c.Text = "0";
        this.caja_texto_d.Text = "0";
        this.caja_texto_e.Text = "0";
        this.caja_texto_f.Text = "0";
        this.caja_texto_z.Text = "0";
        this.etiqueta_a.Text = "a";
        this.etiqueta_b.Text = "b";
        this.etiqueta_c.Text = "c";
        this.etiqueta_d.Text = "d";
        this.etiqueta_e.Text = "e";
        this.etiqueta_f.Text = "f";
        this.etiqueta_z.Text = "z (resultado)";
        this.boton_mas.Text = "+";
        this.boton_menos.Text = "-";
        this.boton_por.Text = "*";
        this.boton_sobre.Text = "/";
        this.boton_resto.Text = "%";
        this.boton_igual.Text = "=";
        this.informacion.Text = "Programa iniciado";
        this.ayuda.Text = "(aquí irá texto de ayuda de uso del programa)"
        this.borrar_todo.Text = "Click aquí para borrar datos";
        this.terminar_programa.Text = "Click aquí para terminar programa";

       // ...................

[cerrar]

Tenemos que "atar" las etiquetas y botones a acciones que respondan al "click" del usuario final de nuestro programa.
Esto se hace mediante una llamada a EventHandler.
Por ahora no entramos en más detalles, y lo usamos tal como figura en el siguiente código, sin preguntar por las cosas extrañas que aparecen en las líneas (observar el uso de +=):

Click para ver código

        // .................

        this.etiqueta_a.Click += new EventHandler(this.Elegir_Casillero_a);
        this.etiqueta_b.Click += new EventHandler(this.Elegir_Casillero_b);
        this.etiqueta_c.Click += new EventHandler(this.Elegir_Casillero_c);
        this.etiqueta_d.Click += new EventHandler(this.Elegir_Casillero_d);
        this.etiqueta_e.Click += new EventHandler(this.Elegir_Casillero_e);
        this.etiqueta_f.Click += new EventHandler(this.Elegir_Casillero_f);
        this.boton_mas.Click += new EventHandler(this.Elegir_Operacion_mas);
        this.boton_menos.Click += new EventHandler(this.Elegir_Operacion_menos);
        this.boton_por.Click += new EventHandler(this.Elegir_Operacion_por);
        this.boton_sobre.Click += new EventHandler(this.Elegir_Operacion_sobre);
        this.boton_resto.Click += new EventHandler(this.Elegir_Operacion_resto);
        this.boton_igual.Click += new EventHandler(this.boton_igual_Click);
        this.ayuda.Click += new EventHandler(this.ayuda_Click);
        this.borrar_todo.Click += new EventHandler(this.borrar_todo_Click);
        this.terminar_programa.Click += new EventHandler(this.terminar_programa_Click);

        // ..................



Hemos hecho referencia a una larga lista de métodos.
A todos ellos tendremos que definirlos más adelante...

[cerrar]

Ahora especificamos el tamaño de la ventana de la aplicación:

        this.ClientSize = new System.Drawing.Size(400, 400);


Y por último, ya que tenemos configurados todos los widgets, los "atamos" finalmente al formulario para que aparezcan en la ventana de la aplicación:

Click para ver código

        //  .....................

        this.Controls.Add(this.caja_texto_a);
        this.Controls.Add(this.caja_texto_b);
        this.Controls.Add(this.caja_texto_c);
        this.Controls.Add(this.caja_texto_d);
        this.Controls.Add(this.caja_texto_e);
        this.Controls.Add(this.caja_texto_f);
        this.Controls.Add(this.caja_texto_z);
        this.Controls.Add(this.etiqueta_a);
        this.Controls.Add(this.etiqueta_b);
        this.Controls.Add(this.etiqueta_c);
        this.Controls.Add(this.etiqueta_d);
        this.Controls.Add(this.etiqueta_e);
        this.Controls.Add(this.etiqueta_f);
        this.Controls.Add(this.etiqueta_z);
        this.Controls.Add(this.boton_mas);
        this.Controls.Add(this.boton_menos);
        this.Controls.Add(this.boton_por);
        this.Controls.Add(this.boton_sobre);
        this.Controls.Add(this.boton_resto);
        this.Controls.Add(this.boton_igual);
        this.Controls.Add(this.informacion);
        this.Controls.Add(this.ayuda);
        this.Controls.Add(this.borrar_todo);
        this.Controls.Add(this.terminar_programa);

       //  .........................
[cerrar]

Hemos definido la interface gráfica de la aplicación.
Ahora vamos a agregar la parte operativa.
Les aviso que va a quedar feo... pero simple.
Al final haremos una autocrítica.
Por ahora vayamos a los hechos: que la aplicación funcione.

(El desarrollo de esto continúa en el post siguiente)



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).
Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 28 Enero, 2010, 06:31 am
Proyecto: Calculadora (continuación).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 28 Enero, 2010, 11:55 pm
Proyecto: "La otra" calculadora.

No he tenido noticias vuestras desde la última entrega en que les presenté el ejemplo de la calculadora.
Si no se entendió, o ante cualquier problema que hayan tenido, avísenme.

Para no quitarles la diversión, les propongo un ejercicio similar al programa que hice yo, aunque de comportamiento un poco diferente. Se trata de llevar a cabo una calculadora común y corriente.

El programa tiene que tener botones que simulen los botones de una calculadora, y permitir la entrada de dígitos uno a uno.
Los datos que se van ingresando tienen que aparecer en un visor, que si quieren pueden implementarlo con una simple etiqueta informativa que va mostrando los dígitos y las operaciones.
Al final tiene que mostrar la operación y el resultado.
Tiene que tener un botón para borrar todo, y otro botón para salir del programa.

Todo esto hagámoslo con la GUI de la librería System.Windows.Forms.

Los pasos preliminares son: abrir en Visual Studio un proyecto nuevo vacío, agregarle luego un archivo de código, y también agregarle al proyecto las referencias necesarias para que funcione la parte visual, que serían: System, System.Drawing, System.Windows.Forms.

Luego editamos el archivo de código, imitando la técnica empleada en el ejemplo que yo les dí.
Es simplemente agregar especificaciones, una tras otra: ancho (Width), alto (Height), posición (Location), texto (Text), y eventos asociados (EventHandler).

Finalmente, tenemos que concretar la lógica de los eventos del programa, de manera que el efecto visual para el usuario sea el correcto, y las operaciones aritméticas sean también correctas.

En cuando al punto decimal, les voy a pedir que sólo programen en principio el aspecto visual, o sea, mostrarlo, pero que su evento asociado no haga nada.
O sea que seguiremos trabajando sólo con números enteros, para facilitar un poco el tratamiento.

El aspecto visual del programa puede ser algo como esto, como para que tengan una idea de lo que les estoy pidiendo:

(https://foro.rinconmatematico.com/index.php?action=dlattach;topic=28779.0;attach=5814)

A lo mejor es un error de mi parte pedirles que inicien con ejemplos que usen interface gráfica, porque pedagógicamente hay muchas sutilezas para el principiante: el uso del prefijo this, el uso de una cosa extraña como el método  EventHandler, y la permanente transformación de datos de tipo string a numérico y viceversa.

Pero tengan en cuenta que esto no es un libro plano en el cual ustedes estudian solos.
Tenemos la posibilidad de tener una experiencia interactiva, e intercambiar impresiones.
Por eso, si de pronto no entienden nada de lo que digo, avísenme, ya sea para que yo mejore mi exposición, o para que ustedes se den cuenta que algo que parecía difuso era en verdad algo simple.

Así que traten de hacer el programita, háganme preguntas, intercambiemos opiniones.
Es necesario que lo hagamos para que podamos aprender bien todas las sutilezas.
Si no, seguro que siempre se escapa algo.



Por una cuestión del orden en los contenidos, quise posponer la explicación del objeto sender en los manejadores de eventos.
Pero vi que, por ejemplo, flashtk lo ha usado en su código.
Así que si alguno de ustedes desea utilizarlo, por mí está bien.
Si alguno no sabe cómo usarlo, y desea incluirlo de todos modos, me avisa y se lo explico un poco.

A grandes rasgos el objeto sender permite hacer referencia al objeto (en este caso un widget) [desde el cual se hizo la llamada al  evento.
De esta manera, con un solo manejador se pueden tratar varios eventos similares o relacionados, con un código mucho más claro y breve, y sin los recovecos que tuve que usar... tan sólo para evitar el uso de sender.

En cuanto ahondemos en los objetos y las clases, el significado de sender se hará totalmente claro.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).


Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 29 Enero, 2010, 03:44 am
(Reservado para completar trabajos previos)
Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 29 Enero, 2010, 07:50 am
3.9. Toma de decisiones. Operadores de Igualdad y Relacionales.

En programación es muy común tomar diferentes caminos en un algoritmo, según el valor de cierta cierta condición. En C# se usan las sentencias if para este propósito. Veamos cómo funciona.

El esquema sería así: deseamos evaluar una condición "test", que sólo puede ser verdadera o falsa.
Si la condición es verdadera, se ejecuta una determinada serie de instrucciones.
Si la condición es falsa, se ejecuta otra serie de instrucciones distinta.
El formato sería éste:


   if ( test )
      {
          instrucciones del caso verdadero
      }
      else
      {
          instrucciones del caso falso
      }



Por ejemplo, podríamos querer informar si cierto número es par.
Para eso preguntamos si el resto de la división por 2 es igual a 0:



     int numero;

     Console.Write("Escriba un número entero:");
     numero = Convert.ToInt32( Console.ReadLine() );
       
     if ( numero % 2 == 0 )
      {
          Console.WriteLine("El número {0} es PAR.", numero);
      }
      else
      {
          Console.WriteLine("El número {0} es IMPAR.", numero);
      }



También es posible omitir la parte else.

Aquellos que están habituados a la programación, esperan que haya sentencias de este tipo en un lenguaje dado.

Resta ver cuáles son los operadores de comparación.
Ante todo, digamos que, en general, un operador de comparación pone a prueba un par de objetos, y da como resultado un valor que sólo puede ser verdadero o falso.
El tipo de datos correspondiente a estos valores se llama booleano, y en C# se indica con bool.
Los valores que puede tomar son true (verdadero) y false (falso).
Pueden declararse variables de tipo bool, y dárseles valores.

Los operadores de comparación son seis:

Por ejemplo, la comparación 5 <= 17 daría como resultado el valor booleano true, y la comparación -3 > 1 daría como resultado false.

En los ejemplos de las calculadoras hemos usado sentencias if,
sin haberlas explicado demasiado.
Confié en que se iban a entender... si no es así, me avisan.



Otra sentencia que permite seleccionar entre varias opciones y distintos caminos es switch, la cual he usado en el ejemplo de la calculadora.



No quiero ahondar demasiado en la teoría de esto, hasta entrar en aguas más profundas.

Deseo simplemente llegar al final de este capítulo, y que se entiendan las cosas más básicas, las cuales repetiremos y usaremos una y otra vez en todos los capítulos siguientes.
Mi intención es que perdamos el miedo a la programación GUI, que sepamos poner widgets en la ventana de una aplicación, que aprendamos a conectar eventos a tareas, y que tengamos en cuenta aspectos muy, pero que muy básicos del lenguaje: la posibilidad de realizar operaciones aritméticas, la existencia de datos de tipo string y bool, y que sepamos que contamos con los operadores de comparación, que han de existir en todo lenguaje.

Todo será profundizado y tratado en detalle a partir del próximo capítulo, que iniciaremos apenas un par de posts más adelante.
Tan sólo les pido que NO SE QUEDEN CON DUDAS. Comenten, pregunten, critiquen.

Cuando puse los ejemplos de las calculadoras, vi que aún tratando de mantener la simplicidad, aparecían complicaciones.
Pero no quiero quitar esos ejemplos, porque pienso que aún sin los conocimientos suficientes todo programador está capacitado para comprenderlos, aún si se considera a sí mismo un novato.

Una vez que tomemos confianza en el funcionamiento de todo lo explicado hasta aquí, tendremos una grata experiencia en el aprendizaje del lenguaje C#, porque la gran mayoría de nuestros ejercicios y ejemplos usarán una interface GUI, que si no, la consola de comandos es muy fea y antipática.

¿Les parece bien eso?

Así que no se me vayan a asustar.  :o  :o  :o

En los capítulos que siguen vamos a usar herramientas mínimas de la programación GUI, muy parecidas a las que les he mostrado hasta ahora. O sea, una interface gráfica básica y modesta, y así podremos concentrarnos en las cuestiones más internas y profundas del lenguaje C#.

También planeo que estudiemos y/o repasemos técnicas de programación eficiente, algoritmos, etc.
Todo con cuidado y paciencia, y asimismo habrá bastante material optativo (eso creo), de modo que cada cual se oriente hacia donde mejor le parezca.




En el siguiente post tan sólo voy a agregar algunos ejemplos y ejercicios más, para reforzar las cosas que hemos visto hasta aquí del material que corresponde al capítulo 3, más el plus de los rudimentos de la programación GUI.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 31 Enero, 2010, 10:25 pm
Proyectos de práctica para el capítulo 3.

A lo mejor les he complicado la vida con las "calculadoras".
Aquí les dejo un proyecto algo más fácil de programar, aunque sigue teniendo interface gráfica.
De paso, podrán practicar las sentencias if.

Proyecto "Adivina Número".

El programa tiene el siguiente aspecto visual:

(https://foro.rinconmatematico.com/index.php?action=dlattach;topic=28779.0;attach=5836)

Lo que tienen que hacer es lo siguiente:


Para elegir un número al azar, se usará un objeto de tipo Random, así:

Random Generador_Aleatorio = new Random();

Supongamos que el número que el programa oculta se guarda en la variable:

int numero_oculto;

Luego, cada vez que se desea generar un número al azar entre 0 y 99 se escribe la sentencia:

this.numero_oculto = this.Generador_Aleatorio(100);

Al presionar el botón "Apostar!", se debe invocar un método asociado, que resuelva si el número elegido por el usuario está cerca del que está oculto.
Para ello se debe calcular la "distancia" entre ambos números (el valor absoluto de la diferencia).
El valor absoluto se obtiene con la función Math.Abs.

A continuación se usan sentencias if para determinar "a cuánta distancia" está el valor propuesto por el usuario del número oculto.
Vamos a estipular que si la distancia es mayor que 15, entonces se da la pista "Frío".
Si la distancia está entre 8 y 14, se dará la pista "Tibio".
Si la distancia está entre 3 y 7, se dará la pista "Caliente".
Si la distancia está entre 1 y 2, se dará la pista "Muy Caliente".
Si la distancia es 0, se mostrará el mensaje: "Acertaste! Felicitaciones!".

Estas pistas y mensajes se muestran con un simple cartel, usando MessageBox.Show, por ejemplo:


        if (distancia > 15)
            MessageBox.Show("Frío... sigue buscando!!");


Y así por el estilo.

Los dejo con la inquietud.
La técnica que les sugiero es "imitar" lo que ya les he enseñado.
No se compliquen mucho la cabeza, y sólo busquen que el programa funcione.
La lógica interna no tiene que ser maravillosa.
Ya tendremos ocasión de pulir nuestras técnicas de programación.
Ahora sólo estamos echando un vistazo de lo básico en la programación GUI, junto con otras herramientas de uso común, a las que debemos acostumbrarnos.

Esta vez los "manejadores de eventos" son métodos muy sencillos, y no hay nada rebuscado.

Aún así: pregunten todas sus dudas e informen de sus problemas, que seguramente los tendrán.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).

Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 01 Febrero, 2010, 01:23 am
Proyectos de práctica para el capítulo 3 (continuación).

Proyecto "Ta te ti".

El programa tiene el siguiente aspecto visual:

(https://foro.rinconmatematico.com/index.php?action=dlattach;topic=28779.0;attach=5838)

Este ejercicio es más bien un desafío: hacer un juego de 3 en raya para dos jugadores.
Este programa se puede hacer con las herramientas que conocemos hasta este momento, pero aún así es muy probable que necesiten ayuda para hacerlo en forma sencilla... y que funcione bien.

Aquí les explico los detalles.

Cada casillero será un botón.
Cada vez que se presiona un botón, se considera que el turno pasa automáticamente al otro jugador, alternativamente.
Los jugadores son "O" y "X".

Siempre inicia el jugador "O"

Al principio los casilleros están vacíos, y a medida que los jugadores van marcando las casillas, se les cambia el atributo "Text" para que refleje que allí hay una "O" o una "X".

Si una casilla ya está marcada, no permitir que se sobreescriba en ella.

En este ejemplo es bueno usar el objeto "sender" cuando se llama al método que maneja el evento de apretar un botón/casilla.

Allí conviene definir una variable interna que haga referencia al "botón que ha sido presionado".
Esto se hace con esta línea:

Button casilla_tocada = (Button) sender;

No pregunten demasiado por qué eso es así, ya lo veremos en el próximo capítulo.

Ahora podemos hacer cosas como escribir una "O" o una "X" en la casilla:

casilla_tocada.Text = "X";

Internamente, los jugadores tienen los números 1 y 2.
Las casillas sin marcar tendrían el valor 0...

A los botones les he puesto nombres de la rosa de los vientos:

    private Button boton_NW;
    private Button boton_N;
    private Button boton_NE;
    private Button boton_E;
    private Button boton_SE;
    private Button boton_S;
    private Button boton_SW;
    private Button boton_W;
    private Button boton_Centro;


He definido una función que convierte los símbolos "O" y "X" a los números 1 y 2:



    private int nj(string s)
    {
        if (s == "O")
            return 1;
        else if (s == "X")
            return 2;
        else
            return 0;
    }




He usado esa función para calcular el número de jugador asociado  a cada una de las 9 casillas del tablero de tateti.
Por ejemplo:



        int j_NW = this.nj(this.boton_NW.Text);
        int j_N = this.nj(this.boton_N.Text);
        int j_NE = this.nj(this.boton_NE.Text);
        int j_W = this.nj(this.boton_W.Text);
        int j_Centro = this.nj(this.boton_Centro.Text);
        int j_E = this.nj(this.boton_E.Text);
        int j_SW = this.nj(this.boton_SW.Text);
        int j_S = this.nj(this.boton_S.Text);
        int j_SE = this.nj(this.boton_SE.Text);



Estos números los he usado para calcular "valores asociados a las 8 líneas del tablero".
Esas 8 líneas son las 3 horizontales, las 3 verticales y las 2 diagonales.

He usado el razonamiento siguiente, para simplificar el análisis de una determinada posición:

* En una línea hay sólo "O" si y sólo si el jugador 1 ocupa cada casilla de esa línea, y esto es equivalente a que el producto de los valores de esa línea es igual a 1.

* En una línea hay sólo "X" si y sólo si el jugador 2 ocupa cada casilla de esa línea, y esto es equivalente a que el producto de los valores de esa línea es igual a 8.

* Si el producto de los valores de una línea es distinto de 1 o de 8, entonces no hay 3 en raya en esa línea.

Por ejemplo:

        int linea_h_superior = j_NW * j_N * j_NE;

Y luego vendría algo como esto:


        int ganador;

        if (linea_h_superior == 8)
            ganador = 2;


Hay todo un método que se llama Verificar_Ganador(), en el que se hacen todas esas cuentas y consideraciones, y se detemina cuál de los dos jugadores es el ganador, o bien se pone ganador = 0 cuando no hay ganador aún.

En otras partes del programa hay que verificar empates, o dar otro tipo de información.

Varios mensajes pueden darse con MessageBox.Show().

No duden en preguntar cuando la cosa se complique.
Los programas tienen que salir, se tienen que ver bien, tienen que funcionar, y no tienen que tener fallas. Así que insistan hasta que esto se consiga, y también insistanme a mí con las preguntas.


Los programas que propongo como ejercicios primero los resuelvo, y sólo después se los pongo a ustedes como problemas a resolver. O sea que les pongo problemas que pueden resolverse con las herramientas que manejamos hasta ahora. Y además quiere decir que ya he visto las posibles fuentes de errores y fallas del código, y por ende pueden preguntarme.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).


Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 15 Febrero, 2010, 03:18 am
Tutorial GUI con SWF para el capítulo 3.

No sé si los habré asustado o qué con la programación GUI.
Así que se me ocurrió que lo mejor es hacer un tutorial antes de seguir avanzando.
Por ahora este tutorial estará aquí al final del capítulo 3, pero una vez que hayan pasado algunas semanas y los participantes lo hayan puesto en práctica, lo colocaré intercalado antes de los ejemplos de práctica de calculadoras y demás...

Vida y obra de un botón.

Ese sería el título de un cuento que verse sobre cómo se construye un botón en una aplicación con interfase gráfica.
Pero haremos algunas cosas más, no sólo botones.

Este tutorial tiene los siguientes objetivos:


Vamos a establecer una clave de colores para los códigos que pongamos de aquí en adelante.
En general, un código de un programar estará en color marrón.
Sin embargo, aquellas porciones de código que vayamos agregando para modificar versiones previas del programa, las indicaremos en azul, para poder distinguir bien la parte nueva agregada de la que ya estaba antes.



Nuestro primer objetivo es hacer una aplicación de ventana vacía, como esta:

(https://foro.rinconmatematico.com/index.php?action=dlattach;topic=28779.0;attach=5907)

Los pasos a seguir son los siguientes:




A continuación, veremos cómo agregar un botón y que reaccione al hacer click sobre él.



Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).
Título: Re: Dictado del Curso de C# (Deitel)
Publicado por: argentinator en 15 Febrero, 2010, 07:55 am
Tutorial GUI con SWF para el capítulo 3 (parte 2).

Siempre que llovió paró.

Todo programa que comienza, tiene que terminar.
Esa es la gran ley de la programación.
Si no, es que el programa está mal hecho.

Lo que haremos será continuar con el programa del post anterior, y le iremos agregando cosas.
Lo primero que deseamos es ponerle un sencillo botón que permita salir del programa normalmente con un click del usuario.

Ése será nuestro objetivo. Ocurre que no es tan simple como uno quisiera.
Pero una vez que lo pongamos en práctica veremos que es muy sencillo a fuerza de acostumbrarnos a hacer siempre lo mismo.

Los pasos necesarios para poner un botón en la ventana de nuestra aplicación son los siguientes:




A continuación, agregaremos más información y funcionalidades a nuestro programa, así como etiquetas informativas.




Clic aquí para consultas y comentarios del curso de C# (http://rinconmatematico.com/foros/index.php/topic,28778.msg113161.html#msg113161).