Autor Tema: Dictado del Curso de C# (Deitel)

0 Usuarios y 1 Visitante están viendo este tema.

06 Enero, 2010, 08:48 pm
Leído 55837 veces

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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:
Temario
  • 1. Introduccion a las computadoras, Internet y Visual C#
  • 2. Introduccion al IDE Visual C# 2005 Express Edition
  • 3. Introduccion a las aplicaciones C#
  • 4. Introducción a clases y objetos
  • 5. Sentencias de Control: Parte 1
  • 6. Sentencias de Control: Part3 2
  • 7. Metodos: Una mirada más profunda
  • 8. Arrays
  • 9. Clases y Objetos: Una mirada profunda
  • 10. Programación orientada a objetos: Herencia
  • 11. Polimorfismo, Interfaces y Sobrecarga de Operadores
  • 12. Manejo de Excepciones
  • 13. Conceptos GUI. Parte 1
  • 14. Conceptos GUI. Parte 2
  • 15. Multihilo
  • 16. Cadenas, Caracteres y Expresiones Regulares
  • 17. Gráficos y Multimedia
  • 18. Archivos y Flujos
  • 19. Lenguaje de Marcado Extensible (XML)
  • 20. Bases de datos, SQL y ADO.NET
  • 21. ASP.NET 2.0, Formas Web y Controles Web
  • 22.  Servicios Web
  • 23. Networking: Streams-Based Sockets and Datagrams
  • 24. Buscando y Ordenando
  • 25. Estructuras de Datos
  • 26. Genericos
  • 27. Colecciones
[cerrar]

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

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

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


07 Enero, 2010, 02:27 am
Respuesta #1

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
1. Introducción a las computadoras, Internet y Visual C#

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

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

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

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

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



Gracias a Topo23 y Mathtruco por los comentarios que siguen:

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

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

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





07 Enero, 2010, 02:39 am
Respuesta #2

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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.





07 Enero, 2010, 08:16 pm
Respuesta #3

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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.  :laugh:

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





13 Enero, 2010, 04:31 am
Respuesta #4

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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  ::) ).
    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.






14 Enero, 2010, 09:18 am
Respuesta #5

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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.






15 Enero, 2010, 12:41 am
Respuesta #6

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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\( \rightarrow{} \) (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 \( \rightarrow{} \)

  • 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 \( \rightarrow{} \)

  • Invocamos el compilador de C# tipeando:

    csc Bienvenido_GUI_SWF.cs  \( \rightarrow{} \)

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

    Bienvenido_GUI_SWF  \( \rightarrow{} \)

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

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...  ::) )
  • 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.  :P
  • 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






16 Enero, 2010, 06:53 pm
Respuesta #7

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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.







16 Enero, 2010, 11:22 pm
Respuesta #8

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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...  ;)




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

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

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

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

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

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

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

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

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




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

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


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


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






17 Enero, 2010, 07:57 pm
Respuesta #9

argentinator

  • Consultar la FIRMAPEDIA
  • Administrador
  • Mensajes: 7,274
  • País: ar
  • Karma: +0/-0
  • Sexo: Masculino
  • Vean mis posts activos en mi página personal
    • Mis posts activos (click aquí)
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...