Os quiero compartir este pedazo de evento que va a tener lugar a nivel España y donde tendremos suculentos premios!!!

Podreis encontrarme como mentor junto a algunos grandes como Luis Fraile y Luis Guerrero.

¡Vuelve el Megathon Windows 2013!

Por segundo año consecutivo, tendrá lugar el Megathon Windows, un hackathon que se celebra de manera simultánea en varias ciudades, donde tendrás la oportunidad de crear apps para Windows 8 y Windows Phone, aprender y conocer a otros programadores y ganar fabulosos premios.

Además como novedad, este año hemos preparado una serie de cursos y webcasts gratuitos de desarrollo de apps para Windows 8 y Windows Phone previos al evento para que puedas empezar a prepararte a fondo para el gran día.

¡Accede a la web del Megathon Windows para apuntarte a los cursos y no olvides registrarte en alguna de las ciudades que ya tenemos confirmadas!

¡Empieza a prepararte! ¡Contamos contigo!

En este post quiero haceros mención de un libro que he tenido el placer de leer gracias a Ediciones Eni con la que estoy colaborando revisando algunos de sus libros.

En este caso se trata de un libro de Jquery llamado: “jQuery: El framework Javascript de la Web 2.0” escrito por Luc VAN LANCKER.

El libro está formado por 13 capitulos, donde se habla de todo lo relativo a Jquery, pasando desde una introducción, el uso de selectores, eventos, efectos, plugins, AJAX…

Para “alegrar” el texto, podemos encontrar bastantes ejemplos de código. Además de incluir dichos fragmentos (descargables desde la página web de la editorial), el autor va a explicandolos de forma clara y concisa.

Libro totalmente recomendable para introducirse en el desarrollo con  JQuery.

Saludos

PD: Os pongo el enlace al libro

Aunque ya he hablado en alguna ocasión de esta característica, una de las grandes novedades de .NET 4.5 es la introducción de Async y Await para “facilitar” la escritura de código que tiene que ejecutarse de forma asíncrona.

Para el desarrollo de aplicaciones para la Store de Windows 8, es una de las cosas mas importantes que hay que tener en cuenta, y de hecho gran parte de la funcionalidad de la API del propio WINRT ya es asíncrona lo que nos facilita mucho la vida.

En este post, quiero hablaros de una cosa que es bastante importe a la hora de hacer nuestros desarrollos.

Bien, ni los constructores de una clase ni las propiedades pueden ser “calificados” como asíncronos.

Centrándonos en el apartado del constructor, probablemente nos gustaría invocar a algún método asíncrono para por ejemplo llenar una lista de elementos que se van a mostrar en pantalla. Bien, mi recomendación para subsanar esto, es la definición de un método estático al que calificaremos como “async” y dentro de dicho método invocaremos al constructor de nuestra clase, y a las acciones asíncronas de la misma. Para ilustrar esto os expongo un pequeño ejemplo:

   1:  public class MyViewModel : baseViewModel

   2:  {

   3:       public MyViewModel()

   4:      {

   5:   

   6:      }

   7:     private async Task LongTask()

   8:    {

   9:         await Task.Delay(10);

  10:     } 

  11:     public static async Task<MyViewModel> Create()

  12:     {

  13:          var vm = new MyViewModel();

  14:          await vm.LongTask();

  15:          return vm;

  16:   

  17:     }

  18:  }

¿Cómo lo asignamos al contexto de nuestra vista?

Vamos a utilizar el método OnNavigatedTo:

 protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            this.DataContext= await MyViewModel.Create();
        }

Espero que os resulte de utilidad.

Saludos

Continuando un poco con la estela del post anterior en el que hablaba de los Behaviors, en este vamos a ver como agregar una funcionalidad que puede ser bastante interesante en nuestras aplicaciones para Windows Store.

Lo que vamos a abordar, es como auto ocultar la barra de aplicación, según el tiempo deseado. Para resolver esta problematica vamos a agregar dos Dependency Properties a los controles de tipo AppBar:

– La primera una propiedad de tipo Booleana que será la encargada de indicar si se aplica el auto cierre o no. Dentro del establecimiento de esta propiedad vamos a agregar los manejadores de eventos para cuando se abrá la AppBar y cuando entre y salga el cursor dentro de ella (para parar el contador si el cursor está dentro de la AppBar)

– La segunda una propiedad de tipo Integer que servirá para expresar en segundos cuando se va a llevar a cabo el cierre de la AppBar. El valor por defecto de esta propiedad va a ser 5.

