[Universal Apps/ Xamarin.Forms] XCC. Compilación condicional en XAML

Introducción

Las condiciones de compilación son un proceso que nos permiten
definir directivas de compilación que provocarán que partes del código
sean compiladas y otras ignoradas.

Utilizamos las directivas #if, #else y #endif
para establecer código distinto ante directivas de compilación
diferente. Muy utilizados para añadir código que solo añadiremos en DEBUG
y en el desarrollo de aplicaciones móviles, para poder añadir en la
misma clase partes de código diferente entre distintas plataformas.

Técnica disponible para añadir bloques de código específico por
plataforma en nuestro código C# por ejemplo, en el desarrollo de
aplicaciones Universales Windows. Sin embargo, en el caso de vistas,
debemos utilizar otro tipo de técnicas (VisualStates, separar vistas en
ficheros diferentes, etc.) ya que no contamos con compilación
condicional en XAML

XCC. XAML Conditional Compilation

El proyecto XAML Conditional Compilation (XCC) de Koen Zwikstra
nos define una serie de namespaces XAML que nos permiten trabajar de
una forma similar a como lo hacemos en C# con directivas de compilación.

XCC se convierte en una opción muy útil cuando trabajamos con vistas
XAML en aplicaciones Universales Windows que deseamos compartir o en
Xamarin.Forms. Podremos especificar elementos visuales solo para una
plataforma e incluso el mismo elemento definirlo de forma diferente
segun la paltaforma.

Aplicaciones Universales

Comenzamos creando un nuevo proyecto:

Añadimos las carpetas Views, ViewModels y Services además de las clases base necesarias para implementar el patrón MVVM de la misma forma que vimos en este artículo.

Nuestro objetivo sera muy sencillo. Nuestra aplicación de ejemplo
tendra diferentes elementos que añadiremos especificándo la plataforma o
bien creando elementos comunes a ambas plataformas pero con propiedades
específicas.

A continuación, añadiremos XCC. La librería la tenemos disponible en NuGet por lo que podemos instalarlo usando Nuget Package Manager. En las referencias de la solución hacemos clic derecho y seleccionamos la opción Manage NuGet Packages for Solution…

En la ventana modal que nos aparece, en la parte superior derecha donde podemos realizar una búsqueda, buscamos por “XCC”:

Seleccionamos el elemento disponible y pulsamos el botón Install.
Tras un breve periodo donde se procede a descargar e incluir las
librerías en las referencias de cada proyecto, tendremos lo necesario
para comenzar a trabajar con directivas de compilación en XAML.

Lo primero que debemos hacer es definir en nuestra vista los espacio
de nombres que utilizaremos para identificar cada plataforma:

xmlns:debug="condition:DEBUG"
xmlns:release="condition:!DEBUG"
xmlns:win81="condition:WINDOWS_APP"
xmlns:wp81="condition:WINDOWS_PHONE_APP"

Los atributos xmlns:win81 y xmlns:wp81
definen los namespaces que utilizaremos para realizar compilación
condicional por plataforma con los elementos y atributos XML. También
hemos definido los atributos xmlns:debug y xmlns:release que nos permiten distinguir elementos y atributos entre DEBUG y RELEASE.

Comenzamos utilizando los espacio de nombre definidos previamente:

<debug:TextBlock    
     Text="Solo visible en DEBUG" />
             
<release:TextBlock
     Text="Solo visible en RELEASE" />

Hemos definido dos controles para mostrar texto con los atributos xmlns:debug y xmlns:release respectivamente. El primero de ellos solo se compilará y aparecerá en modo DEBUG mientras que el segundo de ellos solo lo hará en RELEASE.

NOTA: El diseñador de Visual Studio ignora los prefijos de compilación condicional que utilizamos.

De la misma forma que lo utilizamos con elementos en su totalidad lo podemos hacer con atributos de un elemento:

<!-- Rojo en DEBUG, Verde en RELEASE -->     
<TextBlock Text="Siempre visible"
     debug:Foreground="Red"
     release:Foreground="Green" />

En el ejemplo superior el TextBlock se compilará para ambas plataformas. Sin embargo, el color del texto será rojo en DEBUG y verde en RELEASE.

Muy interesante sin duda lo visto hasta ahora pero la parte más
interesante es el uso de los espacio de nombre que nos permiten hacer
distinciones entre las plataformas.

 <!-- Win Button -->
 <win81:Button                
     Content="Windows" />
            
 <!-- Phone Button -->
 <wp81:Button
     Content="Windows Phone" />

