15/12/2018, 02:24:16 am *
Bienvenido(a), Visitante. Por favor, ingresa o regístrate.
¿Perdiste tu email de activación?

Ingresar con nombre de usuario, contraseña y duración de la sesión
Noticias: Renovado el procedimiento de inserción de archivos GEOGEBRA en los mensajes.
 
 
Páginas: [1] 2   Ir Abajo
  Imprimir  
Autor Tema: Dictado del Curso de C# (Deitel)  (Leído 46386 veces)
0 Usuarios y 1 Visitante están viendo este tema.
argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« : 06/01/2010, 04:48:24 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í:

Las consultas, comentarios y entregas de ejercicios van aquí:

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:
Spoiler: Temario (click para mostrar u ocultar)

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.

En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #1 : 06/01/2010, 10:27:08 pm »

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 [texx]\sharp[/texx] (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 "[texx]\sharp[/texx]" 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)

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




En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #2 : 06/01/2010, 10:39:26 pm »

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.




En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #3 : 07/01/2010, 04:16:01 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 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

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.

  • Vayamos al menú Inicio y hagamos clic en "Ejecutar...".
    Aparecerá el cuadrito para ejecución de programas.
  • Escribamos cmd, y luego clic en "Aceptar".
    Se abrirá una ventana de comandos.
  • En la línea de comandos debemos navegar hasta la carpeta donde está el compilador. Para ello, tenemos que escribir explícitamente el siguiente comando:

    CD C:\WINDOWS\Microsoft.NET\Framework\v3.5

    y a continuación presionar la tecla Enter.
    Verificaremos que estamos posicionados en la carpeta correcta si en la línea de comandos nos aparece el cursor titilando a la derecha de esto: C:\WINDOWS\Microsoft.NET\Framework\v3.5>.

    Esto equivaldría, en el Explorador de Windows, a tener abierta la carpeta C:\WINDOWS\Microsoft.NET\Framework\v3.5\.
  • Ahora que ya hemos "ingresado" a la carpeta correcta, el programa csc.exe está visible para el sistema operativo. Escribimos el siguiente comando:

    csc Holamundo.cs

    y le damos Enter.
    Esto producirá un archivo ya compilado, más aún, ejecutable, con el hombre Holamundo.exe, y quedará guardado en la carpeta en que estamos trabajando.
  • Ahora sólo nos falta ver cómo funciona nuestro programa.
    Para limpiar un poco la ventana de comandos, podemos escribir el comando:

    CLS

    seguido de Enter.

    A continuación escribimos simplemente:

    Holamundo

    seguido de Enter.
    Esto servirá para ejecutar nuestro programa compilado Holamundo.exe.
    Tiene que aparecer en la línea de abajo la frase:

    Hola mundo!!!




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.  :risa:

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




En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #4 : 13/01/2010, 12:31:42 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:
  • Microsoft Visual C# Express Edition 2008 SP1 (Visual Studio 9.0).
  • Monodevelop+Gtk#
  • SharpDevelop

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.

  • Vayamos a la siguiente dirección de internet:

    http://www.microsoft.com/express/download/

    En esa página hay varias aplicaciones para descargar.
    Debemos bajar bastante hasta encontrar un recuadro (en enero de 2010 está en color verde) que dice "Visual C# 2008 Express Edition".
    Antes de descargar el archivo, hacemos la selección de idioma.
    Hacemos clic en el rectángulo de idioma (usualmente es de color blanco y dice "English") y bajamos hasta encontrar la opción "Spanish", la cual seleccionamos con un clic.

    Ahora cliqueamos en "Download" e indicamos a nuestro navegador Web que guarde el archivo en alguna parte.
  • Cuando la descarga finaliza, buscamos el archivo recién descargado, y lo corremos.
    Esto iniciará el programa de instalación (en mi caso es vcssetup.exe).

    • En la primer pantalla nos muestra una bienvenida, y la opción de enviar información a Microsoft sobre la instalación. Recomiendo no tocar nada y cliquear en "Siguiente".
    • En la siguiente pantalla aparece el contrato de uso del producto.
      Se debe cliquear la opción "He leído y acepto los términos de la licencia".
      A continuación clic en "Siguiente".
    • Aparece una pantalla con la opción de "Microsoft SQL Server 2008 Express Edition x86".
      Si la casilla no está marcada, conviene marcarla, porque así tendremos abierta la posibilidad de trabajar con el sistema Microsoft SQL Server que permite gestionar bases de datos relacionales (aunque quizá no usemos asiduamente esto porque está disponible sólo para sistemas Windows).
      Luego clic en "Siguiente".
    • La siguiente pantalla nos muestra la carpeta en que se va a instalar la aplicación, y también indica los requerimientos de espacio libre en el disco duro.
      La carpeta de instalación será: C:\Archivos de programa\Microsoft Visual Studio 9.0\.
      Hacemos clic en "Instalar".

    Después de esto se comenzarán a instalar estas características:

    • Microsoft Windows SDK para Visual Studio 2008 SP1 Express Tools para .NET framework (x86) -esn.
    • Microsofr Windows SDK para Visual Studio 2008 SP1 Express Tools para Win32 (x86).
    • Microsoft Visual C# 2008 Express Edition with SP1.
    • Microsoft SQL Server 2008 Express Edition (x86).

  • Tras finalizar la instalación hacemos clic en "Salir".

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.

  • Vayamos a la dirección de internet:

    http://monodevelop.com/Download

    Aparecerán algunas opciones, y elegimos el ícono de Windows.
    Al hacer clic allí se despliegan tres descargas posibles.

    * .NET Framework 3.5 (esto ya lo hemos instalado en el post anterior).
    * GTK# for .NET 2.12.9-2 (esta opción es necesario descargar primero).
    * MonoDevelop 2.2 (el IDE).

    Como .NET ya lo tenemos, vamos a la segunda opción: GTK#, y hacemos clic en "Download".
    Indicamos a nuestro navegador web que descargue el archivo.

  • Una vez que finaliza la descarga, corremos el programa, dando inicio al proceso de instalación de GTK# para .NET.
    Esto instalará el sistema GTK para que funcione en la plataforma .NET, facilitando la migración a otros sistemas de los programas GUI que implementen GTK.

    • Aparece una pantalla de bienvenida. Clic en "Next".
    • En la siguiente pantalla aparece el acuerdo de licencia (License Agreement).
      Marcamos el cuadrito que dice "I accept the terms in the License Agreement" y luego clic en "Next".
    • En la pantalla siguiente se indica la carpeta donde se instalarán los archivos.
      A mí me aparece: C:\Archivos de programa\GtkSharp\2.12\.
      No cambiamos nada y hacemos clic en "Next".
    • En la siguiente pantalla hacemos clic en "Install".
    • Dará comienzo a la instalación de los archivos.
      Esperamos a que finalice y hacemos clic en "Finish".

  • Ahora instalamos el IDE Monodevelop.
    Repetimos los pasos anteriores, y elegimos ahora la tercer opción de la página: MonoDevelop 2.2.
    Indicamos a nuestro navegador que guarde el archivo, y esperamos a que finalice la descarga.
    Cuando termina, corremos el programa para que inicie el proceso de instalación.

    • Aparece una pantalla de bienvenida. Clic en "Next".
    • En la siguiente pantalla aparece el acuerdo de licencia (License Agreement).
      Marcamos el cuadrito que dice "I accept the terms in the License Agreement" y luego clic en "Next".
    • En la pantalla siguiente se indica la carpeta donde se instalarán los archivos.
      A mí me aparece: C:\Archivos de programa\MonoDevelop\.
      No cambiamos nada y hacemos clic en "Next".
    • En la siguiente pantalla hacemos clic en "Install".
    • Dará comienzo a la instalación de los archivos.
      Esperamos a que finalice y hacemos clic en "Finish".


