Luis Guerrero Hablando de .NET, Silverlight, WPF, Windows Phone 7 y depuración

15Jul/0868

[Curso] WPF para programadores de Windows Forms – Parte 3

Ahora que ya hemos las diferencias entre las arquitecturas en WPF y Windows Forms es el momento de comparar como se programa en ambas tecnologías. Vamos a comparar cuales son las características para programar con WPF y WF, además de hacer el típico Hola Mundo.

Ambas tecnologías se programan con algún lenguaje incluido en .net framework, WF viene desde la versión 1.0 del framework, mientras que WPF viene incluido en la versión 3.0, 3.0 SP1, 3.5 y 3.5 SP1.

En WPF tenemos dos maneras de definir la interfaz de usuario de nuestros programas, a través de código trasero o a través de XAML. Es algo parecido a como se programa en ASP.NET, se tiene un fichero con extensión aspx que contiene el html y el código de los controles de servidor de ASP.NET y además tenemos el fichero de código trasero asociado con este fichero aspx, por ejemplo podemos tener un Default.aspx y un Default.aspx.cs. Los dos ficheros están asociados a través de la clase que contienen.

Pues bien en WPF es igual, tenemos un fichero Window1.xaml que contiene el código XAML de la UI de la ventana y además tenemos el Window1.xaml.cs que contiene el fichero de código fuente asociado a este fichero xaml. En WPF, como en ASP.NET, se tiene que asociar de alguna manera el fichero xaml con el fichero cs para que se pueda acceder a los controles definidos en el xaml. Por ejemplo tenemos un fichero Window1.xaml definido así

<Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        x:Class="WpfApplication1.Window1"
        x:Name="Window"
        Title="Window1"
        Width="640" Height="480">
    <Grid x:Name="LayoutRoot"/>
</Window>

Y tenemos otro fichero Window1.xaml.cs definido de esta manera:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace WpfApplication1
{
    /// <summary>
    /// Interaction logic for Window1.xaml
    /// </summary>
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }
}

Si nos fijamos en el fichero Window1.xaml.cs está definido un namespace WpfApplication1 y este contiene una clase parcial Window1 que hereda de Syste.Windows.Window, pues bien esta clase Window1 es la que contiene la lógica de la ventana que estamos creando. En el fichero Window1.xaml dentro del nodo Window hay un atributo del namespace {x} definido así xmlns:x=http://schemas.microsoft.com/winfx/2006/xaml y este tiene una propiedad Class en que está establecido el nombre de la clase a la que está asociada esta ventana, hay que tener en cuenta que esta el namespace completo WpfApplication1.Window1 y no directamente Window1, esto es porque después la clase se localizará por reflexión y dentro en la definición de IL no existen namespaces como en C# así que técnicamente el nombre de esa clase no es Window1, sino WpfApplication1.Window1.

Esta sería la manera de asociar un fichero xaml con su correspondiente fichero cs de code behind. Nosotros en este primer ejemplo de Hola Mundo lo vamos a hacer directamente el código todo para familiarizarnos con el entorno y con las clases que hay disponibles.

Primero vamos a definir el código fuente mínimo necesario para insertar un botón dentro de un formulario y al pulsar ese botón que salga un mensaje de Hola Mundo. Así sería en Windows Forms

using System;
using System.Drawing;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{

    static class Program
    {
        [STAThread]
        static void Main()
        {
            Form form = new Form();
            Button button = new Button();
            button.Text = "Hola Mundo Windows Forms";
            button.Location = new Point(10, 10);
            button.Click += new EventHandler(OnButtonClick);
            form.Controls.Add(button);
            Application.Run(form);
        }

        static void OnButtonClick(object sender, EventArgs e)
        {
            MessageBox.Show("Hola mundo WF");
        }
    }
}

Y así sería en WPF.

using System;
using System.Windows;
using System.Windows.Controls;

namespace WpfApplication1
{
    class Program
    {
        [STAThread]
        public static void Main()
        {
            Window window = new Window();
            Button button = new Button();
            button.Content = "Hola Mundo Windows Presentation Foundation";
            button.Click += new RoutedEventHandler(OnButtonClick);
            window.Content = button;
            Application app = new Application();
            app.Run(window);
        }

        static void OnButtonClick(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Hola Mundo WPF");
        }
    }
}

El código generado es muy parecido, pero podemos ver alguna de las características que hemos estado comentando de WPF. Por ejemplo Window hereda de ContentControl con lo que no tiene una propiedad Controls sino un Content (object) en el que establecemos el botón. El objeto Application en Windows Forms es directamente un singleton, mientras que en WPF tienes que crear una instancia de tu propia aplicación o heredad de esta clase y llamar al método Run, de instancia y no estático como en WF.

En los siguientes post me centraré en WPF y empezaré a hablar de características especificas de WPF.

Espero que os guste.

Luis.

¿Te ha gustado este artículo?

¡Considera subscribirte al RSS para estar al día!

Filed under: .Net, Windows, WPF -> Windows Forms Leave a comment