En el trozo de XAML anterior, el primero botón solo aparecerá en la
App Windows Store mientras que el segundo hara lo propio solo en la App
Windows Phone.

Al igual que con las directivas de compilación para distinguir entre DEBUG y RELEASE, podemos establecer atributos (propiedades) distintas segun la plataforma:

<Button
     Content="Botón"
     win81:Background="Blue"
     wp81:Background="Green"/>

El resultado en Windows Store:

Windows Phone:

NOTA: XCC no modifica los archivos XAML, crea archivos XAML temporales en la carpeta obj y redirige al compilador XAML a ellos.

Extremadamente útil en vistas no complejas donde mostrar de forma diferente elementos como publicidad, algun DataTemplate, ocultar controles, etc. de una forma muy sencilla.

Al igual que en el uso de directivas de compilación en código C#, la recomendación
general es la misma, no conviene realizar un uso excesivo de la
técnica. Si tenemos una vista compleja llena de elementos marcados con
directivas de compilación se volvería excesivamente compleja y añadiría
dificultad a la hora de realizar el mantenimiento de la misma. Según las
características de la vista nos encontraremos situaciones en als que
conviene utilizar directivas de compilación y otras en las que lo mejor
sea separar en dos ficheros diferentes.

Podéis descargar el sencillo ejemplo realizado a continuación:

También podéis acceder al código fuente directamente en GitHub:

Ver GitHub

Xamarin

XCC también esta disponible para Xamarin.Forms. Para probar las posibilidades crearemos un nuevo proyecto Xamarin.Forms:

En el proyecto Shared o PCL crearemos una vista principal XAML:

A continuación, añadiremos XCC utilizando NuGet de igual forma que hicimos con la Aplicación Universal Windows.

Lo primero que debemos hacer es definir en nuestra vista los espacio
de nombres que utilizaremos para identificar cada plataforma:

xmlns:android="condition:__ANDROID__"
xmlns:ios="condition:__IOS__"
xmlns:wp="condition:WINDOWS_PHONE"

Los atributos xmlns:android, xmlns:ios y xmlns:wp definen los espacio de nombres que utilizaremos para definir condiciones de compilación en elementos y atributos XML.

Podemos definir con facilidad elementos visuales específicos por plataforma:

<android:Label
     Text="Android" />
 
<ios:Label
     Text="iOS" />
 
<wp:Label
     Text="Windows Phone" />

Por supuesto, también podemos utilizar directivas de compilación con atributos (propiedades):

<!-- Android: Verde, iOS: Azul, Windows Phone: Rojo -->
<Label Text="Label"
     android:TextColor="Green"
     ios:TextColor="Blue"
     wp:TextColor="Red" />

Podéis descargar el sencillo ejemplo realizado a continuación:

También podéis acceder al código fuente directamente en GitHub:

Ver GitHub

Recordar que cualquier tipo de duda o sugerencia la podéis dejar en los comentarios de la entrada.

Más información

[Tips and Tricks] Correr una App de consola .NET en la Intel Galileo

Introducción

En la Preview Release del programa de desarrollo de Windows para IoT
podemos desarrollar aplicaciones para la Intel Galileo utilizando las
APIs Arduino Wiring y un subconjunto de Win32. En el pasado //BUILD 2014
en San Francisco, Microsoft anuncio la futura disponibilidad del modelo
de desarrollo de aplicaciones Windows universales.

Aplicación .NET de consola

Abrimos Visual Studio y creamos una nueva aplicación de consola:

Nuevo proyecto de Consola

Vamos a crear una aplicación muy sencilla, nos mostrará los primeros 100 números primos. Para ello, crearemos un Helper que nos indicará si un número es o no primo:

public static bool IsPrime(int number)
{
     if ((number & 1) == 0)
          return number == 2;
 
     for (int i = 3; (i * i) <= number; i += 2)
     {
          if ((number % i) == 0)
               return false;
     }
 
     return number != 1;
}

En nuestra App crearemos un bucle con los primeros 100 números e iremos verificando si son o no primos:

Console.WriteLine("--- Primes between 0 and 100 ---");
 
for (int i = 0; i < 100; i++)
{
     bool prime = PrimeHelper.IsPrime(i);
     if (prime)
     {
          Console.Write("Prime: ");
          Console.WriteLine(i);
     }
}
 