Tarea obligatoria 3: Instalación del programa SharpDevelop.

  • Vayamos a la página de internet:

    http://www.sharpdevelop.com/OpenSource/SD/Download/

  • Bajemos un poco hasta la sección "Downloads for SharpDevelop 3.1".
    En la primer línea que dice "Setup Download", hacemos clic en "Download".

    Esto iniciará la descarga del programa instalador de SharpDevelop_3.1.1.5.msi.
    Es compatible con las versiones 2.0 y posteriores de .NET.
  • Una vez terminada la descarga, corremos el programa, y así inicia el proceso de instalación.
  • Aparece una pantalla de bienvenida. Clic en "Next".
  • Aparece la pantalla de acuerdo de licencia (License Agreement).
    Marcamos el pequeño casillero blanco que dice "I accept the terms in the License Agreement".
    Luego clic en "Next".

    Si aparece un cartel desagradable que dice "Espere mientras se verifica la cantidad de espacio disponible en el disco", puede que se haya colgado todo.
    Conviene cerrar el programa desde el Administrador de Tareas de Windows, e iniciar la instalación otra vez.
  • Aparece una pantalla indicando los componentes que se van a instalar y la asociación de archivos.
    Recomiendo dejar todo sin tocar, y luego clic en "Next".
  • En la siguiente pantalla hacemos clic en "Install".
  • Esperamos a que termine la instalación, y luego clic en "Finish".



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.
  • Iniciemos la aplicación Microsoft Visual C# Express Edition.
  • Vamos al menú "Archivo" y seleccionamos "Nuevo Proyecto".
    Nos aparecerá una ventana con varias opciones.
    Seleccionamos "Proyecto vacío".
    Abajo, en la casilla de texto escribimos el nombre del proyecto, que será Holamundo2. (Le damos este nombre porque el programita que correremos será ligeramente distinto al del post anterior).
    Hacemos clic en "Aceptar".
  • A la derecha de la pantalla hay una franja angosta con el título "Explorador de Soluciones".
    Allí debe aparecer nuestro nuevo proyecto Holamundo2.
  • Vamos al explorador de Windows y arrastremos el ícono del archivo Holamundo.cs hasta el "Explorador de Soluciones".
    El nombre de nuestro archivo aparecerá en la listita del explorador.
    Hacemos doble clic en el nombre de nuestro archivo y se abrirá una subventana que nos permitirá editar el archivo Holamundo.cs.
  • Vamos al menú "Archivo" y hacemos clic en "Guardar Holamundo.cs como...".
    Nos aparecerá el cuadrito para guardar el archivo con otro nombre.
    Le ponemos el nombre Holamundo2.cs.
    Ahora ya podemos editar tranquilos esta nueva versión de nuestro programita.
  • Vamos a la ventana de edición y debajo de la línea que decía ""Hola mundo!!!", agregamos la línea de código:

          System.Console.ReadLine();

  • Abrimos el menú "Archivo" y hacemos clic en la opción "Guardar Holamundo2.cs".
  • Vamos al menú "Depurar" y hacemos clic en la opción "Iniciar depuración".
  • Se abrirá una ventana de comandos que mostrará la línea "Hola mundo!!!" (eso espero  :rodando_los_ojos: ).
    Presionando la tecla "Enter" nuestro programa terminará, y la ventana se cerrará.
  • Vamos una vez más al menú "Archivo" y hacemos clic en "Guardar todo".
    Se abre el recuadro que indica donde se guardará nuestro proyecto.
    La carpeta que aparece ahí será la carpeta de proyectos para el Visual Studio.
    Esta carpeta podría modificarse, pero por ahora no tocamos nada.
    Hacemos clic en "Aceptar", y nuestro proyecto quedó bien guardado.

    Si no hacemos este último paso, el proyecto y sus archivos pueden quedar guardados en una carpeta temporal.
  • Finalmente cerramos la aplicación Visual Studio.


