Java y C# son lenguajes muy parecidos, de hecho C# deriva de C++, Java y otros lenguajes alimentándose de lo bueno de cada uno; particularmente para mi es el mejor por su potencia y sus increíbles mejoras que nos hacen la programación mucho más fácil.

En el anterior post, describí una calculadora de números complejos en Java y en este, lo implemento con C# y WPF. Con esto intento tres cosas, en primer lugar demostrar que la clase (muy pero que muy similar a la de Java) es invariable porque me daría igual usar una aplicación de consola o gráfica, otra es que podáis ver la diferencia entre lenguajes pero la similitud estructural y por último implementarla mediante WPF con el cual nos vamos a ahorrar mucho código quedando la aplicación muy limpia y robusta y de camino os enseño como se aplican estilos a los controles.

Lo primero vayamos a la clase Complex. Las principales diferencias con la de Java son las que voy a enumerar.

1. Implemento la interfaz INotifyPropertyChanged de modo que la clase debe contener el evento public event PropertyChangedEventHandler PropertyChanged; el cual invocamos mediante el método OnPropertyChanged(string p_PropertyName) cada vez que cambia la propiedad de la parte real o imaginaria de un número complejo.
2. En esta clase, he sobrecargado las operaciones básicas de suma, resta, multiplicación, división y negación (a este operador le he asignado el opuesto). Para ver como lo he hecho, os paso el código de la operación suma con el que con un método

           public static Complex operator + (Complex _complex1, Complex _complex2)
           {
               return new Complex(_complex1.Real + _complex2.Real, _complex1.Imaginary + _complex2.Imaginary);
           }
   

   permitiéndome efectuar sumas sobre dos complejos.

A continuación paso el código completo de la clase.

