Introducción a las aplicaciones Windows

Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Introducción a las aplicaciones Windows
En la primera parte del libro se ha estudiado las características de C#, pero realmente, se
ha hecho una escasa utilización de las clases contenidas en el Framework.NET. Una vez
conocidos los conceptos de clase y herencia se puede aprovechar toda la potencia de la
programación orientada a objetos y de este lenguaje, para utilizar el conjunto de clases
que ofrece la plataforma .NET.
En este capítulo se hará una breve introducción a la programación de aplicaciones para
Windows y se construirán algunos programas muy sencillos para explicar el “esqueleto”
de una aplicación. En primer lugar, se implementa una aplicación utilizando un editor
de textos cualquiera con objeto de explicar con detalle el código necesario para
construir una aplicación Windows y posteriormente se implementará otra con ayuda de
Visual Studio .NET para describir el entorno que proporciona el paquete.
Breve descripción del namespace System.Windows.Forms
Toda la funcionalidad que se requiere para crear aplicaciones para Windows la
proporciona el namespace System.Windows.Forms.
El namespace System.Windows.Forms se compone de clases, estructuras,
delegates, interfaces y enumeraciones. En los próximos capítulos se irán estudiando
muchos de ellos.
Para escribir aplicaciones Windows con C# se puede utilizar cualquier editor, por
simple que sea. Desde luego, ayudará a comprender mucho mejor el código el hecho de
escribir las primeras aplicaciones con el block de notas. En este capítulo se escribirán de
esta manera un par de aplicaciones, muy sencillas, que servirán para describir los
fundamentos de una aplicación Windows.
La segunda opción –y realmente la más práctica- es trabajar en el entorno de
desarrollo proporcionado por Visual Studio .NET. La utilización de este paquete
simplifica la tarea del programador y permite centrarse en lo que de verdad es su
misión: escribir el código sin perder mucho tiempo con el diseño gráfico de la
aplicación.
De modo esquemático el namespace System.Windows.Forms contiene las
siguientes clases o tipos:
•
Application
Esta clase es el corazón de una aplicación Windows. Utilizando los métodos de
esta clase se puede procesar los mensajes de Windows, comenzar y terminar la
aplicación, etc...
•
Form
•
Esta clase representa las ventanas o cuadros de diálogo de una aplicación
Windows.
Button, ListBox, TextBox, PictureBox…
1/37
Marco Besteiro y Miguel Rodríguez
•
•
•
•
Introducción a las Aplicaciones Windows
Estas y otras muchas clases proporcionan toda la funcionalidad y flexibilidad de
los controles más habituales de Windows.
StatusBar, Splitter, ToolBar, ScrollBar,…
Son clases que corresponden a utilidades de Windows: barras de estado y de
desplazamiento, cajas de herramientas, etc.
ColorDialog, FileDialog, …
Son las cajas de diálogo estándar.
Menu, MainMenu, MenuItem, ContextMenu…
Se utiliza para crear menús y menús PopUp
ToolTip, Timer, …
Facilitan la interactividad de las aplicaciones.
Los controles, en general, son instancias u objetos de estas clases. Se añaden a un
formulario cuando son miembros de la clase a la que pertenece dicho formulario. De
manera esquemática, el árbol de herencia de las clases correspondientes a los controles
del namespace System.Windows.Forms es el de la figura 14.1:
2/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.1: Jerarquía de clases del namespace System.Windows.Forms
Las clases situadas en el exterior del cuadro no pertenecen a este namespace. Se han
representado con un tono un poco más claro las clases abstractas.
Todas las clases de este namespace derivan de la clase object. Es muy importante
conocer lo que aporta cada una de las clases base de las que hereda una determinada
clase que se vaya a utilizar porque hereda todas sus propiedades, métodos y eventos.
A continuación se explica brevemente la funcionalidad de las principales clases
base.
3/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
La clase Object es clase base de todas las clases. Sobre ella se ha hablado
anteriormente, por lo que no se insistirá en este punto.
La clase MarshalByRefObject define el comportamiento para trabajar con un tipo
por referencia y no por valor. En general, todos los controles son de tipo referencia y
heredan de esta clase.
El tipo Component proporciona la funcionalidad para que un control interactúe con
su contenedor, como por ejemplo, un botón con el formulario que lo contiene. Además,
proporciona la implementación del método Dispose(), que es el método que se ejecuta
cuando, por ejemplo, se cierra un formulario. En el código del formulario de una
aplicación, una clase que heredada de la clase Form puede sobrescribir este método de la
siguiente manera:
public override void Dispose()
{
base.Dispose();
//código
}
Observe que las tres clases citadas pertenecen a namespace diferentes.
La clase Control
Esta es una clase muy importante porque establece gran parte del comportamiento
común de muchas clases que derivan de ella: una gran mayoría de los controles de
Windows la tienen como clase base. Permite configurar gráficamente la posición y el
tamaño de un control, capturar las entradas desde el teclado y ratón, etc. Más adelante se
estudiará con profundidad esta clase.
A continuación se describen dos clases base que derivan de la clase Control, llamadas
ScrollableControl y ContainerControl. Son muy importantes porque, aunque la
gran mayoría de los controles no heredan de ellas, sí lo hace la clase Form –ver figura
14.1-, que es la clase de la que heredan todos los formularios.
La clase ScrollableControl
Se utiliza para definir un pequeño número de miembros que permiten a un control
soportar barras de desplazamiento horizontales y verticales.
Los controles que derivan de esta clase tienen dos propiedades relacionadas con ella que
son AutoScroll y ScroollSize.
Por ejemplo, imagine que en el constructor de un formulario, se incluyen las dos
siguientes líneas:
this.AutoScroll = true;
this.AutoScrollMinSize = new System.Drawing.Size(250,250);
La primera de ellas define si se establecen barras de desplazamiento o no en el control –
el formulario en este caso-. La segunda, establece el tamaño mínimo del control a partir
del cual las barras se harán visibles. En el ejemplo anterior, si el ancho o la altura del
4/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
formulario son menores de 250 píxeles, se visualizará una barra de desplazamiento
horizontal o vertical respectivamente.
En la figura 14.1 se puede observar que no son muchos los controles que derivan de esta
clase. Pero entre ellos, además de Form, está la clase Panel y la clase TabPage. Por esta
razón, si se desea que un PictureBox tenga barras de desplazamiento –por ejemplo,
para visualizar una imagen más grande que el propio control- se puede trabajar con un
panel y en él, introducir un PictureBox. Más adelante se hace un ejemplo de esto, al
describir el control Panel.
Si se pretende personificar las barras de desplazamiento o tener cierto control sobre
ellas, es mejor trabajar con los controles HScrollBar o VScrollBar, porque la clase
ScrollableControl no define muchos métodos o propiedades para ella.
La clase ContainerControl
Esta clase deriva de la clase ScrollableControl y además define propiedades y
métodos para relacionar un control “contenedor” de controles con los controles que
contiene. Permite también manejar el foco de la aplicación. En la práctica, es muy
corriente cuando un formulario contiene varios controles y se desea utilizar la tecla
Tabulador para pasar el foco de uno a otro. Con muy poca programación –y muchas
veces se puede hacer visualmente, en tiempo de diseño - se puede forzar al foco para
que después de un determinado evento siga un determinado orden en los controles que
lo van recibiendo. En el siguiente capítulo, se utiliza esta funcionalidad en un ejemplo.
Todos los controles heredan las propiedades TabStop y TabIndex. Se utilizan para
definir el orden relativo para adquirir el foco respecto al control que los contiene –un
formulario, un panel, etc- y se utilizan en combinación con las propiedades anteriores.
Las propiedades y métodos más importantes de esta clase son:
•
•
•
ActiveControl: define el control activo.
ParentForm: es una referencia al formulario que contiene al control.
ProcessTabKey(): este método permite ir o no adelante a través de los
controles del contenedor de los controles.
La primera aplicación Windows con el block de notas
Se puede escribir directamente el código necesario para implementar una aplicación
básica para Windows en cualquier procesador de textos pero esta no es la mejor opción
si el programa se complica un poco. Sin embargo, se anima al lector a trabajar de este
modo al principio porque le ayudará a comprender mejor el código que Visual Studio
escribe por defecto. En este caso, se trabajará con el block de Notas, pero puede hacerse
con el editor que se prefiera.
5/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Los pasos necesarios para crear una aplicación mínima para Windows son los
siguientes:
a) Derivar una clase de la clase System.Windows.Forms.Form. La clase Form
proporciona toda la funcionalidad de un formulario.
b) En el método Main() de la clase que se está definiendo, invocar al método
estático Run() de la clase Application pasándole como argumento una
instancia u objeto de la clase.
Por ejemplo: ejecute el block de notas y escriba el siguiente código y guárdelo en un
fichero denominado Form1.cs. Puede llamarse de cualquier forma, aunque la
extensión debe ser cs.
//Aplicación Form1. Fichero Form1.cs
using System.Windows.Forms;
public class Form1 : Form
{
static void Main()
{
Application.Run(new Form1());
}
}
A continuación, se ha de compilar el fichero desde el SDK. Para ello, se puede cargar
Visual Studio como se indica en la figura 14.2:
Figura 14.2. Cargando Visual Studio .NET en modo comando.
Para compilar, se ha de escribir la línea (figura 14.3)
csc Form1.cs
La línea anterior crea un fichero Form1.exe en el mismo directorio.
6/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Para ejecutarlo se ha de escribir (figura 14.3):
Form1
Figura 14.3: Modo de compilar y ejecutar una aplicación en modo comando.
Al ejecutarlo, se despliega la siguiente ventana (figura 14.4):
Figura 14.4: La aplicación Form1.exe
Observe que esta ventana tiene los tres botones en la parte superior derecha y el icono
de la esquina superior izquierda, cada uno de ellos con toda su funcionalidad. Además,
se puede cambiar el formulario de tamaño.
Para comprender este primer programa, es preciso hacer algunas puntualizaciones y,
sobre todo, profundizar un poco en la clase Application. A continuación, se describe
brevemente cada línea del código del programa anterior.
•
En primer lugar se importa el namespace System.Windows.Forms:
using System.Windows.Forms;
7/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Este primer paso es necesario porque las clases Application y Form pertenecen a este
namespace.
•
Se crea una clase de nombre Form1, que deriva de la clase Form. Por esta razón,
Form1 tendrá todos los miembros que posee la clase Form, y podrá hacer uso de
ellos. Un objeto de la clase Form representa una ventana estándar de Windows
que será visualizada cuando se ejecute la aplicación.
public class Form1 : Form
Con la directiva using se le indica al compilador que importe el namespace. De
esta manera, para hacer referencia a la clase, basta con invocarla con su nombre
–Form- y no con el nombre completo -System.Windows.Forms.Form-.
•
La clase Form1 tiene un único método –además de todos los que hereda de la
clase Form-, que es estático y llamado Main(). Este es el punto de entrada de la
aplicación. Cuando se ejecuta el fichero Form1.exe, de hecho, se está llamando
al método Main() de ese fichero para comenzar en ese lugar la Aplicación.
static void Main()
•
El método Main() sólo tiene una única línea de código.
Application.Run(new Form1());
En realidad, la línea anterior podría haberse desdoblado en dos:
Form1 unFormulario = new Form1();
Application.Run(unFormulario);
En la primera se crea un objeto de la clase Form1 y en la segunda se le pasa ese
objeto al método Run().
Lo primero que hace el programa es llamar al constructor de la clase Form1 para
crear un objeto o instancia de la clase Form1 . Este objeto se le pasa al método
Run() de la clase Application.
•
Run() es un método estático de la clase Application. Si a este método se le
pasa un objeto que deriva de la clase Form comienza una aplicación estándar de
Windows, visualizándose la ventana correspondiente al objeto pasado como
argumento.
Run() proporciona una serie de métodos y propiedades para manejar una aplicación
como comenzar, terminar, parar y procesar los mensajes de Windows y para obtener
información sobre la aplicación. Esta clase no puede ser heredada.
En general, el método Run inicializa el bucle de mensajes de la aplicación en el hilo
actual y, opcionalmente, hace visible un formulario. Invocando los métodos Exit o
ExitThread se puede parar el bucle o el hilo. Puede llamar a DoEvents para procesar
los mensajes mientras el programa está en un bucle.
8/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Los métodos más importantes de clase Application son:
•
DoEvents()
Procesa todos los mensajes de Windows que están en la cola. Se puede pensar en
este método como un rápido camino para simular el comportamiento de un hilo.
•
Exit()
Termina la aplicación.
•
ExitThread()
•
Run()
Termina el hilo.
Sobrecargado. Comienza la aplicación.
La estructura de estos métodos son las siguientes:
public
public static void
public
public
public
static
contexto);
public static void
static
void
DoEvents();
Exit();
static
void
ExitThread();
static
void
Run();
void
Run(System.Windows.Forms.ApplicationContext
Run(System.Windows.Forms.Form formularioPrincipal);
En el ejemplo anterior, se podría invocar cualquiera de los miembros de la clase Form1.
Por ejemplo, se puede escribir un título en la cabecera de la ventana –con la propiedad
Text- o asignar un color de fondo al formulario con la propiedad BackColor. En este
último caso, se debe importar el namespace System.Drawing en donde se sitúa la clase
Color.
El código correspondiente es:
//Aplicacion Form2
//Fichero Form2.cs
using System.Windows.Forms;
using System.Drawing;
public class Form2 : Form
{
static void Main()
{
Form2 unFormulario = new Form2();
unFormulario.Text = "Primer Formulario";
unFormulario.BackColor=Color.Blue;
Application.Run(unFormulario );
}
}
Guarde este fichero con el nombre Form2.cs, compílelo y ejecútelo.
La salida de este programa es (figura 14.5):
9/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.5. Salida del programa Form2.exe
Cuando un formulario tiene como miembro un control, dicho control se visualizará con
el formulario. Se pueden añadir los controles que se deseen a un formulario. A
continuación se realiza una sencilla aplicación con un botón que cuando se pulsa cambia
el texto de su etiqueta y el título del formulario. Para ello, debe añadirse a la clase
Form3 un botón, como se indica a continuación:
//Aplicacion Form3
//Fichero Form3.cs
using System;
using System.Windows.Forms;
public class Form3 : Form
{
Button b;
public Form3()
{
b = new Button();
b.Text="Aceptar";
this.Text=”Tercera aplicación”;
b.Click += new EventHandler(b_Click);
this.Controls.Add(b);
}
private void b_Click(object sender, EventArgs e)
{
this.Text = "Acabo de pulsar el botón";
b.Text = “Pulsado”;
}
static void Main()
{
Form3 unFormulario = new Form3();
Application.Run(unFormulario );
}
}
Si se guarda el fichero con el nombre Form3.cs y se ejecuta la programa, la salida será
(Figura 14.6):
10/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.6. Salida del programa Form3.exe.
A continuación, se realizan algunas consideraciones sobre algunas líneas del programa
anterior:
•
using System;
Se importa el namespace System para poder tratar los eventos
•
Button b;
Se declara un botón en el formulario como miembro de la clase Form3.
•
b = new Button();
Se crea un objeto de tipo Button en el constructor de Form3
•
b.Click += new EventHandler(b_Click);
Se registra el evento Click del botón b para que sea manejado y tratado por el
método b_Click.
•
this.Controls.Add(b);
Se añade el botón b a la colección Controls de controles del formulario (this).
•
private void b_Click(object sender, EventArgs e)
{
this.Text = "Acabo de pulsar el botón";
b.Text = “Pulsado”;
}
Este es el método que se ejecuta cuando se pulsa el botón. En primer lugar se
modifica el texto del formulario (this) y posteriormente el del botón (b).
11/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Antes de realizar un programa parecido con el apoyo de Visual Studio, es interesante
hacer una introducción a los formularios.
Los Formularios
Como se ha venido diciendo Windows Forms es la nueva plataforma de desarrollo de
aplicaciones para Microsoft Windows. Está basada en el Framework .NET, ofreciendo
un conjunto de clases claro, orientado a objetos y extensible. Además, Windows Forms
puede actuar como interfaz de usuario local en soluciones distribuídas multi-capa.
Un formulario es un objeto o instancia de la clase System.Windows.Forms.Form. Es
una ventana, generalmente rectangular, que puede ser utilizada para presentar
información al usuario y aceptar una entrada del mismo. Los formularios pueden ser
ventanas normales, ventanas padre o hijo MDI, cuadros de diálogo, o simples
superficies para rutinas gráficas.
Los formularios son objetos que exponen propiedades que controlan su apariencia,
métodos que definen su comportamiento y eventos que proporcionan la posibilidad de
interacción con el usuario. La labor del desarrollador es establecer el valor de las
propiedades cuando sea necesario y escribir el código de respuesta a los eventos.
Es sencillo crear y diseñar un formulario. Para ello, si se utiliza Visual Studio .NET, se
puede añadir controles a su superficie arrastrándolos desde la caja de herramientas al
formulario. Una vez añadidos, cada uno de los controles pasa a ser miembro de esta
nueva clase que se está creando. Visual Studio va escribiendo el código correspondiente
de manera automática cada vez que el programador añade de manera visual un control
al formulario. Cuando se diseña un formulario se está creando una clase derivada de la
clase Form y cuando se muestra en pantalla en tiempo de ejecución, se está creando una
instancia de esa clase.
Aunque la creación, diseño, etc... de un formulario puede hacerse directamente desde
cualquier editor, el modo más cómodo, rápido y sencillo es utilizar el entorno Visual
Studio.
En la figura 14.7 se representa la jerarquía de herencia de la clase Form:
12/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Object
MarshalByRefObject
Component
Control
ScrollableControl
ContainerControl
Form
MiFormulario
Figura 14.7. Arbol de herencia de la clase Form.
Como se ha visto anteriormente, es posible utilizar un Form como la clase de inicio de
una aplicación. Para ello ha de contener el método Main con el código para crear y
mostrar el Form. Cuando se cierre el Form de inicio, la aplicación será también cerrada.
Cualquier formulario puede invocar cualquiera de los métodos y propiedades de las
clases de las que hereda. Por eso es fundamental conocer los detalles que implementan
cada clase base.
A través de la clase Form se pueden crear también ventanas MDI (Múltiple Document
Interface). En concreto, la propiedad IsMDIContainer puesta a true hace que un Form
sea de tipo MDI padre y la propiedad MDIParent conteniendo una referencia a una
ventana MDI hace que un Form sea de tipo MDI hijo.
En el siguiente capítulo se tratará con profundidad la clase Form junto con las demás
clases del namespace System.Windows.Forms
13/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Diseño de una aplicación básica con Visual Studio .NET
A continuación se va a diseñar una aplicación sencilla por medio de Visual Studio
.NET.
La aplicación “Hola Mundo”, mostrará el texto “Hola Mundo” en el título del
formulario de la aplicación.
Los pasos a realizar son:
•
Crear un proyecto “Aplicación para Windows”: Para ello, en el menú, seleccione
Archivo/Nuevo/Proyecto...(Figura 14.8)
Figura 14.8. Creando un nuevo proyecto.
•
En la pantalla que Visual Studio propone, escoja las siguientes opciones ( figura
14.9):
Tipo de Proyectos: Proyectos de Visual C#
Plantillas: Aplicación para Windows.
Nombre: HolaMundo (este será el nombre del proyecto).
Ubicación: La que se desee. Piense que el entorno creará un directorio –en la parte
inferior de la ventana se describe el path- con el nombre del proyecto donde se
ubicarán todos los ficheros necesarios para la aplicación. Pulse el botón Aceptar.
14/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.9. Ventana para describir un nuevo proyecto.
•
Se crea una aplicación que por defecto muestra un formulario vacío. Pulse con el
botón derecho sobre él y seleccione “Ver código”, como se indica en la figura
14.10.
Figura 14.10. Ventana de diseño del formulario.
15/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Aparece de manera automática la ventana donde se almacena el código
correspondiente a esta aplicación y que tiene de nombre Form1.cs. Pulsando sobre
las pestañas de la parte superior se puede intercambiar entre la ventana anterior (
Form1.cs [Diseño]) y la ventana de código Form1.cs. El código será parecido al
siguiente:
using
using
using
using
using
using
System;
System.Drawing;
System.Collections;
System.ComponentModel;
System.Windows.Forms;
System.Data;
namespace HolaMundo
{
public class Form1 : System.Windows.Forms.Form
{
private System.ComponentModel.Container components = null;
public Form1()
{
InitializeComponent();
}
protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
#region Windows Form Designer generated code
private void InitializeComponent()
{
this.components=new Container();
this.Size = new System.Drawing.Size(300,300);
this.Text = "Form1";
}
#endregion
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
}
}
Téngase en cuenta que aquí se han eliminado las líneas de comentarios. Es posible
que no puedan verse algunas de estas líneas. Puede ser que estén “comprimidas”.
Fíjese que en la ventana de código, en la parte izquierda aparece una línea gris
vertical con unos cuadros muy pequeños (figura 14.11). Algunos de ellos tienen un
16/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
signo + y otros con un signo -. El signo + significa que esas líneas de código están
comprimidas para poder ver mejor el código. Sin embargo, si el cursor del ratón
permanece unos instantes encima de una de ellas, aparece un cuadro con el código
que está oculto, como se indica en la figura 14.11. Para “descomprimir” el código,
se ha de pulsar sobre el signo +.
Figura 14.11. Ventana de código del formulario Form1.
La propiedad Text de la clase Form determina el título que se mostrará en la barra de
título del formulario. Bien directamente sobre el código –se ha señalado en negrita en el
código anterior-, o bien mediante la ventana de propiedades del formulario (figura
14.12) se puede cambiar esta propiedad. En el primer caso, sólo tiene que cambiar el
texto de la línea en negrita por la línea
this.Text = "HolaMundo";
Es posible que cuando se pulsa sobre una propiedad aparezca una pequeña descripción
de ella en la parte inferior de la ventana de propiedades. Si no se puede ver, pulse con
el botón derecho del ratón en la barra de herramientas de la ventana de propiedades
donde se indica en la figura 14.12 y escoja la opción “Descripción”.
17/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.12: Ventana de propiedades
•
•
Antes de compilar es recomendable guardar todos los ficheros de su aplicación:
Archivo/Guardar todo.
Para compilar la aplicación seleccione en el menú Generar/Generar. Si se hubiera
producido algún error, el entorno se lo hará saber en la ventana Resultados que
aparece en la parte inferior. En caso contrario, aparecerán los mensajes de error con
una pequeña descripción. Haciendo doble click sobre cada error, el cursor se sitúa
sobre la línea donde está el error en el código.
En caso de que la compilación haya sido satisfactoria, aparecerá en dicha pantalla el
aviso:
-------------------- Listo ---------------------Generar: 1 correctos, 0 incorrectos, 0 omitidos
•
Para ejecutar el programa: Depurar/Iniciar o pulse F5 o bien pulse sobre el icono
de color verde representado por un pequeño triángulo. El resultado que se obtiene es
el de la figura 14.13.
18/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
figura 14.13. Resultado de la ejecución del programa HolaMundo.
El entorno
Es importante conocer con detalle el entorno visual de programación que proporciona
Visual Studio .NET. El entorno de desarrollo integrado (IDE) permite diseñar el interfaz
gráfico de manera visual. El programador sólo tiene que arrastrar los controles que
desee hasta su lugar de destino en un formulario. En ese momento, el entorno añade el
código correspondiente a ese control en la ventana de código.
El IDE facilita mucho las cosas al programador porque proporciona una ventana de
propiedades que corresponde al control que esté seleccionado en cada momento. Basta
con ir asignando distintos valores a las propiedades de un control para que sin escribir
ningún código, el entorno lo escriba por defecto. La ventana de propiedades ayudará
mucho en la edición de los métodos que manipularán los eventos.
El editor de código es “inteligente” en el sentido de que sugiere métodos o parámetros
o nombres de controles conforme se escribe. Esta característica es de gran ayuda ya que
permite detectar con facilidad los errores que comete el programador al escribir su
código.
Cuando se arranca Visual Studio.NET por primera vez aparece esta pantalla (figura
14.14).
19/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.14: Pantalla inicial de Visual Studio.NET
Para aprovechar la potencia que ofrece el entorno, es necesario tener conexión a
Internet. Sin embargo, la opción “Mi Perfil”, proporciona la posibilidad de definir a
grandes rasgos el entorno de trabajo. El hecho de elegir algunas de estas opciones
acelera de modo considerable algunas funciones del entorno, como puede ser la ayuda.
Sin embargo, no es necesario definir ningún perfil para poder trabajar con el programa.
El entorno es realmente flexible y las posibilidades para el programador a la hora de
configurarlo son muchas. Por ello, es importante que se conozca cuáles son las
posibilidades que tiene y cómo se puede personalizar.
20/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.15: Entorno de trabajo de Visual Studio.NET
En la figura 14.15 se representa el entorno de trabajo en donde se pueden distinguir
varias zonas:
a) Ventana de diseño: aquí aparecen varias ventanas que se pueden localizar por
medio de sus correspondientes pestañas: la página de inicio, la de diseño y la de
código. Inicialmente esta última no aparece pero basta con pulsar con el botón
derecho sobre la ventana de diseño y escoger “Ver código”. En la ventana de
código, aparece una pequeña etiqueta de ayuda cuando se deja el cursor inmóvil
sobre un determinado método.
b) Cuadro de herramientas, donde están situados los controles más comunes.
Para añadir cualquiera de ellos al formulario hay que seleccionarlo y arrastrarlo
hasta él. Si no está disponible esta ventana, sitúe el ratón sobre el rectángulo de
texto “cuadro de herramientas” situado en el borde izquierdo de la pantalla o
bien sobre el icono situado en la parte superior derecha de la barra de
herramientas de Visual Studio, o en el menú seleccione Ver/Ventana de
herramientas o pulse Control+ALT+X.
c) Ventana de propiedades. Esta ventana visualiza las propiedades del objeto que
esté seleccionado. Pueden cambiarse las propiedades y el programa modifica el
código para que corresponda a lo que se ha introducido en esta ventana. Esto
también sucede de modo inverso: si se cambia una determinada propiedad en la
ventana de código, la modificación aparecerá en esta ventana de propiedades.
Sin embargo, es mejor realizar los cambios desde la ventana de propiedades.
Para verla, pulse F4 o en el menú elija Ver/Ventana de propiedades o pulse
sobre el icono correspondiente de la parte superior derecha en la barra de
21/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
herramientas de Visual Studio. En la ventana de propiedades los dos primeros
iconos de la parte superior izquierda permiten presentar la información de esta
ventana por categorías o por orden alfabético. Los dos siguientes permiten que
esta ventana visualice las propiedades o los eventos del control que está
seleccionado.
d) Una herramienta de incalculable valor es el Examinador de objetos que nos
permite, de un vistazo, estudiar los distintos métodos y propiedades de cada
clase o tipo (Figura 14.16). Para verlo, seleccione en el menú
Ver/OtrasVentanas/Examinador de objetos o pulse Control+ALT+J.
Observe que en la parte inferior se escribe la estructura completa del método o
propiedad elegida.
e) Se aconseja al lector que utilice la ayuda dinámica. Para ello, elija en el menú:
Ayuda/Ayuda dinámica. Se puede observar que cuando se escribe código, esta
ventana sugiere distintas posibilidades de ayuda.
Figura 14.16. El examinador de objetos
f) Otra estupenda y utilísima herramienta que proporciona Visual Studio es un
Visualizador de clases llamado WinCV, cuyo ejecutable se encuentra en el
directorio Microsoft.NET \ FrameworkSDK \ Bin. Tiene el aspecto de la
figura 14.17. Este visualizador informa de la ubicación de la clase –tanto del
namespace como del Assembly- y de su definición. Es muy sencillo recorrer sus
métodos, propiedades, etc.
:
22/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.17. Visualizador de clases WinCV.
Además, el explorador de soluciones y la ventana de vistas de clase ayudan
mucho en la construcción de proyectos. Si se pulsa con el botón secundario sobre el
nombre del proyecto en el explorador de soluciones (figura 14.18) es posible
añadir un nuevo formulario o clase al proyecto, etc. Se puede modificar el nombre
del fichero .cs bien desde la ventana de propiedades o bien pulsando con el botón
derecho, cambiando el nombre del fichero. Si se hace lo mismo sobre el nombre de
un formulario en la ventana de vista de clases se puede añadir una propiedad,
método, campo o indexador a la clase (figura 14.19).
23/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.18. Menú contextual del explorador de soluciones
24/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.19. Menú contextual de la vista de clases.
El entorno proporciona otra herramienta muy útil cuando se está trabajando en la
ventana de código de un proyecto de cualquier clase. Siempre que se guarde algo en el
portapapeles, ese texto queda almacenado en la barra de herramientas. Cuando se
necesite ese texto únicamente deberá arrastrarse el texto –como si fuera un controlhasta la ventana de código y se “pegará” en la ventana (figura 14.20).
Figura 14.20. Utilidad del cuadro de herramientas para almacener líneas de código.
Visual Studio incluye otras herramientas y opciones que ayudan a administrar un
proyecto y las diferentes ventanas del entorno.
El IDE admite dos modos de interfaz distintos: MDI (Interfaz de documentos múltiples)
y Organización por fichas. Pueden cambiarse los modos utilizando el panel General de
las opciones de Entorno en el cuadro de diálogo Opciones: Herramientas/Opciones:
Configuración.
25/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.21: Personalización del interfaz de usuario.
En el modo MDI, el IDE proporciona una ventana principal que sirve de contenedor
visual y lógico para todas las ventanas de herramientas y de documentos. Se pùede usar
CTRL+TAB para recorrer en ciclo los documentos abiertos en el editor. CTRL+TAB
funciona de forma similar a ALT+TAB, que recorre en ciclo los documentos abiertos
utilizados más recientemente.
En el modo de organización por fichas se tabula las ventanas de documentos de forma
conjunta. El IDE utiliza este modo de forma predeterminada. Para cambiar de una
ventana a otra basta con pulsar sobre la pestaña correspondiente, aunque también se
puede hacer pulsando las teclas Control+TAB. Si en un momento determinado se desea
ver un formulario concreto o su código correspondiente puede irse al explorador de
soluciones y pulsar con el botón derecho en el formulario concreto y elegir la opción
Ver Código.
El IDE contiene dos tipos básicos de ventanas: ventanas de herramientas y ventanas
de documentos. Los dos tipos de ventanas se comportan de forma algo distinta entre sí.
En el menú Ver se enumeran las ventanas de herramientas. Se pueden mostrar y
ocultar automáticamente, vincular con otras ventanas de herramientas, acoplar al IDE,
flotar. Se pueden abrir bien desde el menú o bien desde los iconos situados en la parte
superior derecha del entorno.
Se pueden acoplar o desacoplar las ventanas de herramientas activando o desactivando
la opción “Acoplable” en el menú Ventana o pulsando con el botón derecho en la parte
superior de la ventana en cuestión. Cuando una ventana de herramientas es acoplable,
“flota” por encima de las demás ventanas o se ajusta a un lado de la ventana de la
aplicación. Cuando una ventana de herramientas no es acoplable, aparece como una
ventana de documento. Para acoplar u ocultar ventanas de herramientas, se ha de
26/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
seleccionar Acoplable en el menú Ventana o con el botón derecho en el título de la
ventana y, a continuación, arrástrarla hacia un extremo de la ventana del entorno de
desarrollo hasta que pueda verse un esquema en la ubicación que se desee. Para mover
una ventana acoplable sin ajustarla a una posición, se ha presionar CTRL mientras es
arrastrada a la posición deseada.
Si se desea mover una ventana acoplable sin ajustarla a una posición, se ha presionar
CTRL mientras es arrastrada a la posición deseada.
Además, pueden mostrarse de una vez varias instancias de ciertas ventanas de
herramientas. Por ejemplo, puede mostrarse más de una ventana de código. Para ello, se
ha de elegir Nueva ventana en el menú Ventana. Para cerrarla puede pulsarse con el
botón derecho y elegir la acción Cerrar.
La opción “Ocultar automáticamente” permite ver más código de una vez; para ello,
hay que minimizar las ventanas de herramientas a lo largo de los extremos del entorno
de desarrollo integrado. En este estado minimizado, el nombre y el icono de la ventana
se ven en una ficha. Se dispone de fácil acceso a las ventanas moviendo el cursor sobre
la ficha de ventana para que aparezca a la vista desde el extremo del IDE. La ventana
vuelve a quedar oculta una vez que pierde el foco. Para colocar una ventana en estado
Ocultar automáticamente, se ha de hacer clic con el botón secundario del ratón en la
barra de título y elegir Ocultar automáticamente, o hacer clic en el icono de alfiler
situado en la barra de título de la ventana. Esta operación sirve para todas las ventanas
que están acopladas a la ventana.
Las ventanas de herramientas en estado Ocultar automáticamente se visualizan
temporalmente cuando la ventana posee el foco. Para ocultar de nuevo la ventana, hay
que seleccionar un elemento fuera de la ventana actual. Una vez que la ventana pierde el
foco, vuelve a quedar oculta.
Haciendo doble clic sobre una ventana de estas características aparece un botón a la
izquierda del botón habitual de cierre de ventana. Este botón permite ocultar estas
ventanas en la barra derecha del entorno, para que estén ocultas mientras no hagan falta.
Para que vuelvan a aparecer, basta con que el ratón esté sobre ellas un breve instante de
tiempo.
Estas ventanas también pueden acoplarse como pestañas en la parte inferior de cada una
de ellas. Se pueden “arrastrar” dichas pestañas para acoplar dichas ventana a otra.
Las ventanas de documentos se crean dinámicamente cuando se abren o crean archivos
u otros elementos. La lista de ventanas de documentos abiertos aparece en el menú
Ventana.
Algunas ventanas de documentos dentro del IDE son realmente ventanas de
herramientas que tienen el rasgo de acoplable desactivado. Para acoplar estas
ventanas, hay que elegir “Acoplable” en el menú Ventana.
Los nuevos documentos abiertos utilizarán la misma ventana mientras no se
haya modificado el documento actualmente abierto.
27/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Organizar ventanas
Es posible aumentar el espacio de presentación y edición del código dependiendo de
cómo se organicen las ventanas en el IDE. Existen diversas opciones para organizar
ventanas en el IDE, entre las que se encuentran las siguientes:
•
•
•
•
•
Vincular varias ventanas mediante fichas.
Acoplar ventanas de herramientas a un extremo del entorno de desarrollo.
Minimizar ventanas de herramientas a cualquier extremo del entorno de
desarrollo.
Colocar ventanas en distintos monitores.
Colocar en mosaico las ventanas de documentos.
Tipos de proyectos
Cuando se crea un nuevo proyecto, el entorno especifica la lista de opciones que están
disponibles a la hora de trabajar con Visual C#, que son las que se indican a
continuación. Sin embargo, algunas de ellas están pensadas para trabajar a partir de
algunas de las otras opciones.
•
•
•
•
•
•
•
•
•
•
•
Aplicación para Windows
Crea una aplicación con una interfaz de usuario de Windows
Biblioteca de clases
Crea clases que se van a utilizar en otras aplicaciones.
Biblioteca de controles de Windows
Crea controles que se van a utilizar en aplicaciones para Windows
Aplicación Web ASP.NET
Crea una aplicación con una interfaz de usuario Web
Servicio Web ASP.NET
Crea servicios Web que se van a utilizar desde otras aplicaciones
Biblioteca de controles Web
Crea controles que se van a utilizar en aplicaciones Web
Aplicación de consola
Crea una aplicación de línea de comandos.
Servicio de Windows
Crea servicios para Windows
Proyecto vacío
Proyecto vacío para crear una aplicación local
Proyecto Web vacío
Proyecto vacío para crear una aplicación Web
Nuevo proyecto en carpeta existente
Proyecto vacío creado en una carpeta existente
En los próximos capítulos se irán tratando cada una de estas opciones.
28/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Los controles.
Algunos miembros o campos de un formulario pueden ser objetos de la clase Control o
de alguna clase derivada de ella. Se les llama controles del formulario. Cada tipo de
control corresponde a una clase y tiene unas propiedades, métodos y eventos
particulares que permiten enriquecer la interfaz de usuario y la funcionalidad de una
aplicación.
Se pueden añadir controles a un formulario en tiempo de diseño, mediante el editor de
Visual Studio o también dinámicamente, es decir en tiempo de ejecución, lo cual
requiere codificación por parte del desarrollador.
Los controles más comunes que pueden ser utilizados en las aplicaciones de tipo
WinForms son los que aparecen en la barra de herramientas. En el siguiente capítulo se
estudiarán en profundidad los controles más comunes.
Adición de controles a un formulario.
Existen dos modos de añadir un control a un Form:
• Escribiendo directamente en la ventana de código. Por ejemplo, para añadir un
botón se escribiría:
...
...
//Se crea un objeto de la clase
Textbox texto = new Textbox();
//Se modifican algunas de sus propiedades
texto.Size = new Size(25,125);
texto.Location = new Point(25,25);
//Se añade al formulario
this.Controls.Add (texto);
...
...
•
Visualmente, por medio de Visual Studio. Añada, por ejemplo, al formulario de la
aplicación HolaMundo, una caja de texto y un botón. Lo único que se ha de hacer es
arrastrarlos desde el cuadro de herramientas hasta el formulario (ver figura 14.23):
29/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.23. Añadiendo controles a un formulario.
Una vez situados los dos controles sobre el formulario modifique las siguientes
propiedades, en la ventana de propiedades:
•
Botón:
Name: btnAceptar
Text: Aceptar
•
Caja de texto
Name: texto
Text: (Vacío)
El aspecto del formulario será (figura 14.24):
30/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Figura 14.24. Diseño de la aplicación HolaMundo.
Y el código fuente:
using
using
using
using
using
using
System;
System.Drawing;
System.Collections;
System.ComponentModel;
System.Windows.Forms;
System.Data;
namespace HolaMundo
{
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.Button btnAceptar;
private System.Windows.Forms.TextBox texto;
private System.ComponentModel.Container components = null;
public Form1()
{
InitializeComponent();
}
protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
#region Windows Form Designer generated code
31/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
private void InitializeComponent()
{
this.btnAceptar = new System.Windows.Forms.Button();
this.texto = new System.Windows.Forms.TextBox();
this.SuspendLayout();
//
// btnAceptar
//
btnAceptar.Location=new System.Drawing.Point(32,80);
this.btnAceptar.Name = "btnAceptar";
this.btnAceptar.TabIndex = 0;
this.btnAceptar.Text = "Aceptar";
//
// texto
//
texto.Location =new System.Drawing.Point(128,80);
this.texto.Name = "texto";
this.texto.TabIndex = 1;
this.texto.Text = "";
//
// Form1
//
AutoScaleBaseSize = new System.Drawing.Size(5, 13);
this.ClientSize = new System.Drawing.Size(264, 229);
this.Controls.AddRange(new
System.Windows.Forms.Control[] {
this.texto,
this.btnAceptar});
this.Name = "Form1";
this.Text = "HolaMundo";
this.ResumeLayout(false);
}
#endregion
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
}
}
Si se ejecuta la aplicación se verá el formulario tal y como ha sido diseñado, con los
controles Textbox y Button, pero éstos no responderán a las pulsaciones del usuario ya
que no se han programado para ofrecer una respuesta a los eventos que provoque el
usuario sobre ellos.
Sin embargo, los controles tienen un comportamiento por defecto ante la interacción del
usuario:
- Un Textbox permite que el usuario escriba en él.
- Un Button se “hunde” y “sube” cuando es pulsado a través del puntero de ratón (o
pulsando Enter cuando tiene el foco).
Conforme el usuario interactúa sobre el interfaz van ocurriendo los eventos.
32/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Los eventos.
Un evento es una acción a la cual se puede responder (se suele decir “manejar”) desde el
código.
Los eventos pueden ser generados por:
- Una acción del usuario. Por ejemplo: pulsar una tecla o un botón del ratón, o mover
el ratón.
- El código del programa.
- El sistema.
Las aplicaciones controladas por eventos ejecutan código en respuesta a distintos
eventos. Ese código ha de estar en métodos llamados manejadores de eventos.
Todo formulario y todo control exponen un conjunto de eventos predefinido que pueden
ser programados por el desarrollador. Si ocurre uno de tales eventos y el método
manejador del evento tiene código, entonces se ejecuta en código. En caso contrario no
ocurre nada.
Los tipos de eventos que pueden manejar y/o lanzar los objetos varían de unos objetos a
otros. Por motivos de herencia, existen ciertos eventos comunes a la mayoría de
controles. Un ejemplo es el evento Click. Este evento pertenece a la clase Control y lo
tendrán, por lo tanto, todos los controles que deriven de Control. Si el usuario hace
“Click” sobre un botón, se ejecuta el código que hay en el método manejador del evento
Click para ese botón, cuya declaración puede ser algo así:
private void btnAceptar_Click(object sender, EventArgs e)
{
}
Todo método manejador de evento tiene al menos dos parámetros:
•
sender: es una referencia al objeto que ha lanzado el evento. Por ejemplo, si se
pulsa un botón, sender es una referencia al botón que se ha pulsado.
•
e: es una referencia a un objeto de la clase EventArgs, que contiene información
sobre el evento.
Pero el método manejador en sí no tiene utilidad si no se asocia al evento, que va a
manejar. Por ejemplo,para responder a la pulsación de un botón sobre dicho formulario
es necesario asociar el evento Click del botón a un método manejador de dicho evento.
En ese caso, en el código del formulario es necesario añadir la siguiente instrucción:
//constructor del formulario
btnAceptar.Click += new System.EventHandler (this.btnAceptar_Click);
Se indica en esta línea que el evento Click sobre btnAceptar (btnAceptar.Click) va
a ser auditado o escuchado por un manejador de la clase System.EventHandler, el
cual direccionará o dirigirá el tratamiento del evento al método que recibe como
parámetro en su constructor y que es btnAceptar_Click (this indica que es un
método que pertenece al formulario).
33/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
Por supuesto, el método btnAceptar_Click debe estar implementado:
protected void btnAceptar_Click (object sender, System.EventArgs e)
{
...
...
...
}
Existen dos modos de implementar el tratamiento de eventos en una aplicación:
•
Añadiendo el código comentado al fichero o ficheros fuente de la aplicación
como ya se ha hecho anteriormente, en este mismo capítulo.
•
Utilizando el asistente del Visual Studio. A continuación se muestra cómo
hacerlo para la aplicación “HolaMundo”. Se desea que cuando se pulse el botón
btnAceptar se escriba “Hola Mundo” en la caja de texto texto.
El primer paso es seleccionar el control “btnAceptar” gráficamente o bien desde el
ComboBox situado en la parte superior derecha de la ventana propiedades (figura
14.25) y pulsar el icono “Eventos” –un pequeño rayo- situado en la parte superior
derecha de la ventana de propiedades. Al hacerlo, la ventana de propiedades
mostrará una lista con los eventos que soporta btnAceptar.
Figura 14.25: Eventos del botón btnAceptar en la ventana de propiedades.
34/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
•
Elija “Click”, haciendo doble click sobre su nombre. Aparece entonces la
ventana de código de la aplicación con el código de gestión del evento. El cursor se
sitúa en el lugar preciso para implementar el método.
Se puede observar que el entorno ha generado código de modo automático que asocia al
evento Click del botón al método btnAceptar_Click, manejador del evento. Además,
escribe el método manejador vacío con el cursor preparado en el lugar preciso para que
el programador sólo tenga que comenzar a escribir su código de gestión del evento
(figura 14.26).
Figura 14.26. Ventana de código.
•
A continuación, añada el código de gestión del evento Click a la función
btnAceptar_Click, que es el nombre que el IDE proporciona al método, por defecto.
Dicho nombre puede cambiarse de dos maneras: modificando el nombre directamente
en la ventana de código o bien haciéndolo en la ventana de propiedades. Si se desea
hacer, se ha de pulsar sobre la pestaña de diseño, seleccionar el botón y pulsar –una sola
vez, sólo para seleccionarlo- sobre el nombre del evento. Finalmente, se ha de
seleccionar todo y cambiarlo. Es más aconsejable hacer este tipo de cambios a través de
la ventana de propiedades en lugar de hacerlo directamente en la ventana de código.
En general, deben aceptarse los nombres que proporciona el IDE porque están siempre
compuestos por el nombre del control y por el del evento, separados por un guión bajo.
Sólo es una buena idea cambiarlos cuando un mismo método vaya a manejar varios
eventos de distintos controles.
35/37
Marco Besteiro y Miguel Rodríguez
Introducción a las Aplicaciones Windows
El código es:
protected void btnAceptar_Click (object sender, System.EventArgs e)
{
texto.Text = "Hola Mundo";
}
Observe que cuando se va escribiendo el código, el IDE proporciona una herramienta
“inteligente” de incalculable valor que ayuda a completar el código con mucha mayor
rapidez y posiblemente con muchos menos errores (figuras 14.27 y 14.28).
Figura 14.27
Figura 14.28
•
Cuando se está escribiendo el nombre del control, en mitad de la palabra, si se pulsa
simultáneamente las teclas Control y Barra espaciadora, aparecerá una pequeña
36/37
Marco Besteiro y Miguel Rodríguez
•
Introducción a las Aplicaciones Windows
ventana que indica la primera de las palabras que comienza por el texto escrito hasta
ese momento (figura 14.27). Si coincide con el que se desea, puede pulsarse la tecla
Aceptar o Enter y si no es así, se puede seguir tecleando o ir hacia arriba o hacia
abajo con las teclas de dirección. Una vez en la elección deseada, pulse la tecla
Enter.
Cuando se haya escrito el punto que separa el nombre del control de la propiedad o
el método, aparecerá otra ventana que se puede utilizar de la misma manera que la
anterior (figura 14.28). En ambos casos aparecerá la estructura del control o de la
propiedad o método, si se espera un instante.
Tras compilar y se puede ejecutar la aplicación. Si se pulsa el botón btnAceptar,
aparece “Hola Mundo” en la caja de texto como se indica en la figura 14.29.
Figura 14.29. Programa HolaMundo.
37/37