Feeds:
Entradas
Comentarios

Posts Tagged ‘VisualStudio’

La forma más sencilla de crear una aplicación WPF, con el wizard de Visual Studio. Aunque esta es una forma sencilla, no nos enseña a comprender todo lo que hace para que nuestra aplicación funcione y justamente eso es lo que aprenderemos en este post.

Que hace Visual Studio cuando creamos una nueva aplicación WPF?

La comprensión de cómo en WPF se crea un aplicación nos va a permitir crear todo esa “plomería” en forma manual, permitiéndonos hacer incluso Custom Applications para poder realizar las tareas que necesitemos al iniciar nuestra aplicación.

Cuando el Wizard de Visual Studio crea una aplicación WPF crea dos partes, una que no es visible y que se similar a la siguiente:


///<summary>
App</summary>

[System.CodeDom.Compiler.GeneratedCodeAttribute(“PresentationBuildTasks”, “4.0.0.0”)]
public partial class App : System.Windows.Application {

///<summary>
InitializeComponent</summary>

[System.Diagnostics.DebuggerNonUserCodeAttribute()]

public void InitializeComponent()

{

#line 4 “..\..\..\App.xaml”
this.StartupUri = new System.Uri(“MainWindow.xaml”, System.UriKind.Relative);

#line default

#line hidden

}

///<summary>
/// Application Entry Point.

///</summary>

[System.STAThreadAttribute()]

[System.Diagnostics.DebuggerNonUserCodeAttribute()]
public static void Main()

{

NormalApplication.App app = new NormalApplication.App();

app.InitializeComponent();

app.Run();

}

}

Para ver este código tenemos que abrir el archivo: App.g.cs en la carpeta obj\Debug dentro del directorio del proyecto.

La parte que normalmente vemos y podemos editar nosotros es la que se encuentra en el archivo App.xaml.cs

namespace NormalApplication

{
///<summary>

/// Interaction logic for App.xaml

///</summary>

public partial class App : Application{

}

}

Creando la aplicación a mano

Para crear la aplicación a mano, lo primero que tenemos que hacer es crear una clase a la que deberemos indicar desde las propiedades de la aplicación que es la que instanciará la ventana principal.

Si observamos en el siguiente código, lo primero que se hace es crear la aplicación, luego creamos la ventana que será la principal y finalmente llamamos al método Run del objeto application y le pasamos la ventana como parámetro.


public class StartUp

{

[STAThread] static void Main()

{
//Creo el objeto Application

var app = new Application();

//Creo la ventana

MainWindow w = new
MainWindow();

app.Run(w);

}

}

Para configurar cual es el método que va a lanzar nuestra aplicación tenemos que ir al as propiedades del proyecto y setear el startup object con el nombre de la clase que tiene el método Main, como se muestra en la figura:

Esto es todo lo que tenemos que hacer para hacer nuestro propio Startup. Si bien esto no parece tener mucha importancia a simple vista, más Es importante comprender como funciona.

Manejando los eventos de la página

Si tenemos necesidad de manejar los eventos de la página, entonces este ultima forma de crear las aplicaciones en forma manual, ya no sirve. Si nos fijamos en el Application creado por VisualStudio, podemos ver que la clase Main esta heredando de la clase Application, es decir que para poder crear una custom application que maneje los eventos de la página deberemos heredar de la clase Application.

El manejo de los eventos de las páginas para ambos casos es igual se hace en la clase principal, es decir la clase que inicializa la aplicación, ya sea que este esté separada en una o varias Partial Clases o que este toda en una sola clase.

Los eventos a nivel Application Class que podemos manejar son:

  • Startup: Se dispara inmediatamente después de llamarse al método Application.Run(). Este evento normalmente se usa cuando se hace una aplicación de consola, para revisar los parámetros que recibe la aplicación.
  • Exit: Se dispara en el momento en que la aplicación se cierra por cualquier motivo. Se dispara justo antes de que el método Application.Run() finalice. En este evento, ya no podemos evitar que la aplicación finalice. Este método lo podríamos usar para devolver un valor o lanzar alguna otra aplicación o volver a ejecutar la misma aplicación en forma recursiva, por ejemplo
  • SessionEnding: se dispara cuando finaliza una sesión de Windows por cualquier motivo. Para saber cuál es el motivo por el que se dispara el evento, podemos investigar la propiedad SessionEndingCancelEventArgs.ReasonSessionEnding. Desde este evento, si podemos detener el cierre de la aplicación, seteando la propiedad SessionEndingCancelEventArgs.Cancel
    en true; si no se setea esta propiedad, a continuación de este evento, se llama al Application.Shutdown().
  • Activated: Sucede cuando una de las ventanas en la aplicación se vuelve activa. Normalmente esto sucede cuando se pasa de un programa a otro, ademar de dispararse la primera vez que se abre una ventana de la aplicación.
  • Deactivated: Análogamente al evento anteriormente mencionado, este evento se dispara cuando la aplicación pierde el foco.
  • DispatcherUnhandledException: Se dispara cuando ocurre una excepción que no fue manejada en cualquier parte de la aplicación, una aplicación normal de este evento, sería el de loguear errores.

Para manejar estos eventos tenemos dos maneras posibles: podemos atachear un manejador de eventos o podemos sobrescribir el método correspondiente. Por otro lado tenemos que indicarle a la aplicación que método va a ser el que maneja a un evento, para esto basta con attachearlo usando un atributo en el App.xaml.

En el App.xaml quedaría algo asi:

<Application x:Class=”WindowsPresentationFundationApplication.App”

xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation&#8221;

xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml&#8221;

StartupUri=”Window1.xaml”

Startup=”OnStartup”>

</Application>

En el codebehind bastaría con sobreescribir el método OnStartup, quedaría de la siguiente manera:

public partial class App : Application

{

private bool unsavedData = false;

public bool UnsavedData

{

get { return unsavedData; }

set { unsavedData = value; }

}

protected override void OnStartup(StartupEventArgs e)

{

base.OnStartup(e);

UnsavedData = true;

}

}

Si prestamos atención, notaremos que no hay un evento atacheado de la forma normal en que se hace, sino que estamos sobrescribiendo un método ya existente, esto es porque estos métodos ya son parte de la clase base Application, es por esto que es una buena idea, siempre llamar al método de la clase base, por si este hace alguna tarea adicional que desconozcamos.

Conclusión

En este artículo aprendimos como se crea la clase Application y la importancia que la misma tiene. También vimos cuales son los eventos a nivel aplicación y como indicarle a nuestra aplicación que esos eventos están disponibles y que los tiene que usar y finalmente vimos que tenemos dos formas de manejar los eventos, o sobrescribimos los de la clase base, o lo manejamos como cualquier otro evento en C#.

En el siguiente artículo, trataremos tareas más especificas que se hacen a partir del manejo de estos eventos, como por ejemplo, que no se pueda abrir dos veces la misma aplicación, o trabajar con varias ventanas que interactúan dentro de nuestra aplicación.

Read Full Post »