Windows Phone. Coding4Fun MemoryCounter.

Una vez finalizado el desarrollo de nuestra aplicación para Windows Phone desearemos publicarla en el MarketPlace. Para ello, debe pasar un proceso de certificación donde se le realizarán múltiples pruebas que debe superar con éxito. Uno de los puntos vitales a tener en cuenta durante la fase de desarrollo es el rendimiento. Hoy nos centraremos en la gestión de memoria.

NOTA: En Windows Phone Mango el límite de consumo de memoria por parte de la aplicación eran 90MB, en Windows Phone Tango, el límite  baja a los 60MB.

Para ello, utilizaremos el control Memory Counter disponible en el Conding4Fun Toolkit (totalmente gratuito, hablamos  del toolkit en esta entrada). El control Memory Counter permite monitorear el uso total de memoria de nuestra aplicación de manera muy fácil (algo vital a hacer para llegar a buen puerto en la certificación de la misma).

Vamos a realizar un ejemplo práctico para entender mejor que nos aporta el control y como aprovechar todas sus posibilidades. Creamos un nuevo proyecto:

La plantilla seleccionada será “Windows Phone Application” para simplificar al máximo el ejemplo.

Para poder utilizar el control MemoryCounter lo primero que debemos hacer es añadir la referencia a la siguiente librería:

Coding4Fun.Phone.Controls.dll

Nos centramos en la página principal (MainPage.xaml). Añadimos el siguiente namespace:

xmlns:Coding4Fun="clr-namespace:Coding4Fun.Phone.Controls;assembly=Coding4Fun.Phone.Controls"

Ya podemos utilizar el control. Es tán sencillo como añadir:

<Coding4Fun:MemoryCounter/>

Si compilas en este momento podrás ver al control en acción:

NOTA: El control MemoryCounter sólo funciona en modo DEBUG.

Centremonos a continuación en las propiedades principales del control:

  • UpdateInterval. Propiedad de dependencia de tipo Int. Indica cada cuanto se refresca la información proporcionada por el control. Por defecto el valor es 1000.
  • CurrentMemory. Propiedad de dependencia de tipo String. Representa el consumo de memoria actual por la aplicación.
  • PeakMemory. Propiedad de dependencia de tipo String. Representa el pico máximo de memoria alcanzado por la aplicación en algún momento.
<Coding4Fun:MemoryCounter x:Name="memoryCounter" UpdateInterval="250" Foreground="Red"/>

Vamos a añadir una serie de botones que nos permita “jugar” con la memoria utilizada para poder probar el control MemoryCounter:

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
     <Coding4Fun:MemoryCounter x:Name="memoryCounter" UpdateInterval="250" Foreground="Red"/>
     <StackPanel VerticalAlignment="Center">
          <Button x:Name="btnLoad" Content="Cargar 10MB en Memoria"/>
          <Button x:Name="btnClear" Content="Limpiar Memoria"/>
          <Button x:Name="btnInfo" Content="Ver uso de Memoria" Margin="0,150"/>
     </StackPanel>
</Grid>

Hemos añadido tres botones. El primero de ellos sumará cada vez que se pulse 10MB más a la memoria usada, el segundo limpiará la memoria añadida por el primero botón y por último el tercer botón nos permite consultar el uso de memoria.

Añadimos los eventos Click de cada botón:

<Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
     <Coding4Fun:MemoryCounter x:Name="memoryCounter" UpdateInterval="250" Foreground="Red"/>
     <StackPanel VerticalAlignment="Center">
          <Button x:Name="btnLoad" Content="Cargar 10MB en Memoria" Click="btnLoadClick"/>
          <Button x:Name="btnClear" Content="Limpiar Memoria" Click="btnClearClick"/>
          <Button x:Name="btnInfo" Content="Ver uso de Memoria" Click="btnInfoClick" Margin="0,150"/>
     </StackPanel>
</Grid>

Creamos una colección de Bytes para cargar en memoria:

List<Byte[]> _memoria;

// Constructor
public MainPage()
{
     InitializeComponent();

     _memoria = new List<byte[]>();
}

En el primer botón añadimos 10MB al uso de memoria. En el segundo, limpiamos la colección y llamamos el recolector de basura:

private void btnLoadClick(object sender, RoutedEventArgs e)
{
     _memoria.Add(new Byte[1024 * 1024 * 10]);
}

private void btnClearClick(object sender, RoutedEventArgs e)
{
     _memoria.Clear();
     GC.Collect();
}

Por último, utilizaremos las propiedades CurrentMemory y PeakMemory del control MemoryCounter para mostrarselas al usuario en un mensaje al pulsar el botón:

private void btnInfoClick(object sender, RoutedEventArgs e)
{
     string mensaje = string.Format("Memoria usada actualmente: {0}Mb" + Environment.NewLine + "Memoria máxima que se ha llegado a utilizar: {1}Mb", memoryCounter.CurrentMemory, memoryCounter.PeakMemory);
     MessageBox.Show(mensaje);
}

Puedes ver en video el ejemplo realizado a continuación:

También puedes descargar el ejemplo realizado:

Nada más en esta entrada. Hemos visto un control bastante interesante y sobretodo muy útil. Os recomiendo que lo probéis. Si os surgen dudas o sugerencias podéis dejarlas en los comentarios.

Más información:

7 pensamientos en “Windows Phone. Coding4Fun MemoryCounter.

  1. Pues gracias por la info, no conocia memorycounter, yo solo utilizaba los ‘performance analysis’. Esto viene muy bien, aunque opino que ha habido demasiados recortes en la versión light (que ya se puede decir que es historia) de WP7.

    • Me alegro que te sea útil. El control MemoryCounter es una forma rápida y muy sencilla de poder controlar el uso de memoria (básico para la certificación de la aplicación). Hablaré en otra entrada de los Performance Analysis. Para quien no lo conozca recomiendo las siguientes lecturas:

      http://blog.soreygarcia.me/2012/02/usando-el-windows-phone-performance.html

      http://geeks.ms/blogs/jyeray/archive/2012/03/13/windows-phone-tango-preparando-nuestras-aplicaciones-i.aspx

      A modo de resúmen, es una herramienta que nos proporciona información de uso de memoria, CPU, etc. Obtenemos muchísima más información que con el control MemoryCounter. Eso si, hay cierto tipo de información que hay que saber interpretar. En conclusión, este control es otra opción más limitada pero muy sencilla de usar.

      Comparto tu opinión. Hay ciertas apps que necesitan un sobresfuerzo con el límite reducido de memoria por ejemplo. Aunque también entiendo el punto de vista de Microsoft, los dispositivos de 256MB son más económicos y por lo tanto se puede llegar a más gente. Y claro, cuantos más usuarios de Windows Phone, mejor para nosotros los desarrolladores.

      Un saludo.

  2. Hola Javier, esta información me ha sido útil… Tengo un problema… Mi aplicación es un lector rss y tiene algunas secciones secundarias y al navegar entre ellas llega el momento en que se acaba la memoria… Como ejemplo al inciar la app el memorycounter muestra “44.50” luego voy a la página “about my app” y luego presiono el boton back para volver a la página de incio de la app y el memorycounter sube a “67.50” y así cada vez que navego y vuelvo a la principal el contador sube y sube…

    Estoy haciendo algo mal? Debo eliminar la memoria de alguna forma?

    Saludos

  3. Pingback: [Tips and Tricks] Windows Phone. DeviceStatus. Uso de memoria | Javier Suárez Ruiz | Blog

  4. Pingback: [Tips and Tricks] Windows Phone. DeviceStatus. Uso de memoria - Javier Suárez

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s