[OFF TOPIC] Nokia Developer Champion 2012

nok_champion

Hola a todos!

Me ha hecho mucha ilusión ver en mi bandeja de entrada este correo:

“Since 2006, Forum Nokia has been selecting individuals from the Nokia developer community to join the Nokia Developer Champion program; a recognition and reward program that honors a select group of mobile developers from around the world. We are pleased to inform you that as one of the outstanding talents in our developer community,you have been selected as one of a few elite members of the Nokia Developer Champion Program. Congratulations!”

Y quería compartirlo con todos vosotros.

Muchas gracias a todos por el apoyo que me dais y por leer mi blog, preguntar y escuchar mis respuestas. Esto es gracias a vosotros!

Un saludo y Happy Coding!

[Windows Phone 7.5] Promociones y Concursos

Hola a todos!

   

Hoy para empezar el fin de semana con buen pie quiero comentaros algunos concursos y promociones sobre desarrollo para Windows Phone que se han puesto en marcha recientemente por parte de Microsoft y Nokia. En todos ellos tenemos la posibilidad de conseguir móviles Lumia 800 de Nokia para poder realizar  nuestras aplicaciones así que no se puede dejar escapar!

Microsoft a vuelto a arrancar el concurso semanal de desarrollo para Windows Phone que habían llevado a cabo en Navidades. El premio: 5 Lumia 800 a la semana, ¿Cómo conseguirlo? Desarrollas una aplicación y la subes al marketplace, luego vas a la página del concurso (aquí) e inscribes tu aplicación. Entre todos los participantes semanales se sortearán 3 Nokia Lumia 800. Pero la gran novedad de esta edición es que, antes de realizar el sorteo, un jurado compuesto por gente de Microsoft escogerá semanalmente 2 aplicaciones por su calidad, originalidad, UX, uso de capacidades, etc… y estos dos se llevarán directamente un Lumia 800 y no participarán en el sorteo. Moraleja: Dale toda la calidad que puedas a tu aplicación, trabájala y tendrás muchas posibilidades de tener un Lumia 800 en tus manos!

El concurso se llevará acabo desde el 16 de abril hasta el 10 de junio, así que ya puedes correr a empezar a desarrollar. Cuando tengas tu aplicación en el marketplace registrate en el concurso para optar al sorteo de esa misma semana y mucha suerte 🙂

Cuenta de publicador

Yeray, todo esto está muy bien pero… Tengo que hacerme una cuenta de publicador y cuesta 75 € y soy estudiante/estoy en paro/no quiero pagar… ¿Qué puedo hacer? Pues no hay problema. Microsoft puede ayudaros con un cupón de subscripción gratuita de 1 año al marketplace de Windows Phone. Para esto tenéis que escribir a la gente de soporte de Windows Phone en Microsoft Ibérica: sopwp7@microsoft.com les contáis que queréis desarrollar apps para Windows Phone y que os gustaría tener un cupón de registro. Pedirán que les habléis de las aplicaciones, que mandéis alguna captura de la App ejecutándose en el emulador y sin poneros ningún problema y muy rápidamente os enviarán el cupón y ya está! solucionado, un año gratis en el marketplace para que podáis realizar el próximo Angry Birds, eso sí, si os hacéis ricos, el segundo año ya lo tenéis que pagar!

Esto es todo amigos!

Espero que todo esto ayude a decidiros a apostar por Windows Phone y el desarrollo. Ya me contaréis que apps han salido de estas promociones.

Un saludo y Happy Coding!

[Windows Phone 7.5] Creando un DataContextProxy

Hola a todos!

Hoy vamos a ver un tema muy interesante y que puede salvarnos en alguna ocasión. Hablamos del DataContextProxy pero… ¿Qué es esto Yeray? Vamos allá!

¿Qué es un DataContextProxy y para que sirve?

Cuando creamos una aplicación Windows Phone usando el patrón MVVM (esto es, siempre. Porque siempre usamos MVVM ¿Verdad?) Establecemos nuestra ViewModel en la propiedad DataContext de nuestra View, de forma que todos nuestros controles lo usan como fuente de datos y nos permite enlazarnos a las propiedades de la VievModel, algo así:

image

Un caso muy simple, un ComboBox que mediante enlace a datos y apoyándose en el DataContext de la View accede a una propiedad expuesta por el ViewModel. No existe ninguna complejidad en este escenario.

Ahora, vamos a imaginar un caso más complejo: Tenemos el ComboBox incluido como parte de un DataTemplate de un ListBox:

image

Con esta configuración, el DataContext del ComboBox corresponde a cada Item del ListBox, es decir, una instancia de la clase Customer, por lo que no podemos acceder a las propiedades expuestas por la ViewModel. Esta situación es muy común, por ejemplo si queremos tener un botón como parte de un DataTemplate y que ese botón use un ICommand expuesto en nuestra ViewModel. Normalmente, podríamos acceder al DataContext de la página, usando la propiedad del Binding ElementName:

<ListBox Name="lstCustomers" ItemsSource="{Binding Customers}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel>
                <TextBlock Text="{Binding CustomerName}"></TextBlock>
                <Button Content="Show" Command="{Binding DataContext.ShowCustomerCommand, ElementName=lstCustomers}"></Button>
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

Esto es totalmente correcto y nos permitiría acceder a la propiedad DataContext del elemento lstCustomers, con lo que ya tendríamos acceso a la ViewModel, pero no es algo que me parezca demasiado elegante de usar. Como las expresiones de enlace a datos no se validan en tiempo de diseño, a no ser que enlacemos con un StaticResource donde se valida su nombre, si cambiamos el nombre de la lista, aunque sea en una mayúscula… no lo encontrará y pasaremos un buen rato buscando el porqué no funciona nuestro comando.

Es aquí donde entra en juego el DataContextProxy. Básicamente se trata de un objeto que hereda de FrameworkElement (la clase base que incorpora a los controles, entre otras, la funcionalidad DataContext) y que es capaz de exponer mediante una propiedad el DataContext de su objeto padre, aprovechándonos de la herencia de propiedades que tiene FrameworkElement:

image

 

Siempre y cuando no establezcamos directamente la propiedad DataContext de un elemento, se heredará el valor de su contenedor, es por esto que podemos establecer la propiedad DataContext solo en la View y no tenemos que ir estableciéndola en cada control de la página.

Nuestro DataContextProxy se aprovechará de esta característica para exponer a través de una propiedad el DataContext de nuestra página. Podremos incluirlo en la misma como un recurso y acceder a el mediante la expresión StaticResource, lo que nos dará validación del nombre fuente en tiempo de diseño.

Muy bien, ¿Como lo implementamos?

Lo mejor de todo es que crear y usar un DataContextProxy es realmente trivial y sencillo. Lo primero que necesitamos es crear una nueva clase en nuestro proyecto Windows Phone que herede de FrameworkElement:

public class DataContextProxyService : FrameworkElement
{
    public DataContextProxyService()
    {
        this.Loaded += new RoutedEventHandler(DataContextProxyService_Loaded);
    }

    void DataContextProxyService_Loaded(object sender, RoutedEventArgs e)
    {
    }
}

Lo primero que haremos en el constructor de nuestra clase es manejar el evento Loaded para poder ejecutar el código necesario cuando nuestro servicio haya sido inicializado por la página que lo contenga.

A continuación vamos a crear una DependencyProperty que será el contenedor a través del cual expondremos nuestro DataContext:

public static readonly DependencyProperty DataSourceProperty =
    DependencyProperty.Register("DataSource", typeof(Object), typeof(DataContextProxyService), null);

public Object DataSource
{
    get { return (Object)GetValue(DataSourceProperty); }
    set { SetValue(DataSourceProperty, value); }
}

Ahora solo nos queda un último paso: Cuando recibamos el evento Loaded, vamos a crear un Binding que exponga nuestro DataContext a través de la propiedad DataSource:

void DataContextProxyService_Loaded(object sender, RoutedEventArgs e)
{
    Binding binding = new Binding();
    binding.Source = this.DataContext;
    this.SetBinding(DataContextProxyService.DataSourceProperty, binding);
}

Y con esto ya tenemos terminada nuestra clase DataContextProxy, ahora vamos a probarla, para empezar vamos a crear una página que tenga un Listbox con un DataTemplate que muestre un TextBlock con el nombre de un Item y un Button:

<ListBox ItemsSource="{Binding Customers}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel>
                <TextBlock Text="{Binding Name}"></TextBlock>
                <Button Content="Click Me!"
                        Command="{Binding SayhelloCommand}"></Button>
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

Vamos a enlazar el DataContext de nuestra página a una ViewModel que contenga una Lista de Customers y un comando que se ejecute al presionar el botón:

public class VMMainPage : INotifyPropertyChanged
{
    private List<Customer> customers;
    public List<Customer> Customers 
    {
        get
        {
            return customers;
        }
        set 
        {
            customers = value;
            RaisePropertyChanged("Customers");
        }
    }

    private ICommand sayHelloCommand = null;
    public ICommand SayHelloCommand
    { 
        get
        {
            if (sayHelloCommand == null)
                sayHelloCommand = new DelegateCommand(() => { MessageBox.Show("Hello!"); });
            return sayHelloCommand;
        }
    }

    public VMMainPage()
    {
        var newCustomers = new List<Customer>()
                                        {
                                            new Customer() { Name = "Yeray" },
                                            new Customer() { Name = "Vicenç"},
                                            new Customer() { Name = "Ibon"}
                                        };

        Customers = newCustomers;
    }

    public event PropertyChangedEventHandler PropertyChanged;