Console.ReadLine();

Si la ejecutamos veremos un resultado como el siguiente:

100 primeros primos

Vamos a desplegar la App en la Galileo y a ejecutar la misma.
Recordamos que la Galileo es una placa Open Hardware basado en el
procesador Quark SoC X1000 de 32bits de Intel. Por lo tanto, si queremos ejecutar la aplicación debemos modificar la plataforma destino a x86 en las propiedades de compilación de nuestro proyecto.

Compilar en x86

Utilizamos Galileo Watcher con la Galileo conectada a nuestro equipo de desarrollo para acceder a los recursos compartidos y copiar la aplicación:

Copiamos la App en los recursos compartidos

Todo listo!. Si ejecutamos nuestra aplicación vía Telnet el resultado es:

Ejecutando la App en la Galileo vía Telnet

Podéis descargar el sencillo ejemplo realizado a continuación:

También podéis acceder al código fuente directamente en GitHub:

Ver GitHub

Recordar que cualquier tipo de duda o sugerencia la podéis dejar en los comentarios de la entrada.

A tener en cuenta

Hemos verificado que nuestra aplicación .NET de consola funciona
perfectamente. De hecho, muchas otras aplicaciones de consola podrían
funcionar. La mayoría de funciones del Core asi como mscorlib/mscoree
funcionaran. Sin embargo, al comenzar a utilizar librerías dependientes
no implementadas obtendremos distintos tipos de excepciones. No
funciona todo lo que sería necesario. Por ejemplo, si utilizamos System.Diagnostics.Debug, obtendremos una excepción.

Si queremos desarrollar aplicaciones para la Galileo las APIs Wiring
son la opción sólida. Sin embargo,  tenemos un subconjunto de APIs Win32
soportadas que nos permiten poder ejecutar aplicaciones .NET como la
vista en este artículo.

Más información

[Noticia] Los ejemplos del blog se mueven a GitHub!

Introducción

GitHub es una plataforma de desarrollo colaborativo que permite alojar proyectos utilizando el sistema de control de versiones Git.

Además de alojar el código fuente ofrece múltiples herramientas de suma utilidad como:

  • Visor de ramas.
  • Herramientas para realizar revisión de código.
  • Sistema de seguimiento de problemas.
  • Posibilidad de crear wikis.
  • Etc.

En definitiva, permite que os muestre código con facilidad, podréis
descargar el código fuente o echarle un vistazo con rapidez además de
otra serie de aportaciones al blog.

Todos los ejemplos en GitHub

Por los motivos anteriores, actualmente, la mayoría de los ejemplos del blog se estan moviendo a GitHub. Estan organizados por diferentes repositorios:

  • Xamarin.Forms Samples: Ejemplos relacionados con características de Xamarin.Forms.
  • Universal Apps Samples: Ejemplos de Apps Universales.
  • Windows Phone Samples: Proyectos Windows Phone. Desde los iniciales para Windows Phone 7 como los últimos para Windows Phone 8.1.
  • Windows Store Samples: Todos los ejemplos de desarrollo de aplicaciones Windows Store tanto para Windows 8.0 como para Windows 8.1.
  • IoT Samples: Todos los ejemplos de desarrollo de aplicaciones para la Intel Galileo.

Todos los ejemplos incluiran el código fuente, una pequeña Wiki con información del mismo y el enlace a su correspondiente artículo completo y en la mayoría de casos capturas.

NOTA: No se han añadido los ejemplos más antiguos relacionados con Windows Phone 7.0 o 7.5.

One more thing!

También he subido a GitHub el recopilatorio de los eventos en los que he participado en los últimos años. En el repositorio Events tenéis disponibles varias decenas de presentaciones PowePoint junto a sus correspondientes ejemplos.

NOTA: En este caso no se han añadido charlas muy similares entre sí.

La mayoría de artículos del blog llevan asociado un ejemplo. Dicho ejemplo siempre se puede descargar utilizando el icono:

A partir de ahora, todos los ejemplos además se subiran a GitHub ofreciendo en cada artículo un enlace al mismo representado con el siguiente icono:

Ver GitHub

En definitiva, espero poder seguir compartiendo como hasta ahora pero
ofreciendo una nueva vía sencilla y cómoda. Podréis descargar los
ejemplos o sencillamente echar un vistazo a ciertas partes del código.
Además, espero poder nutrir GitHub con herramientas, controles personalizados y otros tipos de proyectos.

