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.
Una vez creados los estilos vamos a centrarnos en el control TextBlock del siguiente código:
Nos vemos. Saludos
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.
- 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.
- 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
///
/// Asigna el módulo y el argumento de un número complejo
///
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
///
/// Inicia el evento de cambio de propiedad
///
/// Nombre de la propiedad
public void OnPropertyChanged(string p_PropertyName)
{
if (this.PropertyChanged != null)
{
this.PropertyChanged(this, new PropertyChangedEventArgs(p_PropertyName));
}
}
///
/// Efectúa una copia del objeto
///
/// Objeto desde el cual se efectúa la copia
public void Clone(Complex _complex)
{
this.Real = _complex.Real;
this.Imaginary = _complex.Imaginary;
}
///
/// Devuelve el conjugado de un número complejo
///
/// Número complejo al que se le calcula
/// Objeto Complex
public Complex Conjugate(Complex complex)
{
return new Complex(complex.Real, -complex.Imaginary);
}
///
/// Devuelve el conjugado de un número complejo
///
/// Objeto Complex
public Complex Conjugate()
{
return Conjugate(this);
}
///
/// Determina cuando una instancia y un objeto tienen los mismos valores
///
/// El objeto a comparar con la instancia
/// Valor booleano
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;
}
///
/// Obtiene el inverso del objeto Complex actual
///
/// Objeto Complex
public Complex Reverse()
{
return Reverse(this);
}
///
/// Obtiene el inverso de un objeto Complex
///
/// Objeto Complex del que se obtiene el inverso
/// Objeto Complex
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);
}
///
/// Retorna el objeto Complex en formato Polar
///
/// La salida se muestra en grados sexagesimales
/// String
public string PolarToString(bool isDegrees)
{
return this.Module.ToString("D1") + ")" + (isDegrees?this.DegreesAngle.ToString("D1"):this.RadiansAngle.ToString("D2"));
}
///
/// Retorna el objeto Complex en formato Polar
///
/// String
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 Window.Resources y en este lugar, incluimos los estilos. He creado tres estilos, uno llamado normal aplicado a los controles TextBlock, otro llamado header que hereda de normal y por tanto es aplicado a los mismos controles y un tercer estilo llamado textBox aplicado a controles TextBox (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 TextBox 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 el control TextBlock del siguiente código:
<StackPanel x:Name="stackResult" Orientation="Horizontal" Grid.Column="2" Grid.Row="5" Grid.ColumnSpan="5">
<TextBox x:Name="textBoxReal1" Style="{StaticResource textBox}" Text="{Binding Real}"/>
<TextBlock x:Name="labelComplexNumberResult" Style="{StaticResource normal}" Text="{Binding ToString}" Margin="123,0,0,0"/>
</StackPanel>
- Le asignamos un nombre
- Le asignamos el estilo con Style="{StaticResource textBox}"
- 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?
/* ************************************************************************************************************************************************
* © 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
{
///
/// Interaction logic for MainWindow.xaml
///
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());
}
///
/// Efectúa el cálculo entre dos números complejos
///
/// Operador
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
No hay comentarios:
Publicar un comentario