/*************************************************************************************************************************************************
* © JOAQUIN MARTINEZ RUS 2015
* PROYECTO:        ComplexCalc. Calculadora de números complejos
* Archivo:         Complex.cs
* Descripción:     Clase de números complejos
* Historial:
*                  1. Joaquin Martínez Rus - 18 jul 2016. Creación
*
* Comentarios:
*
*
**************************************************************************************************************************************************/

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ComplexCal
{
    public class Complex: INotifyPropertyChanged
    {
        #region Constructor

        public Complex(double _real=0, double _imaginary=0)
        {
            this.Real = _real;
            this.Imaginary = _imaginary;
        }

        public Complex(Complex _complex)
        {
            this.Real = _complex.Real;
            this.Imaginary = _complex.Imaginary;
        }

        #endregion

        #region Propiedades

        private double real;
        private double imaginary;

        public event PropertyChangedEventHandler PropertyChanged;

        public double Module { get; set; }
        public double DegreesAngle { get; set; }
        public double RadiansAngle { get; set; }

        public double Imaginary
        {
            get { return imaginary; }
            set
            {
                imaginary = value;
                SetPolarComplex();
                OnPropertyChanged("Imaginary");
                OnPropertyChanged("ToString");
            }
        }

        public double Real
        {
            get { return real; }
            set
            {
                real = value;
                SetPolarComplex();
                OnPropertyChanged("Real");
                OnPropertyChanged("ToString");
            }
        }

        public string ToBinomialString
        {
            get
            {
                return "z = " + this.Real.ToString("F2") + (this.Imaginary < 0 ? " - " : " + ") + Math.Abs(this.Imaginary).ToString("F2") + " i";
            }
        }

        public string ToPolarString
        {
            get
            {
                return "z = " + this.Module.ToString("F2") + ") " + this.DegreesAngle.ToString("F1") + "°";
            }
        }

        public string ToString
        {
            get { return this.ToBinomialString + new string(' ',10) + this.ToPolarString; }
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Asigna el módulo y el argumento de un número complejo
        /// </summary>
        void SetPolarComplex()
        {
            this.Module= Math.Sqrt(Math.Pow(this.Real, 2) + Math.Pow(this.Imaginary, 2));
            this.RadiansAngle= Math.Atan2(this.Imaginary, this.Real);
            this.DegreesAngle = this.RadiansAngle * 180 / Math.PI;
        }

        #endregion

        #region Static Public Methods

        // SOBRECARGA DE LOS OPERADORES BÁSICOS

        public static Complex operator + (Complex _complex1, Complex _complex2)
        {
            return new Complex(_complex1.Real + _complex2.Real, _complex1.Imaginary + _complex2.Imaginary);
        }

        public static Complex operator - (Complex _complex1, Complex _complex2)
        {
            return new Complex(_complex1.Real - _complex2.Real, _complex1.Imaginary - _complex2.Imaginary);
        }

        public static Complex operator * (Complex _complex1, Complex _complex2)
        {
            return new Complex((_complex1.Real * _complex2.Real - _complex1.Imaginary * _complex2.Imaginary),
                (_complex1.Real * _complex2.Imaginary + _complex1.Imaginary * _complex2.Real));
        }

        public static Complex operator / (Complex _complex1, Complex _complex2)
        {
            double xx = (_complex1.Real * _complex2.Real + _complex1.Imaginary * _complex2.Imaginary) / (Math.Pow(_complex2.Real, 2) + Math.Pow(_complex2.Imaginary, 2));
            double yy = (_complex1.Imaginary * _complex2.Real - _complex1.Real * _complex2.Imaginary) / (Math.Pow(_complex2.Real, 2) + Math.Pow(_complex2.Imaginary, 2));
            return new Complex(xx, yy);
        }

        public static Complex operator ! (Complex _complex)
        {
            return new Complex(-_complex.Real, -_complex.Imaginary);
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Inicia el evento de cambio de propiedad
        /// </summary>
        /// <param name="p_PropertyName">Nombre de la propiedad</param>
        public void OnPropertyChanged(string p_PropertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(p_PropertyName));
            }
        }

        /// <summary>
        /// Efectúa una copia del objeto
        /// </summary>
        /// <param name="_complex">Objeto desde el cual se efectúa la copia</param>
        public void Clone(Complex _complex)
        {
            this.Real = _complex.Real;
            this.Imaginary = _complex.Imaginary;
        }

        /// <summary>
        /// Devuelve el conjugado de un número complejo
        /// </summary>
        /// <param name="complex">Número complejo al que se le calcula</param>
        /// <returns>Objeto Complex</returns>
        public Complex Conjugate(Complex complex)
        {
            return new Complex(complex.Real, -complex.Imaginary);
        }

        /// <summary>
        /// Devuelve el conjugado de un número complejo
        /// </summary>
        /// <returns>Objeto Complex</returns>
        public Complex Conjugate()
        {
            return Conjugate(this);
        }

        /// <summary>
        /// Determina cuando una instancia y un objeto tienen los mismos valores
        /// </summary>
        /// <param name="_complex">El objeto a comparar con la instancia</param>
        /// <returns>Valor booleano</returns>
        public bool Equals(Complex _complex)
        {
            if (_complex == null)
            {
                return false;
            }
            if (this.GetType() != _complex.GetType())
            {
                return false;
            }

            return this.Real == _complex.Real && this.Imaginary == _complex.Imaginary;
        }

        /// <summary>
        /// Obtiene el inverso del objeto Complex actual
        /// </summary>
        /// <returns>Objeto Complex</returns>
        public Complex Reverse()
        {
            return Reverse(this);
        }

        /// <summary>
        /// Obtiene el inverso de un objeto Complex
        /// </summary>
        /// <param name="_complex">Objeto Complex del que se obtiene el inverso</param>
        /// <returns>Objeto Complex</returns>
        public Complex Reverse(Complex _complex)
        {
            double denominador = Math.Pow(_complex.Real, 2) + Math.Pow(_complex.Imaginary, 2);
            return new Complex(_complex.Real / denominador, -_complex.Imaginary / denominador);
        }

        /// <summary>
        /// Retorna el objeto Complex en formato Polar
        /// </summary>
        /// <param name="isDegrees">La salida se muestra en grados sexagesimales</param>
        /// <returns>String</returns>
        public string PolarToString(bool isDegrees)
        {
            return this.Module.ToString("D1") + ")" + (isDegrees?this.DegreesAngle.ToString("D1"):this.RadiansAngle.ToString("D2"));
        }

        /// <summary>
        /// Retorna el objeto Complex en formato Polar
        /// </summary>
        /// <returns>String</returns>
        public string PolarToString()
        {
            return PolarToString(true);
        }

        #endregion
    }
}