Tarea obligatoria 5. Vamos a testear el IDE Monodevelop.

  • Abramos la aplicación Monodevelop.
  • En el explorador de Windows, seleccionemos nuestro viejo archivo Holamundo.cs y arrastrémoslo a la ventana de la aplicación, preferentemente encima de todo ese gran saludo de bienvenida.
  • Nuestro archivo Holamundo.cs quedará cargado y listo tanto para edición como para ejecución.
  • Vayamos al menú "Ejecutar" y hagamos clic en la opción "Ejecutar".
  • Hay debajo de la ventana de edición un recuadro angosto en donde se verá la salida que tendría nuestro programa en una consola normal.
    Allí tiene que aparecer la leyenda "Hola mundo!!!".
  • Cerramos la aplicación Monodevelop.

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

  • Abrimos la aplicación SharpDevelop.
  • Vamos al menú "Archivo" y hacemos clic en "Nuevo\Solución".
  • Aparecerá un cuadro con varias opciones.
    A la izquierda, en el recuadro "Categorías", hacemos clic en la línea "C#".
    A la derecha aparecerán algunas opciones. Hacemos clic en "Proyecto en blanco".
    Abajo ponemos un nombre a nuestro proyecto. Le pondremos Holamundo2.
    Hacemos finalmente clic en "Aceptar".
    Aparecerá a la izquierda un recuadro de Proyectos, y en él figurará nuestro nuevo proyecto Holamundo2.
  • En el explorador de Windows seleccionamos nuestro legendario archivo Holamundo.cs y lo arrastramos al recuadro de "Proyectos", encima del nombre del proyecto Holamundo2.
  • Hacemos doble clic en el nombre de nuestro archivo Holamundo.cs en el recuadro de proyectos.
    Se abrirá una ventana de edición para nuestro archivo.
  • Debajo de la línea que tiene el "Hola mundo!!!", agreguemos la línea siguiente:

          System.Console.ReadLine();

  • Vayamos al menú "Archivo" y hagamos clic en "Guardar como...".
    Ponemos el nombre Holamundo2.cs y hacemos clic en "Aceptar".
  • Vayamos al menú "Depurar" y hagamos clic en "Ejecutar".
  • Si tenemos suerte veremos por un momento la consola con el mensaje "Hola mundo!!!", y luego posiblemente se cierre, sin esperar a que uno presione la tecla "Enter".

    No sé por ahora por qué ocurre este comportamiento incorrecto, pero ya me está dando mala espina el SharpDevelop...
  • Cerremos la aplicación SharpDevelop.





En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #5 : 14/01/2010, 05:18:15 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.





