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