Más información

[IoT] Introducción al “Internet de las Cosas” con la Intel Galileo

Introducción

IoT acrónimo utilizado para referirnos a Internet of Things o lo que es lo mismo en nuestro idioma, el Internet de las Cosas es un término sin duda de moda. La leemos y se habla comunmente referenciando varias temáticas relacionadas con la tecnología.

Pero… ¿Qué es el Internet de las Cosas?

Internet de las Cosas

Vivimos en un mondo cada vez más conectado. Es habitual que muchos
cuenten con teléfono conectado a la red pero a su vez es habitual tener
tambien tablet, ordenador y otros elementos básicos conectados. Cada día
estamos rodeados de más tecnología interconectada entre sí. Elementos
cotidianos en nuestra vida diaria comienzan a estar conectados e
identificados. Esto permite un mayor control y gestión del usuario sobre
el conjunto de su vida digital.

Para los desarrolladores nos abre un mundo de posibilidades en un
abanico de sectores gigantescos que hasta ahora eran imposibles o
estaban fuera del alcance de muchos de nosotros.

En el artículo de hoy, vamos a analizar la Intel Galileo, que es
Windows para IoT y a crear nuestro primer proyecto básico para ella.

¿Te apuntas?

¿Intel Galileo?

La Intel Galileo es una placa Open Hardware basado en el procesador Quark SoC X1000 de 32bits de Intel con una velocidad de 400MHz.
Cuenta con conector Ethernet, un zócalo para microSD, puerto serie
RS-232, USB Host, un puerto mini PCI Express y 8 MByte NOR Flash.

Además la placa es compatible con el IDE de Arduino y con las Arduino
Shields pero basado en un procesador Intel aportando una serie de
posibilidades extras que veremos a continuación.

NOTA: La Galileo incluye pines compatibles con una amplia gama de protectores Arduino Uno R3.

 

Intel Galileo

 

Preparando el entorno

Antes de compenzar a trabajar con la Galileo debemos preparar nuestro
entorno, tanto el equipo de desarrollo como la propia Galileo.

Preparando el equipo de desarrollo

En nuestro equipo de desarrollo necesitaremos los siguientes prerrequisitos:

  • Una cuenta Microsoft para registrarnos en el programa de desarrollo Windows para el Internet de las Cosas en Connect.
  • Visual Studio 2013.

NOTA: Cualquier versión de Visual Studio 2013
esta soportada incluida la versión Express. Si cuentas con la versión
Express necesitas instalar Nuget Package Manager. Visual Studio 2015 aun
no esta soportado.

Lo primero que debemos hacer es registrarnos en de desarrollo Windows para IoT en Microsoft Connect. Una vez registrados, procederemos a la descarga de WindowsDeveloperProgramforIOT.msi:

Descarga de WindowsDeveloperProgramforIOT.msi

Tras descargar instalaremos Windows Developer Program for IoT que nos
añadirá las herramientas y plantillas necesarias para poder trabajar
con la Intel Galileo:

Instalamos Windows Developer Program for IOT

Entre el conjunto de opciones instaladas, al final de proceso veremos que contamos con la herramienta Galileo Watcher:

Galileo Watcher

Esta herramienta nos permite detectar la placa que tengámos conectada a la misma red.

Para acceder de forma remota a la palca e interactuar con ella será necesario también utilizar Telnet. Es una característica incluida en Windows, tan solo debemos verificar que este activada.

Para ello, nos dirigimos a Inicio y hacemos clic en Panel de Control. Nos dirigimos a Programas y características y hacemos clic sobre la opción Activar o desactivar las características de Windows.

Habilitar Telnet

En el listado de características de Windows seleccionamos la opción Cliente Telnet y aceptamos.

Preparando la Intel Galileo

Necesitaremos los siguientes prerrequisitos:

  • Una tarjeta microSD de al menos 16GB.

Comenzamos descargando los paquetes necesarios:

Descargamos apply-BootMedia.cmd y  Microsoft Windows for Intel Galileo

Tras la descarga de los ficheros necesarios vamos a preparar la tarjeta microSD. Comenzamos formateándola en FAT32.

A continuación, abrimos una línea de comandos con privilegios de Administrador. Escribiremos:

cd /d %USERPROFILE%Downloads
apply-bootmedia.cmd -destination {YourSDCardDrive} -image {.wimFile downloaded above} -hostname mygalileo -password admin

NOTA: YourSDCardDrive es la unidad de la tarjeta SD en la máquina de desarrollo.

16 Tarjeta SD

Conectando con la Galileo

Una vez preparada la microSD estamos listos para conectar con la
placa. Podemos utilizar varias herramientas para la comunicación con la
misma, Galileo Watchet y Telnet.

Conectando y arrancando la Galileo

Adaptador USB a 10/100Mbps

Tras preparar la tarjeta microSD en el paso anterior la insertaremos
en la Galileo. Proporcionaremos energía a la placa con su adaptador de
corriente y la conectaremos a nuestro equipo de desarrollo utilizando en
adaptador de USB a 10 / 100Mbps.

Una vez conectado debemos esperar a que termine el arranque de Windows en la Galileo.

NOTA: El arranque de Windows en la Galileo es un
proceso que puede llegar a tardar hasta aproximadamente 2 minutos
aunque normalmente es más rápido. Durante este proceso podemos observar
que el LED de la tarjeta microSD parpadea frecuentemente. Cuando el LED
deje de parpadear con frecuencia, nos indicará que el proceso se
completo.

Conexión con la Galileo

Galileo Watcher

Tras el arranque de la placa en nuestro equipo de desarrollo podremos
ver más información de la misma en la herramienta Galileo Watcher:

Información de la Galileo desde la herramienta Galileo Watcher

La herramienta es muy sencilla de utilizar. Mediante un  menu contextual nos permite realizar acciones como:

  • Copiar dirección MAC: Nos permite copiar al Clipboard la dirección MAC de la Galileo.
  • Copiar dirección IP: Nos permite copiar al Clipboard la dirección IP de la Galileo.
  • Abrir Telnet: Nos abre una sesión Telnet con la placa.
  • Abrir navegador: Además de ejecutar Windows, cuenta con un pequeño servidor Web.
  • Recurso compartido red: Al contar con Windows, contamos con la posibilidad de tener el recurso compartido C$.
Menu contextual Galileo Watcher

Telnet

La herramienta Galileo Watcher nos permite abrir una conexión Telnet con la Galileo. Los parámetros de la conexión son:

  • Username: Administrator
  • Password: admin

NOTA: No es la única vía para acceder a la Galileo utilizando Telnet.

Telnet

Abrir navegador

Tenemos tres opciones incluidas en esta opción:

  • Task List: Listado de procesos Windows en ejecución.
  • File List: Listado de ficheros.
  • Memory Statistics: Uso de memoria.
WebServer

Recurso compartido de red

Al contar con Windows, contamos con la posibilidad de tener el recurso compartido C$. Los parámetros para conectar son:

  • Username:myGalileo Administrator
  • Password: admin
Acceder a recursos compartidos de la Galileo

NOTA: myGalileo es el nombre de la placa. En caso de problemas de conexión, utilizaremos la IP de la misma.

Una vez conectado podemos acceder al sistema de archivos de la
Galileo como a cualquier recurso compartido C$ de un sistema Windows.

Conexión Recursos compartidos

Nuestro primer “Hola Mundo”

Llegado a este punto es hora de pasar a la acción creando nuestro primer proyecto. Abrimos Visual Studio y nos dirigimos a las plantillas dentro de la categoría Visual C++. Tendremos una nueva categoría Windows for IoT donde encontraremos una plantilla Galileo Wiring App que nos permitirá crear Apps para la Galileo:

Hola Mundo!

El proyecto por defecto nos incluye el siguiente código:

void loop()
{
    // TODO: Add your code here
 
    digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
    Log(L"LED OFFn");
    delay(1000);               // wait for a second
    digitalWrite(led, HIGH);   // turn the LED on by making the voltage HIGH
    Log(L"LED ONn");
    delay(1000);               // wait for a second
}

El proyecto por defecto (y el “Hola Mundo” habitual) en la Galileo consiste en hacer parpadear un simple LED conectado en el Pin 13.

El código es muy sencillo, cada segundo se modifica el voltaje del Led para hacerlo parpadear.

Llega el momento del despliegue. Antes de desplegar debemos
asegurarnos de verificar una correcta configuración. En las propiedades
del proyecto nos dirigimos al apartado de Debugging.