En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #6 : 14/01/2010, 08:41:38 pm »

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:
  • Para que un programa hecho en C# compile y se ejecute, necesita un punto de entrada a través de una función llamada Main.
    Esta función va dentro de una determinada clase, como vimos en el Holamundo.cs.
    Por ahora lo usamos así y listo.
  • Hay un sinfín de librerías con funciones y clases prediseñadas que ahorran tiempo al programador. Como en todo lenguaje moderno, estas librerías son muchísimas, y distintos proveedores van agregando nuevas librerías todo el tiempo.
    Para mantener cierto orden, se usan los espacios de nombres, que en principio sirven para agrupar un conjunto de funciones y clases que solucionan un mismo tipo de situaciones relacionadas.
  • A algunas de esas librerías se puede acceder directamente en nuestros programas, y en cambio hay otras que requieren una acción adicional "externa": indicar explícitamente al compilador que cargue cierta librería adicional. Reconoceremos esta acción como "Añadir Referencias".
  • Tal como ocurre con sus predecesores C y C++, todas las sentencias de un programa escrito en C# deben terminar con un punto y coma:

    ;


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

  • Cómo agregar referencias para que ciertas librerías, también llamadas bibliotecas o paquetes, estén visibles y el compilador las reconozca.
  • Cómo usar la librería System.Windows.Forms para generar una aplicación simple, pero GUI.

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.

  • Abrimos la consola de comandos: Menú Inicio/Ejecutar..., seguido de cmd[texx]\rightarrow{}[/texx] (con la flecha indicamos la presión de la tecla Enter)
  • Para asegurarnos que el compilador estará visible por el intérprete de comandos de la consola, vamos a escribir esta instrucción en la ventana de comandos:

    PATH %PATH%;C:\WINDOWS\Microsoft.NET\Framework\v3.5 [texx]\rightarrow{}[/texx]

  • Vamos a la carpeta donde tenemos almacenado nuestro proyecto, a través de la línea de comandos, tipeando:

    CD C:\Proyectos_C_Sharp\Bienvenido_GUI_SWF [texx]\rightarrow{}[/texx]

  • Invocamos el compilador de C# tipeando:

    csc Bienvenido_GUI_SWF.cs  [texx]\rightarrow{}[/texx]

    Esto creará el archivo ejecutable Bienvenido_GUI_SWF.exe.
  • Para correr el programa ejecutable recién creado, tipeamos:

    Bienvenido_GUI_SWF  [texx]\rightarrow{}[/texx]

    Si todo está bien, aparecerá una ventanita en Windows con el cartel: "Bienvenido a C#!".

  • Nos damos por satisfechos y cerramos todas las ventanas abiertas.  :guiño:

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.

  • Abrimos la aplicación Visual Studio.
  • Vamos a la opción de menú "Archivo/Nuevo proyecto...", seleccionamos "Proyecto Vacío" y escribimos el nombre Bienvenido_GUI_SWF.
  • Vamos a "Archivo/Guardar Todo", y aceptamos, para dejar bien guardado nuestro proyecto desde el comienzo, y no olvidarnos después (el Visual Studio requiere que tengamos esta precaución mmm...  :rodando_los_ojos: )
  • En la ventana  "Explorador de Soluciones" hacemos clic con el botón secundario del ratón en el nombre de nuestro proyecto Bienvenido_GUI_SWF y elegimos la opción "Agregar/Nuevo elemento...".
    Elegimos el ícono "Archivo de código" y le ponemos el nombre Bienvenido_GUI_SWF.cs
  • Vamos al menú "Edición/Insertar archivo como texto..." y se abre una ventana para cargar un archivo. Navegamos hasta llegar a la carpeta C:\Proyectos_C_sharp\Bienvenido_GUI_SWF, y allí seleccionamos nuestro querido archivo Bienvenido_GUI_SWF.cs.

    Esto copia el contenido de C:\Proyectos_C_sharp\Bienvenido_GUI_SWF\Bienvenido_GUI_SWF.cs en el nuevo archivo que estamos editando en Visual Studio, sin modificar el original.

    ¿Por qué hacemos esto?
    Porque cada IDE guarda sus proyectos en carpetas distintas,
    y además queremos aprovechar el código que ya tenemos escrito,
    sin tener que volver a tipearlo, ni tampoco abrir el archivo para "copiar y pegar", etc.
    Es una forma limpia de "importar" el contenido de un archivo a otro.

  • Ahora hagamos el intento de correr este programa yendo a "Depurar/Iniciar sin depurar".

    Nos va a dar un error de compilación.

    ¿Cuál es el problema?
    Ocurre que la libería que estamos tratanto de usar, que genera el cartelito con el mensaje de bienvenida no está visible para el compilador.
    Esto es extraño, porque el compilador debiera ser el mismo: csc.exe,
    y cuando compilamos con él en la línea de comandos, no hubo ningún problema.

    Por ahora no sé con exactitud la respuesta.
    Lo que presumo es que el programa Visual Studio implementa un compilador propio, para generar mensajes de error más exactos y eficientes, buscando mayor interacción con el programador. Quizá también gestiona los proyectos a su modo.

    Lo que sí les puedo contar es cuál es el incoveniente "teórico", por decirlo así.
    Se requiere indicarle al compilador que se va a usar la librería System.Windows.Forms.
    Esto se hace "agregándola como referencia".

  • Vamos al Explorador de Proyectos, y en el nombre del proyecto Bienvenido_GUI_SWF hacemos clic con el botón secundario del ratón. En el menú que aparece vamos a "Agregar referencia..." y aparece una lista con varios paquetes.
    Buscamos el que dice System.Windows.Forms, lo marcamos y aceptamos.

    En el Explorador de proyectos nos va a aparecer una sublista llamada "Referencias" en donde se ve agregado este paquete.

    Ahora el programa debiera compilar sin problemas.

  • Vamos de nuevo a "Depurar/Iniciar sin depurar", y aparecerá el cartelito con el mensaje de bienvenida.

    A mí también se me abre además una consola de comandos en el fondo, pero en ella no tiene que aparecer nada. Para cerrar esa ventana, presionar una tecla, o dejar que se cierre sola, según el caso.

  • Vamos a "Archivo/Guardar todo...". Luego nos damos por satisfechos y cerramos la aplicación Visual Studio.

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

  • Abrimos el programa MonoDevelop.
  • Vamos a "Archivo/Abrir...", navegamos hasta la carpeta C:\Proyectos_C_Sharp\Bienvenido_GUI_SWF, seleccionamos el archivo Bienvenido_GUI_SWF.cs, y aceptamos.
  • Intentamos correr el programa yendo a "Ejectutar/Ejecutar", y nos dará un mensaje de error porque le falta acceso a la librería System.Windows.Forms.
  • Para solucionarlo, hacemos el agregado de referencia.
    Sin embargo, necesitamos estar dentro de un proyecto.
  • Vamos a "Archivo/Nuevo.../Solución", seleccionamos "C#", a la derecha "Proyecto vacío", debajo le ponemos el nombre Bienvenido_GUI_SWF_Monodevelop, nos aseguramos que se guarde en la carpeta C:\Proyectos_C_Sharp, y aceptamos.
    Aparece una ventana con opciones. No le hacemos caso, y aceptamos.
  • Vamos a la ventana "Solución", y en el nombre de proyecto Bienvenido_GUI_SWF_Monodevelop hacemos clic con el botón secundario del ratón. Seleccionamos "Añadir/Nuevo archivo...", marcamos "C#", y a la derecha "Empty File" (o "Archivo vacío").
    Abajo elegimos el nombre de archivo Bienvenido_GUI_SWF_Monodevelop.cs, y aceptamos.
    Aparecerá en la lista del proyecto el nombre de este archivo, y hacemos doble clic en él para comenzar a editarlo.
  • También tenemos abierta la ventana anterior de Bienvenido_GUI_SWF.cs.
    Con el tipico procedimiento de "Copiar y pegar", copiamos todo el texto de la ventana de Bienvenido_GUI_SWF.cs a la de Bienvenido_GUI_SWF_Monodevelop.cs.

    Esta vez no sé de una mejor manera de "importar" un archivo con Monodevelop.

  • Vamos a la ventanita que dice "Solución" (que es como el Explorador de Proyectos del Visual Studio), y ahí está alegremente figurando nuestro proyecto Bienvenido_GUI_SWF_Monodevelop.
    Debajo aparece la palabra "Referencias".
    Sobre ella hacemos clic con el botón secundario del ratón y elegimos "Editar referencias...".
    Aparece una lista de paquetes, y buscamos el System.Windows.Forms.
    Debemos seleccionarlo marcando la casilla de verificación a la izquierda del nombre del paquete.
    Luego aceptamos.

    Esto cargará el paquete a nuestro proyecto, y lo podremos verificar abriendo la lista desplegable de Referencias.
  • Vamos a "Archivo/Guardar todo", y sin mirar toda la información que aparece, aceptamos.
  • Nos quedamos descansando por un momento, y reflexionamos sobre la extraña manía de Argentinator de obligarnos a escribir nombres de archivo kilométricos.
    Nos convencemos a nosotros mismos de que eso es bueno, por alguna razón.  :lengua_afuera:
  • Ahora sí, vamos a "Ejecutar/Ejecutar", el programa correrá bien, y aparecerá el cartelito feliz.
  • Nos damos por satisfechos, y cerremos el programa Monodevelop.

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

  • En este caso no voy a repetir todas las instrucciones, paso a paso, los dejo a ustedes investigar la manera correcta de hacer las cosas: crear un proyecto, agregarle un archivo de código, pegarle el código anterior, agregar la referencia System.Windows.Forms, guardar todo y ejecutar.
  • Tan sólo tengan en cuenta que la ventana de "Proyectos" puede que esté algo escondida. Hay que buscarla y dejarla visible.
  • Cuando agreguen la referencia, tengan cuidado de que se selecciona bien.
    Hay que marcarla y después apretar un botón que dice "Seleccionar".
    Esto la agrega en una lista de objetos seleccionados en la parte inferior.
    Recién ahora se puede aceptar.
  • Para ejecutar se va a "Depurar/Ejecutar".

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