Ahora damos paso al código XAML del formulario. Lo primero declaramos los recursos de la ventana con &lt;code&gt;Window.Resources&lt;/code&gt; y en este lugar, incluimos los estilos. He creado tres estilos, uno llamado &lt;span style='font-family: &quot;;&quot;;' data-mce-style='font-family: &quot;;'&gt;normal&lt;/span&gt; aplicado a los controles &lt;code&gt;TextBlock&lt;/code&gt;, otro llamado &lt;code&gt;header&lt;/code&gt; que hereda de normal y por tanto es aplicado a los mismos controles y un tercer estilo llamado &lt;code&gt;textBox&lt;/code&gt; aplicado a controles &lt;code&gt;TextBox&lt;/code&gt; (muy original, eh?), por tanto a cada control que le asigne este estilo se le aplicarán los valores de las propiedades incluidas en el estilo a no ser que se sobreescriban al crear el control.( En el control &lt;code&gt;TextBox&lt;/code&gt; he incluido un validador para que no se incluya texto que no sea numérico, pero eso lo veremos otro día)Una vez creados los estilos vamos a centrarnos en&amp;nbsp;el control &lt;code&gt;TextBlock&lt;/code&gt; del siguiente código: 
 
      <StackPanel x:Name="stackResult" Orientation="Horizontal" Grid.Column="2" Grid.Row="5" Grid.ColumnSpan="5">
            <TextBlock x:Name="result"  Style="{StaticResource header}" Text="Resultado" VerticalAlignment="Center"/>
            <TextBlock x:Name="labelComplexNumberResult" Style="{StaticResource normal}" Text="{Binding ToString}" Margin="123,0,0,0"/>
</StackPanel>  

1. Le asignamos un nombre
2. Le asignamos el estilo con Style="{StaticResource textBox}"
3. Le asignamos el valor enlazado de la propiedad Text con  la propiedad Real de la clase Complex. Style="{StaticResource textBox}" Text="{Binding Real}"¿Y de donde extrae los datos la propiedad Text?

Para que los controles sepan de donde tienen que extraer los datos de la clase Complex, al crear la ventana principal, asigno a cada StackPanel donde se encuentran contenidos los controles de cada número, la clase desde donde se alimentará y cada vez que se alteren los datos de cada clase, se visualizarán automáticamente en los controles sin necesidad de código. Por tanto en el code-behind de la ventana principal solo y exclusivamente incluyo la declaración de los tres objetos Complex, los dos de cálculo y el resultado, la asignación del DataContext de los StackPanel, los métodos de los eventos de cambio de propiedad y cambio de operación y el cálculo  de la operación.

/* ************************************************************************************************************************************************
* © JOAQUIN MARTINEZ RUS 2015
* PROYECTO:        ComplexCalc. Calculadora de números complejos
* Archivo:         MainWindow.cs
* Descripción:     Clase de la ventana principal
* Historial:
*                  1. Joaquin Martínez Rus - 18 jul 2016. Creación
*
* Comentarios:
*
*
**************************************************************************************************************************************************/
using System.Windows;
using System.Windows.Controls;

namespace ComplexCal
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        Complex c1 = new Complex(2,4);
        Complex c2 = new Complex(3,5);
        Complex ComplexResult=new Complex();

        public MainWindow()
        {
            InitializeComponent();

            // asignar a los Stackpanel el Datacontext de cada objeto Complex

            stackC1.DataContext = c1;
            stackC2.DataContext = c2;
            stackResult.DataContext = ComplexResult;

            // Crear evento para que cada vez que se cambie una propiedad, se calcule la operación
            c1.PropertyChanged += Complex_PropertyChanged;
            c2.PropertyChanged += Complex_PropertyChanged;

        }

        private void Complex_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            Calculate(comboBox.SelectionBoxItem.ToString());
        }

        private void comboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ComboBoxItem op = e.AddedItems[0] as ComboBoxItem;
            Calculate(op.Content.ToString());
        }

        /// <summary>
        /// Efectúa el cálculo entre dos complejos
        /// </summary>
        /// <param name="operatorToString">Operador</param>
        void Calculate(string operatorToString)
        {
            switch (operatorToString)
            {
                case "+":
                    ComplexResult.Clone(c1 + c2);
                    break;
                case "-":
                    ComplexResult.Clone(c1 - c2);
                    break;
                case "x":
                    ComplexResult.Clone(c1 * c2);
                    break;
                case "÷":
                    ComplexResult.Clone(c1 / c2);
                    break;
                case "Inverso":
                    ComplexResult.Clone(c1.Reverse());
                    break;
                case "Conjugado":
                    ComplexResult.Clone(c1.Conjugate());
                    break;
                case "Opuesto":
                    ComplexResult.Clone(!c1);
                    break;
            }

        }

    }
}