En el valor de la propiedad Remote Server Name
debemos establecer el nombre de nuestra placa, recordad que podemos
verlo facilmente con la herramienta Galileo Watcher. Además, podemos
configurar facilmente donde desplegaremos la aplicación modificando el
valor de la propiedad Working Directory.

Propiedades del despliegue

Tras desplegar se nos pedirán credenciales y Visual Studio realizará
el despliegue. Podemos verficar el mismo accediendo a los recursos
compartidos de la placa.

Podéis descargar el sencillo ejemplo realizado a continuación:

También podéis acceder al código fuente directamente en GitHub:

Ver GitHub

Y hasta aquí llegamos en esta introducción con la Galileo. En futuras
entradas veremos aplicaciones más complejas, como correr aplicaciones
.NET en la misma y otras opciones. Recordar que cualquier tipo de duda o
sugerencia la podéis dejar en los comentarios de la entrada.

Más información

[Material] Evento Desarrollo de Apps multiplataforma nativas con Xamarin

El evento

El pasado 04 de Febrero, Bravent junto Microsoft organizaron un evento presencial en Madrid
con una serie de sesiones técnicas relacionadas con el desarrollo de
aplicaciones multiplataforma nativas con Xamarin donde tuve el placer de
participar junto a Josué Yeray.

El material

En una de las sesiones repasamos el patrón MVVM aplicándolo a una
aplicación Xamarin en cada una de las plataformas paso a paso utilizando
MVVMCross.

Tuvimos otra sesión donde hablamos de Xamarin.Forms. Xamarin presento
una nueva herramienta en su suite llamada Xamarin.Forms que tiene como
objetivo permitir a los desarrolladores crear la interfaz de usuario
para iOS, Android y Windows Phone con un mismo código común en C# o
XAML. En esta sesión vimos todos los aspectos relacionados con
Xamarin.Forms creando una aplicación desde cero donde aprendimos desde
conceptos básicos a uso de dependencias, servicios, etc.

El ecosistema Xamarin no cesa en las herramientas de desarrollo. Tenemos
a disponible una gran variedad de servicios destinados a complementar
el mismo, analíticas, testing, análisis de rendimiento, etc. En esta
sesión hicimos un repaso por todos los servicios disponibles.

En cuanto a las demos técnicas realizadas, las tenéis todas disponibles en GitHub:

Ver GitHub

Al final de la sesión hicimos un pequeño juego tipo concurso de
preguntas y respuestas donde todos nos lo pasamos muy bien y sorteamos
entradas para la dotNet Spain Conference.

Próximos eventos

Si te llama la atención el material, recuerdo que el evento pasará aun por otras ciudades:

  • Sevilla: El 9 de Febrero en el Clouding Point. Registro.
  • Barcelona: El 16 de Febrero en las oficinas de Microsoft. Registro.

Esperamos poder veros en alguna de ellas!

Más información

[Evento] Experiencias del mundo real con Xamarin

Introducción

Actualmente nos encontramos en un mercado con múltiples plataformas:

  • iOS
  • Android
  • Windows Phone

Esto
a nivel de desarrollo nos supone barreras. Contamos con plataformas de
desarrollo diferentes, lenguajes diferentes, etc. suponiendo un nivel de
aprendizaje y esfuerzo cada vez mayor de cara a desarrolladores. Entre
las posibles opciones contamos con Xamarin. Se trata de
un Framework de desarrollo que permite crear aplicaciones para Android,
iOS y Windows usando C# y la plataforma .NET.

El evento: Experiencias del mundo real con Xamarin

Con
mejoras continuas, nuevos servicios y una integración cada vez mayor
con Visual Studio, para muchos, Xamarin se ha convertido en la opción
ideal para el desarrollo de aplicaciones nativas multiplataforma.

Por ese motivo Roberto L. Bisbé ha planteado un Hangout de dos horas
de duración donde distintos desarrolladores además de distintos
miembros del propio equipo de Xamarin trasmitiran experiencias reales
desarrollando proyectos con Xamarin.

El conjunto de ponentes es muy variado y completo contando con:

También participará un servidor aportando todo lo posible. El Hangout tendrá lugar el próximo 10 de febrero a las 20:00 GMT+1 en el siguiente enlace.

Por si fuese poco, los chicos de SyncFusion nos ofrecen la posibilidad de sortear una licencia gratuita para uno de sus productos.

¿Te apuntas?

Más información