En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #7 : 16/01/2010, 02:53:04 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.






En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #8 : 16/01/2010, 07:22:29 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:
  • \n significa retorno de carro y avance de línea.
  • \r significa retorno de carro sin avance de línea.
  • \t significa tabulador.

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...  :guiño:




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:


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:


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

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 !!  :enojado:

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





En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #9 : 17/01/2010, 03:57:43 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...





En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #10 : 21/01/2010, 11:13:02 pm »

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:

  • Para procesar ciertos datos, se necesita primero asignarles un lugar en memoria, y darles un tipo de datos. Esto se hace mediante declaraciones de variables.
    Nuestras variables serán números enteros, así que las declararemos de tipo int.
  • Para que el usuario ingrese datos, se le debe informar más o menos lo que se espera de él.
  • Los datos ingresados en general vienen en formato de cadenas de caracteres.
    Para poder hacer cálculos es necesario hacer una conversión de tipo, transformando la cadena de caracteres en un número entero.
  • Los resultados también ocupan memoria... Declaremos variables para ellos.
  • Tras el ingreso de los datos, se procesan los datos y se efectúan los cálculos.
  • Al final se muestran al usuario los resultados.

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:

  • Abrir el IDE de Visual Studio.
  • Crear un proyecto nuevo y vacío, llamado VS0306SWF_Aritmetica_Basica.
  • Agregar al proyecto las Referencias System.Windows.Forms y System.Drawing.
  • Agregar al proyecto un archivo nuevo y vacío con el nombre VS0306SWF_Aritmetica_Basica.cs, y abrir dicho archivo para edición.

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.

Spoiler: Mismo código sin comentarios (click para mostrar u ocultar)

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!  :llorando:  :llorando:  :llorando: , 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.)




En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #11 : 24/01/2010, 12:55:32 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:

[texx]\bullet[/texx] 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:

  • Nombre: El identificador que elegimos para la variable.
  • Tipo: Es un atributo que permite diferenciar las variables, clasificándolas en conjuntos compatibles entre sí, como ser, número enteros, reales, caracteres, cadenas, u objetos de alguna clase definida por el usuario.
  • Tamaño: Es la cantidad de bytes que ocupa la variable en la memoria.
  • Valor: Es la información que guarda la variable en su seno. Para interpretar correctamente este valor, se debe atender al tipo de la variable.

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



En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #12 : 25/01/2010, 10:38:35 pm »

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.

[texx]\bullet[/texx] Lo primero que debemos llevar a cabo es el diseño del proyecto.

Empecemos con el final: los objetivos:

  • Realizar un programa con interface gráfica en Windows, usando System.Windows.Forms.
  • Toda la aplicación debe desarrollarse en una sola ventana, y todos los controles de la misma tienen que estar bien visibles y ser simples de configurar por nosotros en el archivo de código.
  • Desde el punto de vista de quien usará nuestro programa, la mecánica de uso tiene que ser clara y simple. El aspecto tiene que ser ordenado, y la interacción tiene que ser natural.
  • Tiene que haber un botón para salir del programa en forma ordenada.


Detalles de la calculadora:

  • Habrá varios casilleros en donde podrán escribirse números.
    El usuario tiene que poder editar estos casilleros y poner el número que más le guste, y cuando lo desee.
    Por lo tanto, el widget a usar en este caso serán las cajas de texto, que en la librería System.Windows.Forms reciben el nombre de TextBox.
  • Esos casilleros tendrán nombres, como a, b, c, etc., y se indicará el nombre debajo del casillero.
    Pero para poder hacer esto es menester usar algún widget, concretamente, una etiqueta. En S.W.F. se llaman Label.
  • Deseamos agregar unos botones para indicar las operaciones aritméticas.
    El widget adecuado es un botón, que en S.W.F. corresponde a un Button.
  • También pondremos un cartelito informativo, que nos deje constancia de la operación que estamos haciendo, y el resultado que nos da. Esto lo pondremos en una etiqueta.
  • También agregaremos un casillero z que mostrará el resultado de las operaciones.
    Aún asi, ese casillero también podrá editarse, y tendrá debajo una etiqueta que diga "z".
  • Habrá un botón que permita limpiar todos los datos, poniéndolos a 0.
  • Y finalmente un botón para terminar el programa.

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

  • Llevar a cabo operaciones aritméticas de una en una, como una calculadora corriente.
    Esto evita además toda la discusión de la precedencia de operadores, o el uso de paréntesis, etc.
  • Para realizar un cálculo, se rellenan los casilleros numéricos, luego se hace click sobre uno de los valores deseados, a continuación sobre el botón de la operación deseada, y por último click sobre el segundo operando. Para terminar, se hará click sobre un botón con el signo =.
  • Si en vez de presionar el botón = se presiona algún otro botón de operación, se hace igual el cálculo, pero se sigue operando.
    Para que esto funcione, nos ayudaremos de dos variables internas: operando y resultado.
    El primer operando se guardará en la variable resultado, y el segundo en la variable operando.
    Una vez efectuado el cálculo, se pone el resultado en la variable resultado.
    A medida que los cálculos continúan, los nuevos valores elegidos se guardan en operando.

    El cálculo se efectúa siempre entre el "último resultado" y el "siguiente operando".
  • Para simplificar la mecánica anterior, al accionar el botón = no vamos a considerar que se acabaron las operaciones.. sino que se efectúa una operación especial, que consiste en "dar como resultado al último operando clickeado".
  • También se debe manejar apropiadamente la situación de una división por 0.
    En ese caso, se dejará todo como estaba "hasta ese momento", al tiempo que se mostrará un cartel indicando: "Error de División por 0".

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

Spoiler: Click para ver código (click para mostrar u ocultar)

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:

Spoiler: Click para ver código (click para mostrar u ocultar)

[texx]\bullet[/texx] 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:

Spoiler: Click para ver código (click para mostrar u ocultar)

