Mensajería única (2)

Una vez que podemos pasar datos entre formularios como en la entrada Mensajería únicaWPF nos lo pone mucho más fácil y con mucho menos código.

Lo primero de todo debemos enlazar los controles con los datos de la clase y para ello debemos tener algún conocimiento de XAML y WPF (no es el fin de este artículo enseñar WPF)
Para llevar a cabo el paso de mensajes entre formularios mediante XAML, he creado una nueva ventana con un control Grid con tres columnas y tres filas, un control TextBlock y un control ProgressBar.
Las propiedades de los controles se enlazan con datos, estos datos proceden de una clase de negocio y esta clase es Message.

En WPF, para instanciar una clase, debemos hacerlo desde los recursos de la página o de un control, dependiendo del ámbito que se pretenda abarcar. En este caso, yo declaro la clase Message en los recursos del objeto Grid.
Una vez declarada, se creará una instancia de Message en cada nueva ventana y los controles se enlazan a la clase con Bindng en la propiedad del control que pretendemos enlazar y haciendo referencia a la propiedad de la clase Message. He incluido un conversor en la propiedad Visibility del control ProgressBar para convertir valores booleanos en valores de la enumeración Visibility como Visible, Hidden o Collapse; si es true, Visible y si es False, Collapse. En este caso hacemos los mismo, que es declarar la clase ConvertBoolToVisible (la cual implementa la interfaz IValueConverter) con una key llamada btv.

He hecho un binding sobre la propiedad Text del TextBlock a la propiedad infoText de la clase Message, la propiedad Value del control ProgressBar con la propiedad progress de Message y por último la propiedad Visibility con progressIsVisible ya su vez con el conversor btv.

<Window x:Class="WpfApplication1.Window2"         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"         xmlns:local="clr-namespace:WpfApplication1"         mc:Ignorable="d"         Title="Window2" Height="300" Width="300">

    <Grid x:Name="grid" DataContext="message">
        <Grid.Resources>
            <local:ConvertBoolToVisible x:Key="btv"/>
            <local:Message x:Key="message"/>
        </Grid.Resources>

        <Grid.RowDefinitions>
            <RowDefinition Height="100"/>
            <RowDefinition Height="100*"/>
            <RowDefinition Height="100*"/>
        </Grid.RowDefinitions>

        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="100*"/>
            <ColumnDefinition Width="100*"/>
            <ColumnDefinition Width="100*"/>
        </Grid.ColumnDefinitions>
        <TextBlock x:Name="tb" Text="{Binding infoText}" Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="3" HorizontalAlignment="Center" VerticalAlignment="Center"/>
        <ProgressBar x:Name="pb" Minimum="0" Maximum="100" Value="{Binding progress}"                      Visibility="{Binding Path=progressIsVisible, Converter={StaticResource btv}}"                      Grid.Column="0" Grid.Row="1" Grid.ColumnSpan="3" HorizontalAlignment="Center" Width="150" Margin="71,0,71,65"/>
    </Grid>
</Window>

Y el código (code-behind)? Muchísmo más reducido, ya que en este caso solo existe un objeto Message de clase, asignamos dinámicamente el DataContext del control Grid (que será desde donde se alimenten los controles) y añadimos el evento CollectionChanged.

Para este caso, he efectuado dos cambios en la clase Message:

  • Creación de un nuevo método público llamado Clone en la clase Message que copia las propiedades de un objeto Message al mismo objeto.
  • Implementación de la interfaz INotifyPropertyChanged por la clase Message de modo que debe implementar el método OnPropertyChanged para que la ventana detecte los cambios en las propiedades y pueda asignar los valores.
  • Creación del método OnPropertyChanged("propertyName") el cual llamará al evento this.PropertyChanged(this, new PropertyChangedEventArgs(p_PropertyName));
  • Modificación en el set de las propiedades, incluyendo la llamada al método OnPropertyChanged("propertyName").

Cada vez que se añada un nuevo mensaje, se clonará el objeto mensaje con los nuevos datos y se visualizarán en pantalla efectuando el mismo resultado que conseguimos mediante código, pero esta vez con menos código.

Clase Message modificada

using System;
using System.ComponentModel;

