WPF – Controls Part 2 en 0:45

Hola a todos, hoy es tiempo de …Controles WPF.

De nuevo vuelvo a escribir al tiempo, esto es porque de nuevo tuve algunos problemas con mi research. Bueno, continuando con la serie de post sobre controles de WPF hoy veremos 3 controles: Expander, ListBox y ComboBox.

Expander

En lo personal me agrada mucho este control puesto que nos brinda una experiencia bastante interesante y atractiva, oculta y muestra controles o información sin tener que hacer grandes roturas de cabezas para crearlo.

A continuación un fragmento de un expander.

   1: <Expander Header="This is a Expander" 

   2:     Name="ExpanderFirst" Padding="3" Margin="15,22,0,96" 

   3:     HorizontalAlignment="Left" Width="129" 

   4:     Collapsed="Expander_Collapsed" Expanded="ExpanderFirst_Expanded">

   5: </Expander>

En el código anterior podemos ver que posee propiedades comunes que ya comentamos en el anterior post. Una propiedad caracteristica de este control es “Header”, la cual contiene la información que se mostrará en la cabecera del control. Collapsed y Expanded hacen referencia a los eventos que manejará este control.

El resultado del anterior código es el siguiente.

ListBox

Otro sobreviviente de los windows form. Según creo yo este control esta muy bueno y esta en su version mejorada y aumentada.

He acontinuación otro fragmento de código de este control.

   1: <ListBox Height="68" Name="listBox1" Width="120" 

   2:     Background="Silver" SelectionChanged="listBox1_SelectionChanged">

   3:     <ListBoxItem>Item1</ListBoxItem>

   4:     <ListBoxItem Background="Silver" BorderBrush="AliceBlue" Foreground="Azure">Item 1.5</ListBoxItem>

   5:     <ListBoxItem Foreground="Blue">Item2</ListBoxItem>

   6: </ListBox>

Bueno que se puede comentar aca … sigue con las propiedades comunes de los controles anteriores.

El resultado es mas o menos el siguiente.

ComboBox

Si he tenido un control que ha sido mi amigo fiel en los windows form, este sería uno de ellos. Otro sobreviviente también mejorado para WPF.

Seguidamente un pedazo de código correspondiente a este control.

   1: <ComboBox Name="comboBox1" Height="23" VerticalAlignment="Top" />

Si se preguntarán … qué frustrante es una línea? y qué hace esa línea? Bueno básicamente esa línea sólo muestra el combo vacío. Pero la aplicación que escribí rellena el combo en base a al ítem seleccionado de un ListBox.

El resultado de todo eso sería algo asi.

Antes

Después

Bueno el resultado de todo esto se puede aplicar de la siguiente manera.

Espero les sea útil como referencia. Saludos y Happy Coding!!

Encapsulamiento en Java & C# en 0:24

El día de hoy es tiempo de Encapsulamiento.

Bueno el encapsulamiento para los que no saben es un concepto de la OOP, el cual permite ocultar los campos mediante estructuras de datos, métodos u operaciones, haciendo asi que el usuario no tenga que preocuparse mucho en la implementación interna del mismo y en el caso de los campos permitiendo que sus valores no se alteren tan ”facilmente” aunque esta última parte es un poco susceptible dependiendo de como implementes tu software, sistema o lo que quieras desarrollar.

A mi me sirve mucho cuando trabajo con acceso a datos porque me permite organizar mejor mis clases de negocios para después persistirlas; pero bueno baste de palabrería, a continuación les dejaré la sintaxis de las formas que conozco en las que pueden encapsular campos utilizando Java y C#.

Para Java:

   1: // Para asignar un valor a un campo.

   2: public void set[Campo]([Tipo_Dato) value){

   3:     [Campo] = value;

   4: }

   5:  

   6: // Para retornar un valor de un campo.

   7: public [Tipo_Dato] get[Campo](){

   8:     return [Campo];

   9: }

Es decir si tuviesemos un campo Name de tipo String el código mas o menos sería el siguiente:

   1: public void setName(String value){

   2:     Name = value;

   3: }

   4:  

   5: public String getName(){

   6:     return Name;

   7: }