Al lio:

   1: public class AppBarExtensions

   2:     {

   3:         public static AppBar appBar;

   4:  

   5:         public static readonly DependencyProperty AutoCloseTimeProperty = DependencyProperty.RegisterAttached("AutoCloseTime", typeof(int), typeof(AppBarExtensions),

   6:             new PropertyMetadata(5));

   7:  

   8:         public static int GetAutoCloseTime(UIElement element)

   9:         {

  10:             return (int)element.GetValue(AutoCloseTimeProperty);

  11:         }

  12:  

  13:         public static void SetAutoCloseTime(UIElement element, int value)

  14:         {

  15:             element.SetValue(AutoCloseTimeProperty, value);

  16:         }

  17:  

  18:         public static readonly DependencyProperty AutoCloseProperty = DependencyProperty.RegisterAttached("AutoClose", typeof(bool), typeof(AppBarExtensions),

  19:        new PropertyMetadata(DependencyProperty.UnsetValue,

  20:        (o, e) =>

  21:        {

  22:            var control = o as AppBar;

  23:  

  24:            appBar = control;

  25:            if (control != null)

  26:            {

  27:                if ((bool)e.NewValue)

  28:                {

  29:                    control.Opened += AppBarOpened;

  30:                    control.PointerEntered += control_PointerEntered;

  31:                    control.PointerExited += control_PointerExited;

  32:                }

  33:                else

  34:                {

  35:                    control.Opened -= AppBarOpened;

  36:                    control.PointerEntered -= control_PointerEntered;

  37:                    control.PointerExited -= control_PointerExited;

  38:                }

  39:            }

  40:        }));

  41:  

  42:         static void control_PointerExited(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)

  43:         {

  44:             timer.Tick += timer_Tick;

  45:             timer.Start();

  46:             Elapsed = 1;

  47:         }

  48:  

  49:         static void control_PointerEntered(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)

  50:         {

  51:             timer.Stop();

  52:             timer.Tick -= timer_Tick;

  53:             Elapsed = 1;

  54:         }

  55:  

  56:         private static DispatcherTimer timer;

  57:  

  58:         private static int Elapsed = 1;

  59:  

  60:         static void AppBarOpened(object sender, object e)

  61:         {

  62:             timer = new DispatcherTimer();

  63:             timer.Interval = TimeSpan.FromSeconds(1);

  64:             timer.Tick += timer_Tick;

  65:             timer.Start();

  66:         }

  67:  

  68:         static void timer_Tick(object sender, object e)

  69:         {

  70:             if (Elapsed == GetAutoCloseTime((UIElement)appBar))

  71:             {

  72:                

  73:                 Elapsed = 1;

  74:                 appBar.IsOpen = false;

  75:                 timer.Stop();

  76:             }

  77:             else

  78:                 Elapsed++;

  79:         }

  80:         public static bool GetAutoClose(UIElement element)

  81:         {

  82:             return (bool)element.GetValue(AutoCloseProperty);

  83:         }

  84:         public static void SetAutoClose(UIElement element, bool value)

  85:         {

  86:             element.SetValue(AutoCloseProperty, value);

  87:         }

  88:     }

Del mismo modo que en el ejemplo del post anterior, vamos a ver como usarlo dentro de nuestro código:

   1: xmlns:appbar="using:AppBarExtensions"

De esa manera podremos empezar a utilizarlo en nuestra AppBar:

   1: <AppBar x:Name="appbar" appbar:AppBarExtensions.AutoClose="True" appbar:AppBarExtensions.AutoCloseTime="3" />

Espero que os resulte de utilidad.

Saludos!

El patrón de diseño mas utilizado a la hora de crear aplicaciones con WPF, Silverlight o Windows 8 es MVVM (Model – View – ViewModel).

Aunque no voy a entrar a la explicación de este patrón voy a hablar de algo relacionado con él.

Uno de los objetivos de este patrón es ayudarnos a mantener nuestro código lo mejor estructurado posible.

En este post me voy a centrar en explicar una problemática existente dentro de Windows 8 y mas concretamente en las desarrolladas con XAML.

El problema radica en la no existencia de triggers que si existian en WPF, como podían ser EventTrigger que se producian al lanzarse un evento.

Debido a ello, vamos a ver como podemos extender los controles de WINRT, para que en lugar de utilizar los eventos desde el código de nuestra página / control, enlacemos a través de un Binding con una propiedad ICommand de nuestro modelo.