namespace WpfApplication1
{
    public class Message: INotifyPropertyChanged
    {
        #region Constructor

        public Message()
        {
            this.infoText = ""
            this.progress = 0;
            this.progressIsVisible = false;
        }

        public Message(string _text, bool _isVisible, int _progress)
        {
            setMessage(_text, _isVisible, _progress);
        }

        #endregion

        #region Properties

        private string _infotext;
        private int _progress;

        public int progress
        {
            get { return _progress; }
            set
            {
                _progress = value;

                OnPropertyChanged("progress");
            }
        }

        public string infoText
        {
            get { return _infotext; }
            set
            {
                _infotext = value;
                OnPropertyChanged("infoText");
            }
        }

        private bool _progressIsVisible;

        public bool progressIsVisible
        {
            get { return _progressIsVisible; }
            set
            {
                _progressIsVisible = value;
                OnPropertyChanged("progressIsVisible");
            }
        }

        public string infoText2 { get; set; }

        #endregion

        #region Events

        public event EventHandler<EventArgsMessage> ChangedTextEventHandler;
        public event EventHandler<EventArgsProgress> ChangedProgressEventHandler;
        public event PropertyChangedEventHandler PropertyChanged;

        public void OnPropertyChanged(String p_PropertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(p_PropertyName));
            }
        }

        #endregion

        #region Private Methods

        void OnChangedText(EventArgsMessage e)
        {
            if (ChangedTextEventHandler!=null)
            {
                ChangedTextEventHandler(this, e);
            }
        }

        void OnChangedProgress(EventArgsProgress e)
        {
            if (ChangedProgressEventHandler!=null)
            {
                ChangedProgressEventHandler(this, e);
            }
        }

        #endregion

        #region Public Methods

        ///
<summary>
        /// Asigna los valores al mensaje
        /// </summary>

        /// <param name="_text">Texto del mensaje
        /// <param name="_isVisible">Visibilidad del mensaje
        /// <param name="_progress">Progreso
        public void setMessage(string _text, bool _isVisible, int _progress)
        {
            this.infoText = _text;
            this.progressIsVisible = _isVisible;
            this.progress = _progress;
        }

        ///
<summary>
        /// Borra los valores del mensaje
        /// </summary>

        public void Clear()
        {
            setMessage("", false, 0);
        }

        ///
<summary>
        /// Efectua una copia de las propiedades de un mensaje
        /// </summary>

        /// <param name="message">Objeto a clonar
        public void Clone(Message message)
        {
            this.infoText = message.infoText;
            this.infoText2 = message.infoText2;
            this.progressIsVisible = message.progressIsVisible;
            this.progress = message.progress;
        }

        #endregion
    }

    public class EventArgsMessage:EventArgs
    {
        public EventArgsMessage() { }
        public EventArgsMessage (string _oldText, string _newText)
        {
            this.oldText = oldText;
            this.newText = _newText;
        }

        public string oldText { get; set; }
        public string newText { get; set; }
    }

    public class EventArgsProgress : EventArgs
    {
        public EventArgsProgress() { }
        public EventArgsProgress(int _newValue)
        {
            this.newValue = _newValue;
        }

        public int newValue { get; set; }
    }

}

Code-Behind de la ventana

public partial class Window2 : Window
    {
        public Window2()
        {
            InitializeComponent();
            App.messages.CollectionChanged += Messages_CollectionChanged;
            this.grid.DataContext = m;
        }

        Message m = new Message();

        private void Messages_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
            {
                foreach (var item in e.NewItems)
                {
                    m.Clone((Message)item);
                }
            }

        }
    }

He aquí una muestra

Pues esto es todo. Estoy a vuestra disposición para cualquier duda.

Un saludo

Anuncios

Mensajería única