Ahora que los objetos ya han sido creados, podemos configurarlos.
Para ello se les debe dar valores a los atributos de cada objeto.
  • El atributo Text de cada objeto sirve para poner un texto en el espacio ocupado por el widget correspondiente.
  • Los atributos Width, Height, indican el ancho y el alto del widget en pantalla.
  • El atributo Location indica la posición donde queremos que aparezca el widget, en coordenadas relativas al formulario.
    La medida se hace en pixels, y las coordenadas verticales comienzan arriba en 0 y avanzan hacia abajo con signo positivo.
    Para expresar adecuadamente un par de coordenadas, se debe usar un tipo de datos especialmente construido a este propósito.
    No nos preocupemos por los detalles de esto.
    Basta saber que con el uso del método System.Drawings.Point ( x, y ) se obtiene un valor del tipo correcto, asignable a Location.

Aquí van las inicializaciones:

Spoiler: Click para ver código (click para mostrar u ocultar)

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í:

Spoiler: Click para ver código (click para mostrar u ocultar)

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 +=):

Spoiler: Click para ver código (click para mostrar u ocultar)

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:

Spoiler: Click para ver código (click para mostrar u ocultar)

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)




* curso-c-sharp-vs0308guiswf-calculadora.JPG (27.73 KB - descargado 5220 veces.)
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #13 : 28/01/2010, 02:31:38 am »