Para poder hacer esto, sera necesario definir una Dependency Property. Para el ejemplo concreto vamos a ver como capturar una tecla pulsada por ejemplo en un control de tipo TextBox:

   1: public class PageKeyPressBehavior

   2: {

   3:     public static readonly DependencyProperty KeyDownCommandProperty = DependencyProperty.RegisterAttached("KeyDownCommand", typeof(ICommand), typeof(PageKeyPressBehavior),

   4:                 new PropertyMetadata(DependencyProperty.UnsetValue,

   5:                     (o, e) =>

   6:                     {

   7:                         var textbox = o as TextBox;

   8:                         if (textbox != null)

   9:                         {

  10:                             if (e.NewValue != null && e.OldValue == null)

  11:                                 textbox.KeyDown +=  KeyDownEvent;

  12:                             else if (e.NewValue == null && e.OldValue != null)

  13:                                 textbox.KeyDown -= textbox_KeyDownEvent;

  14:                         }

  15:                     }));

  16:  

  17:             public static ICommand GetIntroButtonCommand(UIElement element)

  18:             {

  19:                 return (ICommand)element.GetValue(IntroButtonCommandProperty);

  20:             }

  21:  

  22:             public static void SetIntroButtonCommand(UIElement element, ICommand value)

  23:             {

  24:                 element.SetValue(IntroButtonCommandProperty, value);

  25:             }

  26:  

  27:             static void KeyDownEvent(object sender, Windows.UI.Xaml.Input.KeyRoutedEventArgs e)

  28:             {

  29:                     var textbox = sender as TextBox;

  30:                     if (textbox != null)

  31:                     {

  32:                         ICommand cmd = GetIntroButtonCommand(textbox);

  33:                         if (cmd != null)

  34:                             cmd.Execute(e.Key.ToString());

  35:                        

  36:                     }   

  37:             }

  38: }

En el código del ejemplo lo que hacemos es registrar una propiedad en los controles de tipo TextBox, y agregamos el manejador de eventos para controlar el evento KeyDown. Dentro de dicho evento lo que haremos será invocar al valor de nuestra Dependency Property.

Bien, ahora como utilizamos esto dentro de nuestra pagina:

1) Lo primero será agregar el namespace donde está alojada la clase que incluye nuestra Dependency Property:

   1: xmlns:be="using:MyApp.Behaviors"

2) Utilizarla dentro de nuestro TextBox:

   1: <TextBox be:KeyDownCommand="{Binding MyKeyDownCommand}" />

Con esto ya trendriamos enlazado nuestro ViewModel y nuestra Vista sin tener que capturar los eventos desde el propio Code Behind.

Espero que os sea de utilidad.

Saludos!

Después del Workshop en el que participe el otro día, me pidieron que subiera el resultado de los laboratorios al blog ver el resultado de los mismos.

Os dejo un zip en mi skydrive:

Este ZIP contiene una solución de VS2012 con los siguientes proyectos:

– Model: Clases de Modelo (Entry), una interfaz IRepository<T> y 2 implementaciones de dicha clase: una para trabajar con XML y otra para tratar con MobileService.

– ViewModel: Contiene las clases vmBase, DelegateCommand, DelegateCommand<T> y el ViewModel que se va a utilizar en los otros proyectos.

– Lab1UI: Esta es la UI que utiliza XML.

– Lab2UI: Esta utiliza Mobile: NOTA: para el servicio tendréis que poner el servicio que tengáis definido en vuestra cuenta de Windows Azure. NOTA 2: No he puesto el tema de notificaciones y autenticación, pero si tenéis cualquier duda podéis hacérmela llegar.

También os comentaba acerca de los libros de una editorial con la que colabora de vez en cuando es Ediciones ENI. Tienen un libro interesante titulo “C# 4.0 Los fundamentos del lenguaje” y dentro de no demasiado estará disponible la versión 5.0 (actualmente está en francés).

Si estáis interesados en alguno de sus libros avisadme también.

Espero que os sea de utilidad.

Buenos días,

Os comparto la presentación y las demos que hemos utilizado Adrián de Microsoft y yo en la charla de Mobile Services que hemos impartido hoy.

PPT:

Demos:

MobileServicesDemos.

Espero que os sea de utilidad.

Saludos!

Desde este post quiero hacer un breve resumen de lo que ha sido este año 2012 para mi.

Antes de meteros el rollo, quiero desearos unas Felices Fiestas y que el 2013 os traiga lo que le pedias!

Desde el punto de vista laboral ha sido un año de los mas duros que ha pasado desde que comencé a trabajar debido a la crisis y los problemas de mi anterior empresa. Gracias a que nuestro sector es un “privilegiado”, en la situación en la que estamos y con la que está cayendo, encontré trabajo con relativa facilidad, y empecé a trabjar en Ilitia.