y el código XAML full:

<Window x:Class="ComplexCal.MainWindow"
        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:ComplexCal"
        mc:Ignorable="d"
        Title="Complex Calc" Height="480" Width="640">
    <Window.Resources>

        <Style x:Key="normal" TargetType="TextBlock">
            <Setter Property="VerticalAlignment" Value="Center"/>            
            <Setter Property="FontSize" Value="14"/>
            <Setter Property="FontFamily" Value="Segoe UI"/>
            <Setter Property="Height" Value="25"/>
            <Setter Property="Width" Value="Auto"/>
        </Style>
        <Style x:Key="header" TargetType="TextBlock" BasedOn="{StaticResource normal}">
            <Setter Property="FontWeight" Value="Bold"/>
            <Setter Property="VerticalAlignment" Value="Bottom"/>
            <Setter Property="HorizontalAlignment" Value="Center"/>            
        </Style>
        <Style x:Key="textBox" TargetType="TextBox">
            <Setter Property="VerticalAlignment" Value="Center"/>
            <Setter Property="Height" Value="25"/>
            <Setter Property="Width" Value="50"/>
            <Setter Property="HorizontalAlignment" Value="Center"/>
            <Setter Property="Validation.ErrorTemplate">
                <Setter.Value>
                    <ControlTemplate>
                        <DockPanel LastChildFill="true">
                            <Border Background="OrangeRed" DockPanel.Dock="right" Margin="5,0,0,0" 
                                Width="20" Height="20" CornerRadius="5"
                                ToolTip="{Binding ElementName=customAdorner, 
                                          Path=AdornedElement.(Validation.Errors)[0].ErrorContent}">
                                <TextBlock Text="!" VerticalAlignment="center" HorizontalAlignment="center" 
                                   FontWeight="Bold" Foreground="white" />
                            </Border>
                            <AdornedElementPlaceholder Name="customAdorner" VerticalAlignment="Center" >
                                <Border BorderBrush="red" BorderThickness="1" />
                            </AdornedElementPlaceholder>
                        </DockPanel>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
            <Setter Property="Margin" Value="20,0,0,0"/>
        </Style>
    </Window.Resources>
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="28*"/>
            <ColumnDefinition Width="27*"/>
            <ColumnDefinition Width="82*"/>
            <ColumnDefinition Width="132*"/>
            <ColumnDefinition Width="154*"/>
            <ColumnDefinition Width="60*"/>
            <ColumnDefinition Width="149*"/>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="49*"/>
            <RowDefinition Height="49*"/>
            <RowDefinition Height="49*"/>
            <RowDefinition Height="49*"/>
            <RowDefinition Height="49*"/>
            <RowDefinition Height="49*"/>
            <RowDefinition Height="155*"/>
        </Grid.RowDefinitions>
        <TextBlock x:Name="labelReal" Grid.Column="2" Grid.Row="1" Style="{StaticResource header}" Text="Real"/>
        <TextBlock x:Name="labelImaginaria" Grid.Column="3" Grid.Row="1" Style="{StaticResource header}" Text="Imaginaria"/>
        <TextBlock x:Name="labelNumberHeader" Grid.Column="4" Grid.Row="1" Style="{StaticResource header}" Text="Número complejo"/>
        <TextBlock x:Name="z1" Grid.Column="1" Grid.Row="2" Style="{StaticResource normal}" Text="z1" Margin="0,12"/>
        <TextBlock x:Name="z2" Grid.Column="1" Grid.Row="4" Style="{StaticResource normal}" Text="z2" Margin="0,12" />
        <TextBlock x:Name="op" Grid.Column="2" Grid.Row="3" Style="{StaticResource normal}" Text="Operación" Margin="0,12"/>
        <ComboBox x:Name="comboBox" Grid.Column="3" HorizontalAlignment="Left" Grid.Row="3" VerticalAlignment="Center" Width="80" Height="25" SelectionChanged="comboBox_SelectionChanged">
            <ComboBoxItem Content="+" IsSelected="True"/>
            <ComboBoxItem Content="-"/>
            <ComboBoxItem Content="x"/>
            <ComboBoxItem Content="÷"/>
            <ComboBoxItem Content="Inverso"/>
            <ComboBoxItem Content="Conjugado"/>
            <ComboBoxItem Content="Opuesto"/>
        </ComboBox>
        <StackPanel x:Name="stackC1" Orientation="Horizontal" Grid.Column="2" Grid.Row="2" Grid.ColumnSpan="5">
            <TextBox x:Name="textBoxReal1"  Style="{StaticResource textBox}" Text="{Binding Real}"/>
            <TextBox x:Name="textBoxImagin1" Style="{StaticResource textBox}" Text="{Binding Imaginary}"/>
            <TextBlock x:Name="labelComplexNumber1" Style="{StaticResource normal}" Text="{Binding ToString}" Margin="50,0,0,0" />
        </StackPanel>
        <StackPanel x:Name="stackC2" Orientation="Horizontal" Grid.Column="2" Grid.Row="4" Grid.ColumnSpan="5">
            <TextBox x:Name="textBoxReal2" Style="{StaticResource textBox}" Text="{Binding Real}"/>
            <TextBox x:Name="textBoxImagin2" Style="{StaticResource textBox}" Text="{Binding Imaginary}"/>
            <TextBlock x:Name="labelComplexNumber2" Style="{StaticResource normal}" Text="{Binding ToString}" Margin="50,0,0,0" />
        </StackPanel>
        <StackPanel x:Name="stackResult" Orientation="Horizontal" Grid.Column="2" Grid.Row="5" Grid.ColumnSpan="5">
            <TextBlock x:Name="result"  Style="{StaticResource header}" Text="Resultado" VerticalAlignment="Center"/>
            <TextBlock x:Name="labelComplexNumberResult" Style="{StaticResource normal}" Text="{Binding ToString}" Margin="123,0,0,0"/>
        </StackPanel>
    </Grid>