Para C#

   1: // Forma 1. Con metodos

   2: // Para asignar a un valor a un campo.

   3: public void [NombreMetodo]([Tipo_Dato] value)

   4: {

   5:     [Campo] = value;

   6: }

   7:  

   8: // Para retornar el valor de un campo.

   9: public [Tipo_Dato] [NombreMetodo]()

  10: {

  11:     return [Campo];

  12: }

   1: // Forma 2. Con propiedades

   2:  

   3: public [Tipo_Dato] [Nombre_Propiedad]

   4: {

   5:     get

   6:     {

   7:         return [Campo];

   8:     }

   9:  

  10:     set

  11:     {

  12:         [Campo] = value;

  13:     }

  14: }

Imaginando de nuevo que tenemos un campo Name de tipo string (noten que en .NET el tipo de dato es string, en Java es String …. les debo un post de comparación de tipo de datos) el encapsulamiento podría ser el siguiente:

   1: public void assignName(string value)

   2: {

   3:     Name = value;

   4: }

   5:  

   6: public string returnName()

   7: {

   8:     return Name;

   9: }

   1: public string name

   2: {

   3:     get

   4:     {

   5:         return Name;

   6:     }

   7:  

   8:     set

   9:     {

  10:         Name = value;

  11:     }

  12: }

Espero que les sirva este pequeño concepto ya que a mi me sirve mucho en la implementación de muchos programas. Saludos y hasta la próxima.

Happy Coding!

WPF – Controls Part 1 en 1:30

El día de hoy es tiempo de … Controles WPF.

Si como se podrán imaginar no voy a hablar sobre todos los controles, ni sobre todas las propiedades o características que estos poseen ya que tendría que publicar un libro y este es un blog; pero trataré de referirme ha algunos …. Let´s go.

Nota: Estoy publicando el código XAML sólo por motivos demostrativos ya que en verdad si desean insertar estos controles basta con el designer de Visual Studio o con Expresion para insertar y modificar propiedades de los mismo.

Label

Si como lo escuchan o perdón como lo leen, el control label sobrevivió a la generación del .NET 3.0. Posee todas las caracteristicas básicas de los nuevos controles de WPF. He aquí un ejemplo.

   1: <Label Name="label1" Margin="18,51,0,0" Height="30" 

   2:     HorizontalAlignment="Left" VerticalAlignment="Top" Width="98.103">

   3:     This is a Label.

   4: </Label>

Como se puede observar posee un nombre expresado en la propiedad Name, la propiedad Margin permite posicionar el control dentro de una grilla y posee el siguiente formato: (left, top, right, bottom) traduciendo esto (izquierda, arriba, derecha, abajo). HorizantalAlignment indica el alineamiento horizontal, en este caso hacia la izquierda. VerticalAlignment expresa el alineamiento vertical, en este caso arriba. Las propiedades Height y Width indican el alto y el ancho del control. El texto encontrado entre los tags Label marcan lo que se va mostrar en el control. Como resultado tendremos algo así.

TextBlock

Según Josh Smith, en lo personal es un experto en WPF, el TextBlock no es un control. Si coexiste en el namespace System.Windows.Controls pero deriva de la clase FrameworkElement. Esta y otras razones quedan claramente expuestas en uno de sus artículos. En el artículo se muestran las diferencias esta muy bueno.

Bueno aparte de todo lo anterior he aquí un ejemplo.

   1: <TextBlock Height="15.96" HorizontalAlignment="Left" 

   2:  Margin="18,17,0,0" VerticalAlignment="Top" Width="98.103">

   3:  This is a TextBlock.

   4: </TextBlock>

En este caso tiene las mismas propiedades que el control Label, y como resultado tendremos lo siguiente.

TextBox

Este control es un viejo amigo sobreviviente, me da mucha alegría presentarlo y que siga en el Framework, solo que ahora con características de WPF. Es decir mejorado y aumentado.

Un ejemplo chico de código XAML.

   1: <TextBox Height="21.96" Margin="144,14,0,0" 

   2:  VerticalAlignment="Top" HorizontalAlignment="Left" 

   3:  Width="148" Background="Silver" BorderBrush="DarkGray" 

   4:  GotFocus="TextBox_GotFocus" Name="TextBox1" LostFocus="TextBox1_LostFocus">

   5:   This is a TextBox.

   6: </TextBox>

Aparte de las propiedades habituales que ya vimos se encuentra el fondo o Background, el color del Borde o BorderBrush. Además se encuentras las referencias a los eventos los cuales serán codificados en el code behind file.

Después de esto tendremos como resultado … lo siguiente.

Bueno creo que por hoy es suficiente. Si además me estoy cayendo de sueño asi que nos vemos y Happy Coding!!

Para adelantar la aplicación final de controles será la siguiente ventana mas o menos.