Gracias a este cambio he tenido la oportunidad de hacer proyectos realmente interesantes con tecnologías como Windows 8, VS2012, Kinect, WPF etc, lo que ha supuesto todo un reto para mi

A nivel técnico y de comunidad ha sido un año realmente interesante a pesar de que el ultimo tercio del año, no he tenido demasiado tiempo para publicar demasiado.

He participado en un par de eventos presenciales, y varios webcast, pero me gustaría hacer especial mención al Evento en el que participe con Madrid Dot Net y la gente de Second Nug de “Introducción a VS2012”. Aunque también me hace especial ilusión el Workshop en el que voy a colaborar mañana en las oficinas de Microsoft.

El 1 de octubre volví a recibir ese correo, que realmente hace mucha ilusión recibirlo. Me refiero al correo que envía Microsoft informandote que eres MVP. En este caso es por segundo año consecutivo, y quiero volver a dar las gracias a todo el equipo de Microsoft por su ayuda, y a todos los lectores del blog por “leerme”.

También relacionado con el MVP y la comunidad está la asistencia al evento TechDay y MVPOpenDay de la mano de Microsoft, el primero de ellos un evento puramente técnico con cosas realmente interesantes (salvo una charla que no me convencio…) y sobre todo con una charla introductoria por parte de Jose Bonnin.

A nivel personal también ha sido un año bastante bueno, lo primero porque me he casado, y después porque he conocido a mucha gente interesante =D

Saludos!!

Hoy toca un post cortito para hablaros de un evento que va a tener lugar el martes 18 de Diciembre.

En este evento vamos a ver la siguiente agenda:

Sesión 1: Analistas de negocio/desarrolladores

9:00 -11:30 
Accede al mercado de las Apps.

Apps Windows 8. Un Nuevo Canal.

Enriquece tu aplicación con Servicios Cloud.

Integra tu App en tus procesos de desarrollo

Sesión 2: Desarrolladores

12:00  -14:30
Lab 1: Crea tu App Windows 8.

Lab 2: Enriquece tu App con servicios en la nube

Lab 3: Integración de tu App en los procesos de ALM

Mas información y enlaces de registro aquí.

Saludos!

Introducción

Como me imagino que todos sabréis ya ha salido hace algún tiempo Windows 8, y la programación para él es relativamente distinta que para el resto de aplciaciones “tradicionales”.

Aunque ya llevo un tiempo trabajando con Windows 8 como sistema operativo, y con WINRT desarrollando aplicaciones para él, se siguen echando en falta algunas cosas en las APIS que nos proveen dentro del nuevo Framework.

En este post voy a exponer dos métodos interesantes para la API de manejo de ficheros.

Código

Dentro de mi proyecto, he definido una clase estática en la que he agregado dos métodos extensores para los elementos que implementen la interfaz IStorageFolder`:

– El primero de ellos será para mover todo el contenido de un directorio.

– El segundo será para copiar todo el contenido de un directorio.

   1: public async static Task CopyFolderAsync(this IStorageFolder folder, IStorageFolder destinationFolder)

   2:       {

   3:  

   4:           if (destinationFolder == null)

   5:               throw new ArgumentNullException("Destination Folder can't be null");

   6:           var destFolder = await destinationFolder.CreateFolderAsync(folder.Name);

   7:           var files = await folder.GetFilesAsync();

   8:           foreach (var file in files)

   9:           {

  10:               await file.CopyAsync(destFolder);

  11:  

  12:           }

  13:  

  14:       }

  15:       public async static Task<IStorageFolder> MoveFolderAsync(this IStorageFolder folder, IStorageFolder destinationFolder)

  16:       {

  17:  

  18:           if (destinationFolder == null)

  19:               throw new ArgumentNullException("Destination Folder can't be null");

  20:           var destFolder = await destinationFolder.CreateFolderAsync(folder.Name);

  21:           var items = await folder.GetItemsAsync();

  22:           foreach (var item in items)

  23:           {

  24:               if (item is StorageFile)

  25:                   await ((StorageFile)item).CopyAsync(destFolder);

  26:               else if (item is StorageFolder)

  27:                   await ((StorageFolder)item).CopyFolderAsync(destFolder);

  28:           }

  29:           await folder.DeleteAsync(StorageDeleteOption.PermanentDelete);

  30:           return destFolder;

  31:       }

Espero que os resulte de utilidad, y que estéis haciendo cosas ya para Windows8!!!

Saludos!