Mensajería única
Estaba mejorando mi sistema de mensajería para mis aplicaciones y he pensado, ¿por qué no lo publicas?, pues ahí va. (Este en concreto es con WPF)
Cuando desarrollo mis aplicaciones, intento que todas tengan un sistema de mensajería con el que pueda comunicarse cualquier ventana de la aplicación con esta, de modo que generando un mensaje por ejemplo, “cargando caché de datos…” y una barra de progreso indique su estado, aparezca en la barra de estado o mediante un cuadro de dialogo, el mensaje “cargando caché de datos…” y la barra aumente su progreso, de modo que si tengo varias ventanas abiertas, podría visualizar los mismos mensajes en todas y esto mediante un ejemplo os lo voy a mostrar. Para comenzar creo una clase llamada Message que contiene cuatro propiedades, infoText que almacena el texto del mensaje principal, progress que almacena el valor del progreso, progressIsVisible que almacena si la barra de progreso es visible y por último infoText2 que almacena un segundo texto por si acaso lo necesito.
A esta clase le añado varios eventos, por si acaso los necesito, que son cuando cambia el texto del mensaje o cuando cambia el progreso. Extiendo varios EventArgs con EventArgsMessage para obtener los valores nuevo y antiguos y el valor del progreso EventArgsProgress. Contiene dos métodos, uno para asignar los valores de la propiedades y otro para borrarlos.
Por otra parte creo una colección del tipo ObservableCollection en la clase App de la aplicación de modo que cualquier ventana puede acceder a esta colección si la hacemos pública, la cual contiene un evento CollectionChanged el cual usaremos en cada ventana para capturar los mensajes.

public static ObservableCollection<Message>; messages = new ObservableCollection<Message>();

Y ahora solo nos queda capturar los eventos en cada ventana. Para ver esto, voy a crear una ventana principal que iniciará un hilo desde un botón con un proceso que suma desde 1 hasta 100 con un retardo de 50 ms y que en cada incremento, actualizará un control Textblock con el texto del mensaje y una barra de progreso con un valor. Al mismo tiempo, abriré otra ventana en la aplicación con un TextBlock y otra barra de progreso que deberían actualizarse de igual modo que lo hace la ventana principal y sin albergar ningún código en ella que le permita incrementar nada ni mostrar nada. Para mostrar el mensaje y actualizar las barras uso un delegado en cada ventana que se encargará de hacer este trabajo y para acceder a los controles sin errores, Dispatcher.Invoke(new MessageAddedHandler(setMessage), message) invocando al delegado y como argumento el nuevo mensaje. ¿Qué resultado obtendremos? Dos ventanas, la que contiene el botón y la que no. Al pulsar se inicia la carga y en ambas ventanas se actualizan tanto el texto como el valor de la barra de progreso al mismo tiempo.

Pasamos al código.

Clase Message

using System;
namespace WpfApplication1
{
    public class Message
    {
        #region Constructor
        public Message()
        {
            this.infoText = "";
            this.progress = 0;
            this.progressIsVisible = false;
        }
        public Message(string _text, bool _isVisible, int _progress)
        {
            setMessage(_text, _isVisible, _progress);
        }
        #endregion
        #region Properties
        private string _infotext;
        private int _progress;
        public int progress
        {
            get { return _progress; }
            set
            {
                if (_progress!=value)
                {
                }
                _progress = value;
            }
        }
        public string infoText
        {
            get { return _infotext; }
            set
            {
                if (_infotext!=value)
                {
                    EventArgsMessage eventArgsMessage = new EventArgsMessage(_infotext,value);
                }
                _infotext = value;
            }
        }
        public bool progressIsVisible { get; set; }
        public string infoText2 { get; set; }
        #endregion
        #region Events
        public event EventHandler<eventargsmessage> ChangedTextEventHandler;
        public event EventHandler<eventargsprogress> ChangedProgressEventHandler;
        #endregion
        #region Private Methods
        void OnChangedText(EventArgsMessage e)
        {
            if (ChangedTextEventHandler!=null)
            {
                ChangedTextEventHandler(this, e);
            }
        }
        void OnChangedProgress(EventArgsProgress e)
        {
            if (ChangedProgressEventHandler!=null)
            {
                ChangedProgressEventHandler(this, e);
            }
        }
        #endregion
        #region Public Methods
        ///
<summary>
        /// Asigna los valores al mensaje
        /// </summary>

        /// <param name="_text" />Texto del mensaje
        /// <param name="_isVisible" />Visibilidad del mensaje
        /// <param name="_progress" />Progreso
        public void setMessage(string _text, bool _isVisible, int _progress)
        {
            this.infoText = _text;
            this.progressIsVisible = _isVisible;
            this.progress = _progress;
        }
        ///
<summary>
        /// Borra los valores del mensaje
        /// </summary>