</Window>

Pues esto es todo, la clase Complex en C# y su ejecución bajo WPF con los controles enlazados.

Nos vemos. Saludos

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

Hola a tod@s

Aquí os muestro una pequeña calculadora de direcciones IP desarrollada en WPF y C# .NET 4.5 y con la que vemos una pequeña demostración de una clase y su funcionamiento.

El funcionamiento de la app es muy fácil, cuadros de texto para la IP y cuadro de texto para la máscara de subred con notación CIDR que quiere decir que el número introducido, indica el número de bits a 1 de la máscara de subred, es decir si introduzco 28, quiere decir que la máscara tiene 28 bit a 1, lo que sería:

el equivalente a 255.255.255.240.

A continuación adjunto la clase la cual no tiene ningún misterio (no he sido muy exquisito en cuanto a código, pero para aprender creo que está bien), propiedades públicas con los resultados y los métodos que si detallo:

Métodos públicos

• SetNetAddress. Asigna la dirección de red
• SetBroadCast. Asigna el Broadcast
• SetIPt. Asigna la dirección ip
• SetNetType. Asigna el tipo de red (A,B,C,D o E)
• SetHostMin.Asigna a la propiedad el valor de host mínimo de la red
• SetHostMax. Asigna a la propiedad el valor máximo de la red
• GetIPToString. Obtiene la IP como un valor de cadena de la forma XXX.XXX.XXX.XXX
• GetIPBinaryToString. Obtiene la IP como un valor de cadena en binario.

Métodos privados

• NotifyPropertyChanged. Método delegado del evento cuando no es válida la IP. De esta manera, desde la clase donde instancio esta, puedo capturar si la IP no es válida e indicarlo.
• BinaryToDecimal. Método sobrecargado para convertir números o direcciones ip de binario a decimal.
• DecimalToBinary. Método sobrecargado para convertir números o direcciones ip de decimal a binario.
• OperationOR. Operador OR sobre la dirección IP para obtener la máscara de entrada
• OperationAND. Operador AND sobre la la dirección IP para obtener el broadcast
• OperationNOT. Operador NOT sobre la la dirección IP para obtener el broadcast junto con el operador AND.
• ValidateIP. Valida la IP, comprobando que sus valores son correctos y está bien formada.

Nota: Recordad que para obtener la dirección del red, se realiza la operación AND entre la IP y la máscara de subred y que para obtener el broadcast, se utiliza el operador OR entre la IP y la NOT de la máscara de subred (donde hay ceros, cambio a unos y viceversa).

 

 

Si alguno ha dado el algebra de Boole, recordáis que a AND b= NOT (a OR b)?
solo hay que mirar la tabla AND y la OR, donde hay un 1 en la otra hay un 0!
y por último el símbolo de estos operadores (y de alguno más) es:
(una puerta NOR es una OR con una NOT, que es la que usamos para obtener el broadcast)

