introducción a las aplicaciones windows - hasiera - … · en la primera parte del libro se ha...

Marco Besteiro y Miguel Rodríguez Introducción a las Aplicaciones Windows

1/37

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…


2/37

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:


3/37

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.


4/37

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


5/37

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.


6/37

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.


7/37

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;


8/37

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.


9/37

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() Termina el hilo.

• Run() Sobrecargado. Comienza la aplicación.

La estructura de estos métodos son las siguientes:

public static void DoEvents(); public static void Exit(); public static void ExitThread(); public static void Run(); public static void Run(System.Windows.Forms.ApplicationContext contexto); public static void 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):


10/37

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


11/37

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


12/37

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:


13/37

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

Object

MarshalByRefObject

Component

Control

ScrollableControl

MiFormulario

ContainerControl

Form


14/37

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.


15/37

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.


16/37

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 System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using 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


17/37

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


18/37

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.


19/37

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


20/37

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.


21/37

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


22/37

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.

:


23/37

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


24/37

Figura 14.18. Menú contextual del explorador de soluciones


25/37

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 control- hasta 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.


26/37

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


27/37

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.


28/37

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.


29/37

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


30/37

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


31/37

Figura 14.24. Diseño de la aplicación HolaMundo. Y el código fuente: using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using 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


32/37

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.


33/37

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


34/37

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.


35/37

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


36/37

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


37/37

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.

introducción a las aplicaciones windows - hasiera - … · en la primera parte del libro se ha...

Documents