    private void RaisePropertyChanged(string propertyName)
    { 
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

Si ejecutamos la aplicación veremos el siguiente resultado, el nombre del customer se muestra correctamente pero el comando no funciona:

image

Si miramos la ventana de Output veremos los siguientes errores:

image

Efectivamente, el sistema de enlace de Silverlight está buscando el comando SayHelloCommand dentro de cada item de la lista, por supuesto no lo encuentra. Aquí es donde entra en acción nuestro DataContextProxy: Lo primero es añadir una referencia a nuestro ensamblado en la página para que podamos acceder a los objetos de nuestra aplicación:

xmlns:dataproxy="clr-namespace:WP75DataContextProxy"

A continuación, vamos a definir una instancia de nuestra clase DataContextProxyService como recurso de la página en la que nos encontramos:

<phone:PhoneApplicationPage.Resources>
    <dataproxy:DataContextProxyService x:Key="DataProxy"></dataproxy:DataContextProxyService>
</phone:PhoneApplicationPage.Resources>

Y por último vamos a modificar el Binding del comando en el botón para que haga uso de la propiedad DataSource de nuestro DataContextProxyService:

<Button Content="Click Me!"
        Command="{Binding DataSource.SayHelloCommand, Source={StaticResource DataProxy}}">
</Button>

Esta vez, si iniciamos la aplicación y presionamos alguno de los botones, el resultado será distinto, el sistema de enlace a datos encontrará el comando en nuestro DataContext principal, el asignado a la ventana y no lo buscará en cada Item:

image

 

Conclusión

Usando esta técnica tenemos una forma sencilla y clara de poder obtener nuestro DataContext principal dentro de listas, combos, plantillas y otros elementos. Todo esto sin tener que referenciar elementos por nombre, usando un recurso estático y sin depender de elementos que mañana pueden no ser necesarios y puedan ser eliminados de la aplicación. Como siempre aquí os dejo el código de ejemplo que he usado en el artículo.

Espero que os sea muy útil. Happy Coding!

[Windows Phone 7.5] SDK 7.1.1 RTW con licencia GO LIVE

wplogo

 

Hola a todos!

Un post rápido, ya está disponible para descarga la versión final del SDK 7.1.1 de Windows Phone. Entra las novedades de esta versión final tenemos:

  • Imagen de emulador de 512Mb usa la build del sistema 8773
  • Actualización del SDK de Advertising incluida con solución a varios bugs
  • Soporte en intellisenses para especificar el requerimiento de 512Mb en el manifiesto
  • Soporte completo en Windows 8

Además de las novedades en cuanto a los dispositivos de baja memoria, sorprende la rapidez que han tenido en hacer que el emulador funcione en Windows 8, lo cual seguro que contenta a más de uno (yo me incluyo).

Podéis descargaros el SDK 7.1.1 aquí.

Disfrutadlo y Happy Coding!

[EVENTO CODEMOTION] Windows Phone 7.5 Design Patterns & Application Quality

Hola a todos!

wplogoimage

Ayer 24 de Marzo tuve la oportunidad de asistir a la primera edición en España del CODEMOTION. Además de poder asistir a algunas interesantes charlas y poder desvirtualizar a Luis Fraile y a El bruno entre otros, también tuve la oportunidad de impartir una charla sobre desarrollo avanzado para Windows Phone 7.5. En esta ocasión pudimos hablar sobre el patrón MVVM, Inyección de dependencias, servicios y testeo unitario.

Algo antes de comenzar la charla tuve la sorpresa de saber que Oscar Gutierrez, developer relations manager de Nokia Spain, vendría a acompañarme un rato en la misma para hacer una interesante proposición a los asistentes y presentar los recursos de desarrollo que Nokia tiene disponibles para todos los desarrolladores de Windows Phone.

En esta ocasión quise destacar lo importante de desarrollar bien desde el principio, usando el patrón correcto, pensando en realizar código desacoplado, basado en servicios y usando IoC para resolver dependencias. También vimos como poder testear nuestro código de una forma eficiente e integrada con Visual Studio.

A continuación os dejo la presentación de la charla, en Slideshare, desde donde también podréis descargarla:

El proyecto que usé para ilustrar todos estos principios fue el que he desarrollado para nuestro podcast WPControla, podéis ver el código en http://wpcontrola.codeplex.com

Espero que os guste, yo desde luego disfruté como un niño en la charla.

Un abrazo y Happy Coding!

[Windows Phone 7.5] Podcast en español WPControla, episodio 3

wpcontrola_tile Hola a todos!

Dicen que no hay dos sin tres así qué, aquí estamos con el tercer capítulo del podcast sobre desarrollo para Windows Phone que hago con Rafael Serna.

En este tercer capítulo entrevistamos a Jorge Cantón de Syderis, uno de los creadores del SDK multiplataforma CellSDK. También desgranamos las últimas noticias y hablamos sobre la publicidad en las aplicaciones y como mejorar un poco nuestras ganancias con ella.

Tienes un resumen completo y los enlaces del podcast aquí.

Espero que disfrutéis tanto escuchándolo como yo haciéndolo.

Un saludo y Happy Coding!

[Windows Phone 7.5] Creando nuestros propios Behaviors

Hola a todos!

En el último artículo sobre Expression Blend (puedes verlo aquí) hablamos sobre animaciones y como usar los behaviors incluidos en Silverlight para ejecutarlas. Pudimos ver como existen diferentes tipos de behaviors, pero no vimos como poder crear los nuestros propios para poder usarlos en nuestras aplicaciones.

Behavior<T>

Dentro del ensamblado System.Windows.Interactivity tenemos una clase llamada Behavior<T> de la cual podemos heredar para crear un behavior personalizado. La estructura mínima es la siguiente:

public class CustomBehavior : Behavior<Grid>
{
    protected override void OnAttached()
    {
        base.OnAttached();
    }

    protected override void OnDetaching()
    {
        base.OnDetaching();
    }
}

Con el código anterior indicamos que queremos crear un Behavior llamado CustomBehavior que podrá ser usado en elementos de tipo Grid. El método OnAttached se ejecutará cuando el behavior se añada al elemento Grid y el OnDetaching cuando se descargue del elemento. De esta forma podremos ejecutar el código que deseemos y tendremos una forma de limpiar las referencias, eventos, y todo lo necesario cuando el Behavior ya no sea necesario.

Un ejemplo práctico: Extendiendo el control WebBrowser

El control WebBrowser incluido en el SDK de Windows Phone es muy versátil para mostrar contenido HTML, incluso contiene un método llamado NavigateToString que nos permite mostrar en el control una cadena de texto con formato HTML. El problema que tiene es que no existe una propiedad que podamos usar desde XAML directamente para mostrar el contenido de una propiedad, siempre necesitamos usar Code Behind para atacar a este método, algo parecido a esto:

<Grid x:Name="LayoutRoot" Background="Transparent">       
    <phone:WebBrowser Name="webControl"></phone:WebBrowser>
</Grid>
public MainPage()
{
    InitializeComponent();

    webControl.NavigateToString("<BODY>Hola!</BODY>");
}

Esto es muy engorroso si estamos usando un patrón MVVM, además de romper la regla de no usar Code Behind, tenemos que detectar los cambios en nuestro ViewModel y de alguna forma invocar código en nuestro code behind o tener una referencia al control directamente en nuestra ViewModel, lo cual es aun peor.

¿Como lo resolvemos? Usando un Behavior!

Lo primero que vamos a hacer es crear una nueva clase llamada NavigateToStringBehavior que herede de Behavior, pasando como tipo el control WebBrowser. Dentro de nuestro behavior tenemos una propiedad llamada AssociatedObject, que nos devuelve el objeto al cual hemos asociado nuestro behavior, con todas las propiedades del tipo indicado:

public class NavigateToStringBehavior : Behavior<Microsoft.Phone.Controls.WebBrowser>
{
    /// <summary>
    /// Execute when attached to a parent object.
    /// </summary>
    protected override void OnAttached()
    {
        base.OnAttached();
        AssociatedObject.Loaded += AssociatedObject_Loaded;
    }

    /// <summary>
    /// Execute our behavior actions!
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
    {
    }

    /// <summary>
    /// Execute when detached from a parent object
    /// </summary>
    protected override void OnDetaching()
    {
        base.OnDetaching();
        AssociatedObject.Loaded -= AssociatedObject_Loaded;
    }
}

En este caso usamos el método OnAttached para manejar el evento Loaded de nuestro WebBrowser, mediante la propiedad AssociatedObject y el método OnDetaching para eliminar el manejador creado de forma que no queden dependencias y se pueda liberar correctamente toda la memoria al destruir el WebBrowser.

Ahora necesitamos algún mecanismo que nos permita indicarle a nuestro behavior cual es el contenido que deseamos mostrar, además queremos que este contenido pueda ser indicado mediante un Binding a una propiedad de nuestra ViewModel, la solución: Añadir una DependencyProperty a nuestro behavior:

private static readonly DependencyProperty HtmlContentProperty = DependencyProperty.Register("HtmlContent", typeof(string),
                                                                                                typeof(NavigateToStringBehavior), 
                                                                                                null);
public string HtmlContent 
{
    get { return (string)this.GetValue(HtmlContentProperty); }
    set { this.SetValue(HtmlContentProperty, value); }
}

Para ello creamos una propiedad pública en nuestra clase NavigateToStringBehavior de tipo string llamada HtmlContent y a continuación una propiedad de tipo DependencyProperty que será la encargada de almacenar nuestro valor.

Ahora solo nos queda añadir código al manejador de eventos AssociatedObject_Loaded para que obtenga el valor de la propiedad HtmlContentProperty y llame al método NavigateToString del WebBrowser asociado:

/// <summary>
/// Execute our behavior actions!
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
{
    AssociatedObject.NavigateToString(HtmlContent);
}

El código simplemente llama al método NavigateToString pasando como argumento la propiedad HtmlContent, que a su vez obtendrá el valor de la DependencyProperty HtmlContentProperty evaluando la expresión de enlace a datos (binding) si existe.

Usando el fruto de nuestro trabajo

Ahora vamos a crear una clase llamada HtmlViewModel en nuestra aplicación que imitará a una ViewModel real y expondrá dos propiedades de tipo string:

public class HtmlViewModel
{
    public string Html1 { get; set; }

    public string Html2 { get; set; }

    public HtmlViewModel()
    {
        Html1 = @"<BODY bgcolor='#AAAAFF' text='#003300'>
                    <strong>Hola!</strong>
                  </BODY>";

        Html2 = @"<BODY bgcolor='#FFAAAA' text='#003300'>
                    <strong>Adios!</strong>
                  </BODY>";
    }
}

En estas dos propiedades hemos introducido código HTML para imitar el posible HTML que podríamos tener guardado de un Rss o una página web.

Vamos a abrir Expression Blend (Haciendo click derecho en nuestra página MainPage.xaml y escogiendo la opción “Open in Expression Blend”).

He creado un layout con dos WebBrowsers en la página:

image

 

Lo primero que necesitamos hacer es indicarle a nuestra página que debe usar la clase HtmlViewModel como su DataContext. Para ello seleccionamos en la pestaña de objetos nuestra PhoneApplicationPage y en las propiedades buscamos el DataContext, donde encontraremos el botón New, al presionarlo abrirá una ventana para seleccionar nuestra fuente de datos:

image

Después de seleccionar la  clase HtmlViewModel presionamos OK. Veremos una lista de las propiedades que expone nuestra clase, Html1 y Html2, ahora seleccionamos el primer WebBrowser y vamos a la pestaña Assets y a los Behaviors, donde veremos que está incluido nuestro NavigateToStringBehavior:

image

Solo tenemos que seleccionarlo y arrastrarlo sobre nuestro primer WebBrowser. Si intentamos añadirlo a la grid o a la página, veremos que nos indica un mensaje de que no es un objetivo válido. una vez añadido al primer WebBrowser, en las propiedades del Behavior veremos nuestra DependencyProperty HtmlContent, donde podremos indicar nuestro Binding:

image

Podemos repetir la misma operación con el segundo WebBrowser, añadiendo un nuevo NavigateToStringBehavior y estableciendo el Binding a la propiedad Html2.

Tras hacer esto, si ejecutamos nuestra aplicación veremos el resultado:

image

Y Voila! tenemos nuestro código HTML mostrándose en un WebBrowser sin necesidad de usar Code Behind y con un Behavior reutilizable siempre que lo necesitemos y con soporte a enlace a datos.

Conclusión

Hemos podido ver como crear un Behavior es muy sencillo pero al mismo tiempo muy útil y potente, es una herramienta que nos permitirá crear comportamientos reutilizables, usables desde Expression Blend directamente y evitando usar Code Behind. Como siempre, aquí tenéis el proyecto de ejemplo, espero que os sea de utilidad.

Un saludo y Happy Coding!

[Windows Phone 7.5] Materiales de mi Webcast sobre Expression Blend 4

Ayer jueves 15 de Marzo MSDN Latam me volvió a ofrecer la oportunidad de realizar un Webcast sobre desarrollo con Expression Blend 4 para Windows Phone 7.5

Podéis ver el evento grabado en el siguiente enlace: https://www137.livemeeting.com/cc/MSEvents/view?cn=guest&id=1032507359&pw=E5720F15

He colgado la presentación en SlideShare para que sea más comodo verla:

Espero que hayáis disfrutado tanto con el webcast como yo haciéndolo. Un saludo y Happy Coding!

[Windows Phone Tango] Preparando nuestras aplicaciones (I)

Hola a todos!

Como ya vimos anteriormente, Microsoft ha liberado la CTP del SDK de Windows Phone Tango. Se estima que los dispositivos ejecutando esta versión de Windows Phone aumentarán el mercado disponible en un 60% por lo que es más que recomendable empezar a preparar nuestras aplicaciones para esta nueva versión del sistema operativo.

Una de las limitaciones más evidentes será el recorte en la memoria disponible para nuestra aplicación que pasará de 90Mb a 60Mb por lo que, si no lo habéis hecho ya, es buen momento para empezar a usar el profiler de Windows Phone y ver donde podemos optimizar nuestro consumo de memoria.

Introducción a la herramienta de análisis de rendimiento de Windows Phone

Una de las novedades que tuvimos con el SDK de Windows Phone 7.1 fue la inclusión de un profiler específico para nuestras aplicaciones móviles, el “Windows Phone Performance Analysis” que podemos encontrar en el menú Debug de Visual Studio 2010.

Al iniciarlo se nos presentarán dos opciones distintas:

image

En esta primera pantalla podremos decidir entre analizar el rendimiento visual y de código o analizar el consumo de memoria. También podemos ver como se nos indica en forma de Warning que estamos usando el emulador y no un dispositivo real, con lo que el rendimiento puede ser distinto al de un dispositivo real (y de echo lo es y mucho) y que para obtener unos resultados más precisos debemos usar la configuración de release. En este primer ejemplo vamos a seleccionar “Memory” y dejar los valores por defecto.

Por último tenemos un link para iniciar la aplicación, lo que dejará el profiler a la escucha de los resultados e iniciará la compilación y despliegue:

image

En este momento deberemos usar nuestra aplicación de forma normal. Podemos centrarnos en una página en concreto e ir midiendo el rendimiento que tiene bajo diferentes situaciones o hacer un barrido por toda la aplicación para ver una primera aproximación del consumo de memoria. En cualquier caso, cuando hayamos terminado, presionamos Stop Profiling y Visual Studio empezará a procesar los datos y nos los mostrará en una línea de tiempo:

image

En esta primera ejecución estamos usando una aplicación vacía, tal cual la crea el SDK, por lo que no vemos ninguna variación en el consumo de memoria y solo se produce un evento de recolección, al terminar la misma. Podemos seleccionar una porción de esta línea para ver un detalle de lo que ha ocurrido en ese momento exacto, simplemente pinchando en un punto inicial y arrastrando hasta un punto final:

image

Si presionamos “Start Analysis” se nos mostrará en un primer momento los avisos de rendimiento:

image

Si presionamos sobre la flecha a continuación de “Performance Warnings” podremos seleccionar “Heap Summary” donde podremos ver un sumario de uso de memoria, nuevas inclusiones… :

image

Si seleccionamos la línea “Retained Silverlight Visuals at End” podremos acceder a los tipos que contiene:

image

Por cada tipo además de ver su tamaño total, máximo durante el periodo seleccionado y el número de instancias, podremos ver una descripción de cada instancia:

image

Con esto, vemos el momento de creación, cuanto tiempo se mantuvo viva, quien lo creo y el tamaño en Bytes que ocupa.

Con esta información, podremos ver de forma rápida donde estamos aumentando el consumo de memoria, si esta se libera cuando debe o no, quien está creando objetos que no debería, etc… . Usarla de forma correcta nos ayudará a tener una aplicación más eficiente y poder llegar al nuevo 60% de los dispositivos que usarán Windows Phone Tango.

En el próximo artículo profundizaremos en la optimización del uso de memoria en nuestras aplicaciones, uso de imágenes, hilos y más cosas interesantes y curiosas.

Un saludo y Happy Coding!

[MSDN Latam] Webcast: Aplicaciones Windows Phone con Expression Blend

msdn_wp75

Hola!

Parece que la gente de MSDN Latam le ha cogido el gusta a Windows Phone y están que no paran… y yo me apunto a todo!

Esta vez vamos a montar un webcast el día 15 de Marzo a las 16:00 (GMT-5) sobre Windows Phone 7.5 y más concretamente sobre como aprovecharnos de Expression Blend para darle a nuestra aplicación un estilo único y de paso ganar en productividad al trabajar con XAML:

  • Introducción a la filosofía METRO
  • Expression Blend
  • Layout y controles
  • Plantillas de controles y estilos
  • Animaciones y Comportamientos

Todo los veremos desde un punto de vista práctico, con pocas diapositivas y mucho Expression Blend. Puedes registrarte aquí

Un saludo y Happy Coding!