Para descargar la calculadora IP, pulsar aquí

Espero que os sirva y adjunto el código de la clase principal.

/* ************************************************************************************************************************************************
* © JOAQUIN MARTINEZ RUS 2015
* PROYECTO:         IpAddress Calculator
* Nombre:           AndrewWiles
* Archivo:          IpAddress.cs
* Descripción:      Clase principal
* Historial:
*                   1. Joaquin Martínez Rus - 13 ene 2016. Creación
*
* Comentarios:      Calculador de redes
*
*
**************************************************************************************************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.ComponentModel;

namespace AndrewWiles
{
    public class IpAddress:INotifyPropertyChanged
    {
        public IpAddress()
        {
            CreateArrays();
            this.IP = "0.0.0.0";

        }

        public IpAddress(string ip)
        {
            CreateArrays();
            this.IP = ip;

        }

        #region Propiedades, eventos

        public event PropertyChangedEventHandler PropertyChanged;

        private string _ip;

        public string IP
        {
            get { return _ip; }
            set
            {
                _ip = value;

                IsValidIP = this.ValidateIP();

                if (IsValidIP)
                {
                    ipNumbers = _ip.Split('.');

                    for (int i = 0; i < ipNumbers.Length; i++)
                    {
                        ipNumbersByte[i] = DecimalToBinary(ipNumbers[i]);
                    }
                }
            }
        }
        public string[] ipNumbers { get; set; }
        public string[] ipNumbersByte { get; set; }
        public string[] NetWorkAddress { get; set; }
        public string[] Broadcast { get; set; }
        public string[] NetMask { get; set; }
        public string[] HostMin { get; set; }
        public string[] HostMax { get; set; }

        public string IpClass { get; set; }
        public string NetID { get; set; }
        public string HostID { get; set; }
        public int Hosts { get; set; }

        private int netMaskCIDR;

        public int NetMaskCIDR
        {
            get { return netMaskCIDR; }
            set
            {
                netMaskCIDR = value;
                this.ConvertCIDRToNetMask();
            }
        }

        private bool isValidIP;

        public bool IsValidIP
        {
            get { return isValidIP; }
            set
            {
                isValidIP = value;
                NotifyPropertyChanged("ValidIP");
            }
        }

        #endregion

        #region Métodos públicos

        public void SetNetAddress()
        {
            this.NetWorkAddress = this.OperationAND(this.ipNumbers, this.NetMask);
        }

        public void SetBroadCast()
        {
            this.Broadcast= this.OperationOR(this.ipNumbers, this.OperationNOT(this.NetMask));
        }

        public void SetIP(string ip)
        {
            this.IP = ip;
        }

        public void SetNetType()
        {
            if (ipNumbersByte[0].Substring(0,1)=="0")
            {
                this.IpClass = "A";
            }
            if (ipNumbersByte[0].Substring(0, 2) == "10")
            {
                this.IpClass = "B";
            }
            if (ipNumbersByte[0].Substring(0, 3) == "110")
            {
                this.IpClass = "C";
            }
            if (ipNumbersByte[0].Substring(0, 4) == "1110")
            {
                this.IpClass = "D";
            }
            if (ipNumbersByte[0].Substring(0, 4) == "1111")
            {
                this.IpClass = "E";
            }

        }

        public void SetHostMin()
        {
            this.NetWorkAddress.CopyTo(this.HostMin,0);
            this.HostMin[3]= (Convert.ToInt16(this.HostMin[3]) + 1).ToString();
        }

        public void SetHostMax()
        {
            this.Broadcast.CopyTo(this.HostMax, 0);
            this.HostMax[3] = (Convert.ToInt16(this.HostMax[3]) - 1).ToString();
        }

        public string GetIPToString(string [] ip)
        {
            string ipToString = "";

            foreach (var item in ip)
         {
                ipToString += item + ".";
         }

            return ipToString.Substring(0, ipToString.Length - 1);
        }

        public string GetIPBinaryToString(string[] ip)
        {
            string ipToString = "";

            foreach (var item in ip)
            {
                ipToString += this.DecimalToBinary(item) + "  ";
            }

            return ipToString.Substring(0, ipToString.Length - 1);
        }

        #endregion

        #region Métodos privados

        #region Métodos de Eventos

        private void NotifyPropertyChanged(string property)
        {
            var handler = this.PropertyChanged;

            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(property));
            }
        }

        #endregion

        #region Operaciones Binarias

        private string[] BinaryToDecimal(string[] aByte)
        {
            string[] bytes = new string[4];

            for (int i = 0; i < aByte.Length; i++)
            {
                bytes[i] = BinaryToDecimal(aByte[i]);
            }

            return bytes;
        }

        private string BinaryToDecimal(string aByte)
        {
            double aux = 0;

            for (int i = 0; i < aByte.Length; i++)
            {
                double potencia = Math.Pow(2, i);
                double digito=Convert.ToInt16(aByte.Substring(aByte.Length-1-i,1));
                aux += (potencia * digito);
            }

            return aux.ToString();
        }

        private string[] DecimalToBinary(string[] aByte)
        {
            string[] bytes = new string[4];

            for (int i = 0; i < aByte.Length; i++)
            {
                bytes[i] = DecimalToBinary(aByte[i]);
            }

            return bytes;
        }

        private string DecimalToBinary(string aByte)
        {
            int entero=Convert.ToInt32(aByte);
            return Convert.ToString(entero,2).PadLeft(8,'0');
        }

        public string[] OperationOR(string[] ip1, string[] ip2)
        {
            string[] CalculoOR = new string[4];

            for (int i = 0; i < ip1.Length; i++)
            {
                int a= Convert.ToInt32(ip1[i]);
                int b= Convert.ToInt32(ip2[i]);
                string o = (a | b).ToString();
                CalculoOR[i] = o;
            }

            return CalculoOR;
        }

        public string[] OperationAND(string[] ip1, string[] ip2)
        {
            string[] CalculoAND = new string[4];

            for (int i = 0; i < ip1.Length; i++)
            {
                int a = Convert.ToInt32(ip1[i]);
                int b = Convert.ToInt32(ip2[i]);
                string o = (a &amp;amp;amp;amp;amp; b).ToString();
                CalculoAND[i] = o;
            }

            return CalculoAND;
        }

        public string[] OperationNOT(string[] ip)
        {
            string[] CalculoNOT = new string[4];

            for (int i = 0; i < ip.Length; i++)              {                  string number = this.DecimalToBinary(ip[i]);                   string notNumber = "";                  foreach (var item in number)                  {                      notNumber += item == '0' ? '1' : '0';                  }                  CalculoNOT[i] = this.BinaryToDecimal(notNumber);              }              return CalculoNOT;          }           #endregion          #region Cálculos con Direcciones          private void ConvertCIDRToNetMask()          {              string unos = "";              string ceros = "";              int resto = 32 - this.NetMaskCIDR;              string netmaskTemporal = unos.PadRight(this.NetMaskCIDR, '1') + ceros.PadRight(resto, '0');              string a = netmaskTemporal.Substring(0, 8);              string b = netmaskTemporal.Substring(8, 8);              string c = netmaskTemporal.Substring(16, 8);              string d = netmaskTemporal.Substring(24, 8);              this.NetMask[0] = BinaryToDecimal(a);              this.NetMask[1] = BinaryToDecimal(b);              this.NetMask[2] = BinaryToDecimal(c);              this.NetMask[3] = BinaryToDecimal(d);              this.Hosts = (int)Math.Pow(2, resto) - 2;          }          #endregion          #region Validaciones          private bool ValidateIP()          {              return ValidateIP(this.IP);          }          private bool ValidateIP(string ip)          {              bool isValid = false;              Regex regexip = new Regex(@"\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b");              MatchCollection result = regexip.Matches(ip);              if (result.Count > 0)
             {
                isValid = true;
             }
             else
             {
                isValid = false;
             }

            return isValid;
        }

        #endregion

        #region Genéricas

        private void CreateArrays()
        {
            ipNumbers = new string[4];
            ipNumbersByte = new string[4];
            NetWorkAddress = new string[4];
            Broadcast = new string[4];
            NetMask = new string[4];
            HostMin = new string[4];
            HostMax = new string[4];
        }

        #endregion

        #endregion
    }

    public class IPData
    {
        public IPData(string texto, string data, string binary)
        {
            this.Texto = texto;
            this.Data = data;
            this.Binary = binary;
        }

        public string Texto { get; set; }
        public string Data { get; set; }
        public string Binary { get; set; }

    }
}

Saludos