Java – Just Beginners and me ;) en 16:30

El día de hoy es tiempo de … Java Just for Beginners and Me.

Ayer estuve hablando con un amigo y me pidió que lanzara una serie de posts sobre Java así que con el transcurrir del tiempo voy a escribir sobre el actual lenguaje y WPF. Pero volvamos a un principio.

Asumiré que instalaron el JDK y que tienen un IDE o un simple editor de texto. Después de crear un archivo para java (Los archivos que contienen source code de Java poseen la extensión .java, es decir si queremos una clase Alumno el nombre de archivo será Alumno.java). Pasaremos a lo nuestro ..... código!!! He aquí un ejemplo que voy a explicar.

   1: package javaapplication1;

   2:  

   3: /**

   4:  *

   5:  * @author Roberto Honores

   6:  */

   7: public class Main {

   8:  

   9:     /**

  10:      * @param args the command line arguments

  11:      */

  12:     public static void main(String[] args) {

  13:         System.out.println("Person to Show:");

  14:         if(args.length == 0){

  15:             Person oPerson = new Person("Roberto", "Honores");

  16:             Print(oPerson);

  17:         }

  18:         else if(args.length == 1){

  19:             Person oPerson = new Person(args[0],"");

  20:             Print(oPerson);

  21:         }

  22:         else{

  23:             Person oPerson = new Person(args[0],args[1]);

  24:             Print(oPerson);

  25:         }

  26:     }

  27:  

  28:     public static void Print(Person sender){

  29:         System.out.println(sender.ToString());

  30:     }

  31: }

Al igual que en todos los lenguajes derivados de C. Al final de cada línea se termina con el caracter “;”.

En la primera línea se ve la palabra package, la cual refleja que este archivo pertenece a un paquete. Un paquete es una forma de organizar las clases en un namespace.

La palabra public indica la visibilidad del elemento que sigue en este caso la clase Main.

Ahora, para que cada clase pueda ejecutarse se necesita del método main. Por convención los parametros de inicio de este método son “String[] args”. Esto indica que se esta pasando un arreglo de parámetros. Eso sucede en usualmente en aplicaciones UNIX en donde se pasan parámetros para invocar un programa.

Luego vemos la instrucción System.out.println en las líneas 13 y 29. Esta instrucción es un método para imprimir en consola el contenido de todo lo que se encuentra entre paréntesis.

Bueno sin otra cosa que explicar por ahora me despido, nada más recordarles cualquier duda o sugerencia la pueden comentar.

Happy Coding!!!

WPF – A Simple Window en 22:20

El día de hoy es tiempo de ... Windows Presentation Foundation o como es más conocido WPF.

Bueno después de mucho tiempo empiezo a retomar mis actividades, leer, escribir otra cosa diferente y ver otro horizontes de desarrollo entre otras cosas.... hasta que desde el día anterior a este decidí aprender un poco de WPF para poder mejorar mis conocimientos en User Experience (Si tengo que admitirlo hasta el momento antes de escribir mi última tool mi conocimiento en UX era casi nulo).

Es por eso que a continuación les compartiré algunas cosas que aprendí con la poco experiencia que acabo de adquirir.

Primero el código que se utiliza es XAML, el cual es para mi opinión XML con otras cosas que felizmente el IntelliSense ayuda y mucho si utilizan el ReSharper :-)

   1: <Window x:Class="Practice5.Window1"

   2:     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   3:     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   4:     xmlns:s="clr-namespace:Practice5"

   5:     WindowStartupLocation="CenterScreen"

   6:     Title="Practice 5" Height="550" Width="750" Background="Black">

   7:  

   8:     <Grid>

   9:     </Grid>

  10: </Window>

Los tags Window como indica su nombre hacen referencia a una ventana. En la línea 1, podemos observar que existe un attributo x:Class, este atributo permite hacer referencia a la clase que pertenece esta ventana.

Luego en las líneas 2, 3 y 4 aparece el atributo xmlns, el cual hace referencia a namespaces, vale recalcar que el namespace de la línea 4 hace referencia al proyecto.

El atributo WindowStartupLocation establece cual va hacer la posición inicial de la ventana con respecto a la pantalla, en mi caso esta centrada.

Después están atributos a los que estamos acostumbrados como el título de la ventana, la altura y el ancho y para finalizar el fondo.

El resultado final será el siguiente.

Bueno no es algo super espectacular; pero en los siguientes post mostraré más controles y otras cosas interesantes.

Bueno nos vemos … See ya 01010101.