Proyecto: Calculadora (continuación).

  • En primer lugar, notemos que cuando el usuario ingresa datos en los casilleros, la aplicación no reacciona de ninguna manera especial. Tan sólo se deja actuar al widget como lo que es: una caja de texto que permite entrar datos.
    No obstante, tengamos presente que el valor almacenado en esos casilleros es siempre de tipo string, vale decir, una cadena de caracteres.
    Así que, para hacer cálculos aritméticos, en algún momento habrá que convertir los datos de caracteres a números enteros.
  • Cuando el usuario clickea en una de las etiquetas a, b, c, d, e, f, el programa responderá escribiendo el valor correspondiente en el casillero z, que podemos pensarlo como el "visor de resultados".
    Al mismo tiempo, se indicará que se ha "cargado un nuevo operando".
    Esto se hará con un método específico que se invocará en todos los casos, y lo llamaremos nuevo_operando(), que por ahora dejamos sin implementar.
    El código de todos estos métodos es el mismo, y es muy sencillo:

    Spoiler: Click para ver el código (click para mostrar u ocultar)

    Notemos que hasta ahora el casillero de resultados z tiene el mismo tratamiento que los demás: en todos los casos el efecto es dejar en el "visor" el valor del casillero clickeado por el usuario.
    La única diferencia es que la sentencia this.caja_texto_z.Text = this.caja_texto_z.Text;
    es redundante, ya que se está poniendo el valor de ella misma... en ella misma.
  • Notemos que, como las widgets caja_texto_a, y las demás, son de tipo TextBox, todas tienen el atributo Text.
    Dicho atributo es una variable, y se le puede asignar valores, o usar su valor en un cálculo o procesamiento.
  • Notemos que en todas partes estamos usando el prefijo this. para acceder a los objetos del formulario.
    Esto no es estrictamente necesario.
    Pero es de "buena educación" poner this. en todas partes.
    ¿Por qué?
    Porque podría haber varias instancias de la aplicación o de las ventanas, y en esos caso, el prefijo this. ayuda a discernir el correcto comportamiento de la aplicación.
    Al profundizar en la teoría de la programación orientada a objetos explicaremos con más certeza qué es lo que ocurre, y el significado de this.
  • Al presionar un botón de operación aritmética, se debe realizar un cálculo.
    En este caso llevamos a cabo varias operaciones comunes a todos los casos.
    Como son siempre las mismas, creamos un método común de nombre recalcular(), que definiremos más adelante.
    El aspecto de los métodos para los botones de operaciones quedarían así:

    Spoiler: Click para ver el código (click para mostrar u ocultar)
  • En los métodos anteriores se ha invocado una variable llamada oper.
    Ella será un miembro de la clase Formulario_principal, será de tipo char, y albergará un caracter indicando el tipo de operación aritmética efectuada.
  • Observemos la extraña codificación de esos métodos.
    "Primero" se llama a la función de recalcular(),
    y "después" se indica el tipo de operación.
    ¿No habría que indicarl antes? ... mmmm

    En realidad esto obedece a la "mecánica" de nuestra calculadora.

    "Suponemos" que tenemos dos operandos y una operación "ya" almacenadas en alguna parte.
    Al presionar el botón = simplemente se "efectiviza" el cálculo y se muestra el resultado.
    Los demás botones +,-,*,/,%, funcionan de la misma forma que el botón =, con la única diferencia de que a su vez quedan "en espera" de un nuevo operando, para seguir con el cálculo.

    Obsérvese que el "signo de la operación" al apretar el botón = es un punto y coma ;.
    Esto quiere decir que la operación aritmética efectuada es simplemente: "separar lo anterior del nuevo valor elegido, y tenerlo guardado como un nuevo operando".

  • Otra sutileza: cuando se presiona el botón = se termina la seguidilla de cálculos.
    En ese caso, el valor que queda en el casillero z se puede usar para hacer nuevas operaciones.
    La idea es que quede incluso disponible, sin necesidad de hacer click sobre él.
    O sea, si en el visor queda un número, querríamos operar con él, sin tener que hacer click sobre la z.

    Pero esto es una cuestión intuitiva del usuario, que el lenguaje C# no es capaz de adivinar...
    Tenemos que indicarlo nosotros adecuadamente.
    Para que esté disponible el valor del visor, lo ponemos como el siguiente nuevo operando.
    Y por eso se agrega una llamada a nuevo_operando(); en el código del método boton_igual_Click.
  • Ahora vamos a implementar los métodos nuevo_operando(), recalcular().
    Antes de ello es necesario declarar unas variables que guardarán valores temporales de los operandos. Ya dijimos que uno se llamará resultado y el otro operando.
    A pesar de los nombres, ambos serán "operandos" cuando hagamos los cálculos.
    La diferencia está en que el valor guardado en resultado es el que se pone en el "visor de resultados".
    También declararemos una variable para almacenar la próxima operación que se habrá de calcular.

    Además, vamos a agregar una variable de tipo string, de nombre formula, que tendrá fines meramente informativos.
    No será necesaria en los cálculos, pero permitirá mostrar al usuario un cartelito resumiendo la operación aritmética que está llevando a cabo, y cuánto da.

    Las declaraciones de las variables son éstas:

        private char oper;
        private int operando;
        private int resultado;
        private string formula;


  • Veamos el método nuevo_operando().
    En él simplemente se pone en la variable operando el valor numérico entero que resulta de transformar el dato puesto en el casillero z , que originalmente es de tipo string.

    ¿Por qué sólo z?
    ¿Qué pasa si quiero poner el valor de c, como operando?
    Bueno, el programa funciona así:

    * Al hacer clic en c se pone el valor del casillero de c en el de z, lo cual es automáticamente visto por el usuario.
    O sea, el valor elegido se pone automáticamente en el "visor de resultados".
    A continuación presionamos un botón de operación, digamos +, y el programa almacenó esta elección del usuario en la variable oper.
    Antes de almacenar este sencillo dato, hizo una llamada a recalcular(), sólo para resolver las operaciones aún pendientes...
    Pero con el signo + aún no puede hacerse nada, porque falta ingresar otro operando.

    * Ahora el usuario elige un segundo operando, y entonces se almacena automáticamente en la variable operando.

    ¡¡En particular, estamos sobreescribiendo el valor anterior de operando!!  :sorprendido:

    ¿Y entonces, dónde fue a parar el valor del primer operando?
    A no desesperar, que seguramente ha sido guardado en el casillero de z.
    Esto se hizo al momento de clickear sobre el botón +.

    Toda esta discusión para poder poner como método nuevo_operando() una simple línea que resuelve todo, y lo hace bien, del modo esperado:


        private void nuevo_operando()
        {
            this.operando = Convert.ToInt32(this.caja_texto_z.Text);
        }


  • Ahora vamos al método recalcular().
    Este método mira en los valores numéricos que están guardados en las variables resultado y operando, y consulta la operación aritmética que está "en espera" en la variable oper.
    Según de qué operación se trate, hace el cálculo que corresponde.
    La selección de la operación se hace sencillamente, a través del selector de casos switch, que en su momento explicaremos.
    Por ahora basta ver cómo funciona.

    [spoiler=Clic para ver detalles]
        private void recalcular()
        {
          &n
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #14 : 28/01/2010, 07:55:36 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:


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.





En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #15 : 28/01/2010, 11:44:19 pm »

(Reservado para completar trabajos previos)
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #16 : 29/01/2010, 03:50:09 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:
  • ==: compara dos variables y determina si sus valores son iguales.
  • !=: compara dos variables y determina si sus valores son distintos.
  • <: compara dos variables y determina si la primera es estrictamente menor que la segunda (si esto está definido para el tipo de datos que se está comparando).
  • <=: compara dos variables y determina si la primera es menor o igual que la segunda (si esto está definido para el tipo de datos que se está comparando).
  • >=: compara dos variables y determina si la primera es estrictamente mayor que la segunda (si esto está definido para el tipo de datos que se está comparando).
  • <: compara dos variables y determina si la primera es estrictamente menor que la segunda (si esto está definido para el tipo de datos que se está comparando).
  • >=: compara dos variables y determina si la primera es mayor o igual que la segunda (si esto está definido para el tipo de datos que se está comparando).

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.  :sorprendido:  :sorprendido:  :sorprendido:

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.




En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #17 : 31/01/2010, 06:25:32 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:


Lo que tienen que hacer es lo siguiente:

  • Iniciar un nuevo proyecto vacío, de nombre VS0309GUISWF_Adivina_Numero, con un nuevo archivo de código vacío VS0309GUISWF_Adivina_Numero.cs.
    Agregar las referencias usuales: System, System.Drawing, System.Windows.Forms.
  • El programa selecciona un número al azar entre 0 y 99, que queda oculto para el usuario.
    El usuario debe escribir en un cuadro el número que él cree correcto.
    O sea, está adivinando.
    Cuando ha escrito el número de su preferencia, presiona el botón "Apostar!", y el programa da pistas con mensajes de texto que dicen: "Frío, Tibio, Caliente, Muy Caliente, Acertaste".
    El botón "Reiniciar" sirve para que el programa seleccione un nuevo número al azar.
    Los botones "<<" y ">>" sirven para retroceder o avanzar 10 pasos. Al presionarlos, el número de la caja de texto debe reflejar este avance o retroceso.

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.





* curso-csharp-vs0309GUISWF_adivina_numero.JPG (24.47 KB - descargado 4970 veces.)
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #18 : 31/01/2010, 09:23:38 pm »

Proyectos de práctica para el capítulo 3 (continuación).

Proyecto "Ta te ti".

El programa tiene el siguiente aspecto visual:


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.






* curso-c-sharp-vs0309guiswf-tateti.JPG (27.24 KB - descargado 6948 veces.)
En línea

argentinator
Consultar la FIRMAPEDIA __________________________________________________________________________________________________________________
Administrador
Pleno*
*****

Karma: +0/-0
Desconectado Desconectado

Sexo: Masculino
Argentina Argentina

Mensajes: 7.205

Vean mis posts activos en mi página personal


Ver Perfil WWW
« Respuesta #19 : 14/02/2010, 11:18:07 pm »

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:

  • Enseñar los rudimentos de la creación de programas en C# con interfase gráfica, usando las librerías System.Windows.Forms.

  • Aprender a configurar los elementos (widgets) más simples de una aplicación con interfase gráfica para el usuario (GUI).

  • Aprender a "hacer reaccionar" a los elementos gráficos (widgets) de la aplicación, "atando" adecuadamente un "evento" (como el hacer click en un botón) a una determinada "acción de respuesta del programa".

  • Vamos a desarrollar paso a paso ejemplos de aplicación que sólo necesiten elementos básicos de programación, como los vistos hasta este momento, sin muchas complicaciones de algoritmos.


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:


Los pasos a seguir son los siguientes:

  • Abrir el programa Visual Studio y crear un proyecto nuevo, tal como se ha explicado en lecciones anteriores.

  • En dicho proyecto, crear un archivo nuevo, tal como se ha venido haciendo siempre, y pongámosle el nombre VS_GUISWF_Tutorial01_Vacia.

  • Antes de ponerse a programar como loco, hay que habilitar las librerías que permiten hacer aplicaciones gráficas. Como ya sabemos, hay varias posibilidades, principalmente las System.Windows.Forms y las Gtk#.
    Nosotros vamos a usar por ahora System.Windows.Forms.
    Para ello, debemos agregar a nuestro proyecto las Referencias correspondientes.
    Ya sabemos cómo hacer esto.
    Tan sólo recordemos que las Referencias que hay que agregar son las siguientes:

    System
    System.Windows.Forms
    System.Drawing


  • Ahora sí nos ponemos a programar.
    En primer lugar tenemos que escribir el código del método Main:


    static class Aplicacion_Vacia
    {
        static void Main()
        {
               
        }
    }


  • Ahora, para facilitar el uso de las librerías de System.Windows.Forms vamos a habilitar los espacios de nombres de las mismas, agregando las sentencias using correspondientes al principio del programa.
    El resultado de esto nos da este código:


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


    static class Aplicacion_Vacia
    {
        static void Main()
        {

        }
    }


  • Ahora vamos a "construir" el formulario de la aplicación.
    Tenemos que comprender en este punto de la cuestión, que construir el formulario equivale a la trastienda de una obra de teatro. Los actores se visten y maquillan detrás del telón, pero los espectadores (usuarios) no ven nada hasta que la obra "inicia".

    Así que el formulario lo construiremos un poco "a ciegas", sin saber en principio cómo quedará.

    Lo que hay que hacer es declarar una clase que herede las propiedades de la clase Form, que reside en la librería Windows.System.Forms.

    Esto se hace agregando una declaración como esta:


    public class Formulario : Form
    {

    }


    No nos preocupemos por la sintaxis, ni mucho menos por el significado de la palabra public. Eso lo veremos en el capítulo siguiente.

    Dentro de las llaves { ... } se ponen objetos que representarán a los widgets de la aplicación y también los métodos que los controlan.

    En el desplegable que sigue adjuntamos el código como va quedando hasta ahora.



  • La clase Formulario que hemos introducido no hace nada por ahora. Para que haga algo al invocársela, se debe definir su método constructor.
    Se trata de una porción de código con el mismo nombre que la clase, y que se coloca dentro de ella.
    Tiene este aspecto:


        public Formulario()
        {
     
        }


    Obviamente este método por ahora no hace nada.
    Pero todo aquello que queremos que el Formulario realice al iniciarse por primera vez, debemos indicarlo mediante sentencias entre las llaves {   ...   } del método Formulario().


  • Ahora deseamos al menos tener algo de control sobre la aplicación, comenzar a hacer algo.
    Lo único que haremos por ahora será manejar los atributos de ancho y largo del formulario principal de la aplicación.
    A este formulario lo estamos definiendo nosotros mismos, es una clase que se comportará del modo que le estamos indicando.
    En particular, estos atributos de tamaño los ha "heredado" de Form.

    Hay en Form una multitud de atributos que se pueden configurar, pero nosotros no debemos preocuparnos por eso ahora, no tiene demasiada importancia.
    Aceptaremos los valores por defecto de esos atributos.

    Sólo vamos a modificar el tamaño del formulario, y esto se hace dando un valor adecuado al atributo Form.ClientSize().
    Sin embargo, como hemos declarado que nuestro formulario hereda los atributos de Form, resulta que ClientSize() está directamente disponible dentro de nuestra clase Formulario.

    El tipo de datos de este atributo no es numérico, sino algo definido en las librerías... No vamos a entrar en detalles por ahora, sólo digamos que la manera correcta de darle un valor es a través del método Size() de la librería System.Drawing.

    La invocación es muy sencilla:


    ClientSize = new Size(300, 600);


    El primer número es el ancho, y el segundo número es el largo.
    O sea que estamos construyendo un formulario, cuya ventana de aplicación tendrá un tamaño de 300x600.


  • Si ejecutamos la aplicación anterior, veremos que no hace nada. ¿Por qué?
    Mencionemos que un formulario es sólo una clase.
    Se necesita ahora crear un objeto que haga las veces de ventana de aplicación,  y cuyo tipo de datos sea el de la clase del formulario que estamos definiendo.

    Esto se hace mediante una declaración del tipo: new Formulario().

    Eso creará un objeto con las características indicadas en Formulario(), y en particular creará la ventana de la aplicación.
    Pero volvamos aquí a la comparación del teatro.

    Definir la clase Formulario equivale a "explicarle a los actores cómo será su vestuario".
    Hacer la invocación new Formulario() equivale a "hacer que los actores se vistan para la obra según las indicaciones antes recibidas, pero aún no se abre el telón a los espectadores".
    Para abrir el telón y que la obra comience, o sea, que en efecto aparezca la ventana de aplicaicón en la pantalla del usuario, se debe iniciar el bucle de ejecución de la aplicación, al tiempo que se le asigna el objeto creado mediante new Formulario().

    El bucle de la aplicación es un "estado de espera" del programa que está aguardando acciones del usuario.
    Ahora bien, para arrancar este bucle se utiliza el método Run.Application)() de la librería System.Windows.Forms.

    Todo lo descripto aquí se hace mediante una sola sentencia como la siguiente:


            Application.Run( new Formulario() );


    Esta sentencia, para que tenga efecto, debe estar en el flujo de ejecución de acciones del programa principal, o sea que la colocamos dentro de Main().
  • Nuestra aplicación vacía ya está lista.
    Recordemos guardar todo el proyecto mediante Archivo/Guardar todo...

    Ahora sólo tenemos que ejecutar el programa, como ya sabemos hacerlo (Depurar/Iniciar sin depurar).




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




* curso-c-tutorial-cap3-aplic-vacia.PNG (7.62 KB - descargado 6034 veces.)
En línea

Páginas: [1] 2   Ir Arriba
  Imprimir  
 
Ir a:  

Impulsado por MySQL Impulsado por PHP Powered by SMF 1.1.4 | SMF © 2006, Simple Machines LLC XHTML 1.0 válido! CSS válido!