        public void Clear()
        {
            setMessage("", false, 0);
        }
        #endregion
    }
    public class EventArgsMessage:EventArgs
    {
        public EventArgsMessage() { }
        public EventArgsMessage (string _oldText, string _newText)
        {
            this.oldText = oldText;
            this.newText = _newText;
        }
        public string oldText { get; set; }
        public string newText { get; set; }
    }
    public class EventArgsProgress : EventArgs
    {
        public EventArgsProgress() { }
        public EventArgsProgress(int _newValue)
        {
            this.newValue = _newValue;
        }
        public int newValue { get; set; }
    }
}

Clase <code>App</code>

public partial class App : Application
    {
        public static ObservableCollection<message> messages = new ObservableCollection<message>();

        public App()
        {

        }
    }

Ventana principal con método de cálculo

Constructor

public MainWindow()
        {
            InitializeComponent();
            App.messages.CollectionChanged += Messages_CollectionChanged;
            Window1 w1 = new Window1();
            w1.Show();
        }

Propiedades. El delegado, un objeto CancellationTokenSource para cancelar el proceso y un flag para saber si la app está corriendo o no.

        delegate void MessageAddedHandler(Message _message);
        CancellationTokenSource cs;
        public bool isRunning { get; set; } = false;

Captura del evento. Ocurre cuando la colección cambia.

void Messages_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action==System.Collections.Specialized.NotifyCollectionChangedAction.Add)
            {
                foreach (var item in e.NewItems)
                {
                    Dispatcher.Invoke(new MessageAddedHandler(setMessage), (Message)item);
                }
            }
            else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset)
            {
                Dispatcher.Invoke(new MessageAddedHandler(setMessage), new Message());
            }

        }

Métodos. El primer método asigna un mensaje a los controles, el segundo inicia el proceso o lo cancela y el tercero suma 1 después de 50 ms: una vez que acaba, finaliza y borra los mensajes.

void setMessage(Message message)
        {
            this.textBlock.Text = message.infoText;
            this.pb.Value = message.progress;
            this.pb.Visibility = message.progressIsVisible ? Visibility.Visible : Visibility.Collapsed;
        }

         private void button_Click(object sender, RoutedEventArgs e)
        {
            if (isRunning)
            {
                this.button.Content = "Iniciar";
                cs.Cancel();
            }
            else
            {
                isRunning = true;
                cs = new CancellationTokenSource();
                this.button.Content = "Cancelar";
                var t = Task.Factory.StartNew(() => doSomeThing(cs.Token),cs.Token);

            }
        }
        void doSomeThing(CancellationToken ct)
        {
            try
            {
                for (int i = 0; i <= 100; i++)
                {
                    ct.ThrowIfCancellationRequested();
                    Thread.Sleep(50);
                    App.messages.Add(new Message(String.Format("Cargando {0}", i), true, i));
                }
                App.messages.Clear();
            }
            catch (OperationCanceledException ex)
            {
                isRunning = false;
                App.messages.Clear();
                return;
            }
        }

Ventana que captura mensajería. En esta ventana solo se captura el evento cuando la colección cambia y la asignación de los valores al mensaje.

public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
            App.messages.CollectionChanged += Messages_CollectionChanged; ;
        }
        delegate void MessageAddedHandler(Message _message);
        private void Messages_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
            {
                foreach (var item in e.NewItems)
                {
                    Dispatcher.Invoke(new MessageAddedHandler(setMessage), (Message)item);
                }
            }
            else if (e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Reset)
            {
                Dispatcher.Invoke(new MessageAddedHandler(setMessage), new Message());
            }
        }
        void setMessage(Message message)
        {
            this.textBlock.Text = message.infoText;
            this.pb.Value = message.progress;
            this.pb.Visibility = message.progressIsVisible ? Visibility.Visible : Visibility.Collapsed;
        }
    }
}

y con todo funcionando, cada vez que iniciemos desde la ventana principal el proceso, las dos ventanas deben mostrar el mismo texto y el mismo progreso.Os dejo el proyecto completo en el enlace.

Saludos