[Eventos] re-Connect Tour

re-connectEl Tour

Tras un exitoso Microsoft Connect(); 2016, en New York, donde se presentaron importantes novedades relacionadas con la plataforma Cloud, novedades en .NET, Visual Studio para MacOS o novedades en Xamarin, ¿algo mejor que recopilar todas las novedades en un evento?.

Si, haciendo varios y organizarlos en un Tour por varias ciudades!.

Las ciudades y fechas son:

La agenda

  • 9:30 Más productividad que nunca en el desarrollo móvil multiplataforma con Xamarin
    En esta charla veremos las novedades más importantes que llegan de la mano de Xamarin. Para empezar el nuevo Visual Studio for Mac que permite crear aplicaciones iOS y Android con backend net core. Pero esa no es la única novedad: veremos en acción el previsualizador de Xamarin Forms, Xamarin Profiler y el espectacular Xamarin Inspector que lleva el desarrollo móvil a otro nivel. Y finalmente Visual Studio Mobile Center, la evolución de HockeyApp y la integración con toda la suite de movilidad de Microsoft.
  • 10:30 .NET Core & SQL❤ Linux
    Net Core 1.1 ya está aquí, y a pesar de ser una versión “menor” no deja de tener novedades interesantes: la integración con los logs de Azure, mejoras de rendimiento y, por supuesto Entity Framework 1.1, entre otras. En esta charla desgranaremos las novedades de asp.net core 1.1 y mostraremos como EF1.1 permite trabajar con las últimas novedades de SQL Server. Comentaremos el concepto de SQL Server CPSA y como nos impacta eso como desarrolladores. Y por supuesto, veremos SQL Server for Linux en acción.
  • 11:30 Microsoft y el mundo de los contenedores
    En esta charla veremos las novedades incluídas en Visual Studio 2017 para facilitar el uso de Docker. Comentaremos que es Docker, como funciona y como con Visual Studio 2017 podemos crear aplicaciones netcore y empaquetarlas con Docker de forma sencilla, sin perder ni un ápice de productividad. Veremos también como publicar contenedores Docker en un AppService, como usar Azure Container Registry así como un esbozo de Azure Container Services. Y para finalizar comentaremos las novedades de VSTS al respecto de Docker.
  • 12:30 ASP Net Core & Visual Studio en 3 sabores, elige el tuyo
    En esta charla veremos lo sencillo que es desarrollar una aplicación netcore con cualquiera de las 3 ediciones de Visual Studio que disponemos, Visual Stduio, Visual Studio for Mac y Visual Studio Code 1.7 bajo Linux. Para ello crearemos una aplicación sencilla asp.net core que use MongoDb. Veremos todas las facilidades de la suite de Visual Studio para depurar código y para navegar por el código. Finalmente veremos cómo usar Docker desde la suite de Visual Studio para crear un contenedor con nuestra aplicación, y usando las nuevas CLI de Azure veremos cómo publicarlo en un AppService. Finalmente veremos cómo podemos usar DocumentDb en lugar de MongoDb en menos que canta un gallo

¿Te apuntas?

Más información

[dotNetMálaga 2016] Taller Xamarin

logo_dotnetmlg_full_color_2tintas_2dotNetMálaga 2016

El próximo sábado 10 de Diciembre tiene lugar la II edición de la conferencia dotNetMálaga que constará de un día completo con numerosas sesiones y talleres divididos en dos tracks, .NET y Web. También habrá regalos y sorteos para los asistentes.

Taller Xamarin

De 11:15h a 13:30h participaré con un divertido taller de desarrollo de aplicaciones móviles multiplataforma con Xamarin. El objetivo será realizar una aplicación paso a paso. También se realizarán pequeñas sesiones para trasmitir los conceptos básicos necesarios. Al final de taller, contaremos con alguna sorpresa y regalo.

Requisitos:

  • Visual Studio y Xamarin instalado. La versión Community gratuita es perfectamente válida.
  • SDK de desarrollo Windows 10.
  • Es recomendable contar con emuladores instalados.
Taller Xamarin

Taller Xamarin

Anímate a participar!

Más información

[Material] re-Connect(); Madrid 2016

re-connectEl evento

Tras un exitoso Microsoft Connect(); 2016, en New York, donde se presentaron importantes novedades relacionadas con la plataforma Cloud, novedades en .NET, Visual Studio para MacOS o novedades en Xamarin, ¿algo mejor que recopilar todas las novedades en un evento?

De esta forma, el pasado 30 de Noviembre, tenía lugar en Madrid el re-Connect(); 2016. Una jornada con varias sesiones técnicas con miembros de la comunidad y también con miembros de Microsoft como David Carmona.

El material

Pude participar en el evento con una de las sesiones.

Novedades Xamarin

Novedades Xamarin

Desde que Microsoft hizo pública la compra de Xamarin el pasado febrero, todos estábamos esperando ansiosamente el gran evento de Microsoft, para saber cual va a ser la dirección del desarrollo multiplataforma liderado por Miguel de Icaza. La verdad que este evento no nos ha dejado indiferentes y se han anunciado muchas novedades que nos afectaran directa o indirectamente en nuestros día a día. En esta charla hicimos un pequeño resumen de las noticias más destacadas enfocadas al mundo .NET y Xamarin y hablamos de las novedades en IDEs (Visual Studio para MacOS), las nuevas herramientas, DevOps con Visual Studio Mobile Center o la llegada de Tizen.NET.

Se puede ver toda la grabación del evento en Channel 9.

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

Ver GitHub

Más información

[Material] Xamarin Dev Day Madrid

El evento

El pasado sábado 26 de Noviembre, tenía lugar en Madrid el Xamarin Dev Days. Una jornada con varias sesiones técnicas, taller, regalos y mucho networking.

El resultado fue un fantástico día de desarrollo Xamarin con muchas preguntas, ayuda y tiempo para charlar entre todos rodeados de un café o unas pizzas.

El material

Pude participar en el evento con una de las sesiones. Nos centramos en el desarrollo de aplicaciones móviles multiplataforma utilizando Xamarin.Forms:

Comenzamos por una introducción de conceptos básicos, primera demo aplicando MVVM y terminamos repasando todas las últimas novedades como DataPages, Native Views o el desarrollo para Tizen.

Tras las sesiones, realizamos un muy divertido taller donde paso a paso, desarrollamos una aplicación Xamarin.Forms aplicando MVVM y accediendo a información meteorológica.

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

Ver GitHub

Quisiera terminar añadiendo algunos agradecimientos. Comienzo por los chicos de Liferay por las instalaciones y toda la ayuda; a Plain Concepts y Bravent por su patrocinio; a Xamarin también por patrocinar el evento; a mis compañeros Dachi Gogotchuri, Sergio Gasca, Ramón Esteban y Alejandro Campos por sus demos y ayudar con todo y por supuesto a los asistentes. Gracias a todos.

Más información

[Material Codemotion 2016] Introducción al desarrollo de HoloLens

El evento

El pasado 18 y 19 de Noviembre, en la universidad San Pablo CEU, tenía lugar el Codemotion 2016. Evento destinado a desarrolladores en España con más de 2000 desarrolladores, más de 30 comunidades técnicas y más de 150 sesiones técnicas.

Codemotion 2016

Codemotion 2016

El material

He tenido la oportunidad de participar este año hablando de desarrollopara HoloLens.

Desarrollo para HoloLens

Desarrollo para HoloLens

Tras una breve introducción donde repasamos conceptos como realidad virtual, realidad aumentada o que es un holograma, entramos de lleno a conocer las HoloLens. Conbinando presentaciones, el dispositivo físico y el portal del dispositivo conocimos las características, sensores y posibilidades.

A continuación, entramos de lleno a hacer una App. Utilizando Wave Engine realizamos una aplicación sobre el sistema solar (en directo).

Terminamos con algunas aplicaciones desarrolladas ya publicadas en la Store, consejos, preguntas y alguna sorpresa.

La presentación (versión reducida suprimiendo videos):

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

Ver GitHub

Más información

[Podcast Interfaz] Conociendo Xamarin

interfaz-podcastIntroducción

Recientemente, Rodrigo Díaz Concha, Windows Development MVP y Microsoft Regional Director en Mexico, ha lanzado un podcast (muy recomendado) llamado Interfaz. El objetivo del podcast es ser un medio de comunicación que toque diversos temas del espectro de tecnologías de software que tenemos a nuestro alcance hoy en día con una frecuencia semanal.

El podcast, conociendo Xamarin

En el episodio 9 del podcast, tengo el placer de poder participar hablado de Xamarin. Durante el episodio hablamos acerca de qué es Xamarin, las opciones para el desarrollo con Xamarin, las ventajas de usar Xamarin.Forms, el futuro de Xamarin y los errores comunes que las personas cometen al iniciar con esta tecnología.

¿Te resulta interesante?

Puedes escuchar el podcast a continuación.

 

Más información

[Xamarin.Forms] Un vistazo al uso de Native Views desde XAML

XamarinIntroducción

Xamarin.Forms añade una capa de abstracción sobre la capa de la interfaz de usuario que permite definir la misma una única vez para todas las plataformas con código C# o XAML. A pesar de la abstracción, podemos acceder a características específicas de la plataforma utilizando DependencyService o crear nuevos controles accediendo a características nativas gracias al uso de Custom Renders, efectos o Native Embbeding.

En el uso de Custom Renders o efectos, necesitamos crear una clase en la PCL con la definición del control o efecto y una clase en cada plataforma soportada con la implementación.

¿Y si se puede hacer todo de una forma más directa?

Native Views

Con Xamarin.Forms 2.3.3.+se introduce el concepto de Native Views. Se pueden incrustar directamente vistas nativas en el XAML de nuestra interfaz compartida ya sea utilizando proyectos compartidos o librerías portables.

Uso en Android

Añadir vistas nativas es realmente sencillo. Necesitamos declarar los namespaces XML (xmlns) necesarios:

xmlns:android="clr-namespace:Android.Widget;assembly=Mono.Android;targetPlatform=Android"
xmlns:androidForms="clr-namespace:Xamarin.Forms;assembly=Xamarin.Forms.Platform.Android;targetPlatform=Android"

Tras añadir los namespaces correspondientes, podemos acceder directamente a controles nativos:

<android:CalendarView         
     x:Arguments="{x:Static androidForms:Forms.Context}" />

Podemos acceder directamente a las propiedades del control nativo como atributos XML. En caso de requerir el uso de argumentos podemos establecerlo utilizando x:Arguments.

En Android es necesario pasar el contexto de Xamarin.Forms. En caso contrario obtendremos un error:

System.MissingMethodException: Default constructor not found for type Android.Widget.xxxxx

El resultado:

Calendario nativo de Android

Calendario nativo de Android

El turno de iOS

En el resto de plataformas, es practicamente igual el uso de Native Views. Comenzamos definiendo el namespace necesario:

xmlns:ios="clr-namespace:UIKit;assembly=Xamarin.iOS;targetPlatform=iOS"

Y podemos acceder directamente a controles nativos:

<ios:UIDatePicker />

El resultado:

UIDatePicker

UIDatePicker

Y ahora Windows

En el caso de Windows, igualmente necesitamos declarar el namespace:

xmlns:uwp="clr-namespace:Windows.UI.Xaml.Controls;assembly=Windows, Culture=neutral, PublicKeyToken=null, ContentType=WindowsRuntime;targetPlatform=Windows"

Y tenemos acceso a vistas nativas:

<uwp:CalendarDatePicker />

El resultado:

nativeviews-windows

CalendarDatePicker

Utilizando Native Views

Tras definir tres vistas, cada una con vistas nativas de cada plataforma, para utilizarlas en una página debemos definir el namespace correspondiente:

xmlns:nativeViews="clr-namespace:NativeViews.Views.Native" 

Y añadir cada vista:

<Grid>
     <nativeViews:AndroidView />
     <nativeViews:IosView />
     <nativeViews:WindowsView />
</Grid>

Sencillo, ¿cierto?.

¿Qué ocurre al ejecutar la aplicación y cargar esta vista en Android (por ejemplo)?.

Sólo se renderizarán los elementos Xamarin.Forms y la vista nativa de Android. No se mostrará nada relacionada con las visats nativas de iOS o Windows. Igual comportamiento obtendremos en otras plataformas.

Tenéis el código fuente del ejemplo utilizado disponible en GitHub:

Ver GitHub

Recuerda, cualquier tipo de duda o sugerencia es bienvenida en los comentario del artículo.

Atener en cuenta

A la hora de utilizar Native Views en nuestros desarrollos hay que tener en cuenta que:

  • No se puede utilizar Native Views en una vista con XAMLC (compilación de XAML) activado.
  • No podemos utilizar x:Name en controles nativos.

one-more-thingOne more thing

La posibilidad de añadir directamente vistas nativas en el XAML de nuestras vistas compartidas en Xamarin.Forms es una nueva característica interesante pero en la mayoría de ocasiones nos interesará gestionar de una forma adecuada la interacción con los controles.

Native Views permite el uso de enlace a datos tanto en modo OneWay como TwoWay. Gracias a esta posibilidad podemos crear vistas realmente complejas de una forma más simple. En próximos artículos continuaremos profundizando en el concepto de Native Views centrándonos en el uso de enlace a datos. Permanece atento!

Más información

[Xamarin.Forms] Behavior para hacer scroll infinito

stack-04-wfIntroducción

Actualmente el control de tipo listado incluido en Xamarin.Forms incluye soporte a características avanzadas interesantes como el uso de plantillas diferentes para cada elemento del listado o la posibilidad de realizar Pull To Refresh.

A pesar de que el refresco de listados realizando Pull To Refresh es una forma bastante habitual y extendida, no es la única. También en ocasiones es necesario refrescar listados a la medida que se va realizando scroll, lo que se conoce como scroll infinito.

¿Cómo realizamos scroll infinito en Xamarin.Forms?

El evento ItemAppearing

El control ListView lanza el evento ItemAppearing cada vez que un elemento pasa a ser visible. Nuestra tarea para detectar por lo tanto si hemos llegado al final es que el último elemento visible es el último elemento disponible.

NOTA: Habitualmente siempre que sea posible se recomienda el uso de idntificadores para realizar las comprobaciones necesarias.

Creando un Behavior

Los Behaviors (o comportamientos en Español) nos permiten añadir lógica directamente en XAML para realizar acciones sin necesidad de escribir código extra en el code behind.

Vamos a crear un Behavior que asociado a un listado permita lanzar un comando llegado al final del scroll para solicitar nuevos elementos.

Comenzamos creando una clase que herede de Behavior<T>:

public class IniniteListScrollingBehavior : Behavior<ListView>
{

}

Debemos implementar:

  • Propiedad AssociatedObject: Control al que se adjuntará el Behavior, es decir, el ListView.
  • Método OnAttachedTo: Lanzado inmediatamente tras adjuntar el Behavior al control. Se recibe una referencia al control adjuntado idóneo para acceder a propiedades o eventos del mismo.
  • Método OnDetachingFrom: Lanzado cuando el Behavior se elimina del control. Lugar perfecto para realizar tareas de limpieza (gestión de suscripciones de eventos, liberar recursos, etc.).
public ListView AssociatedObject { get; private set; }

protected override void OnAttachedTo(ListView bindable)
{
     base.OnAttachedTo(bindable);

     AssociatedObject = bindable;
     bindable.BindingContextChanged += OnBindingContextChanged;
     bindable.ItemAppearing += OnItemAppearing;
}

protected override void OnDetachingFrom(ListView bindable)
{
     base.OnDetachingFrom(bindable);

     bindable.BindingContextChanged -= OnBindingContextChanged;
     bindable.ItemAppearing -= OnItemAppearing;
     AssociatedObject = null;
}

private void OnBindingContextChanged(object sender, System.EventArgs e)
{
     base.OnBindingContextChanged();
     BindingContext = AssociatedObject.BindingContext;
}

private void OnItemAppearing(object sender, ItemVisibilityEventArgs e)
{
     var listview = ((ListView)sender);

     if (listview.IsRefreshing)
          return;
}

Vamos a utilizar el método ItemAppearing del ListView para lanzar un comando encargado de refrescar el listado. Necesitamos crear una BindableProperty de tipo ICommand en el Behavior:

public static readonly BindableProperty CommandProperty =
     BindableProperty.Create("Command", typeof(ICommand), typeof(IniniteListScrollingBehavior), null);

public ICommand Command
{
     get { return (ICommand)GetValue(CommandProperty); }
     set { SetValue(CommandProperty, value); }
}

En el método ItemAppearing del control:

private void OnItemAppearing(object sender, ItemVisibilityEventArgs e)
{
     var listview = ((ListView)sender);

     if (listview.IsRefreshing)
          return;

     if (Command == null)
     {
          return;
     }

     if (Command.CanExecute(e.Item))
     {
          Command.Execute(e.Item);
     }
}

Accedemos al comando (siempre y cuando el listado no siga refrescando) y lo ejecutamos pasándole el último elemento visible como parámetro. Este parámetro lo utilizaremos desde la ViewModel para determinar si ese elemento es el último de la lista o no.

Utilizando el Behavior

Tras crear el Behavior ha llegado el momento de utilizarlo. Pero antes de lanzarnos de pleno…¿de dónde obtenemos la información?.

En la ViewModel tendremos una propiedad pública con el listado a mostrar:

private ObservableCollection<Monkey> _monkeys;

public ObservableCollection<Monkey> Monkeys
{
     get { return _monkeys; }
     set
     {
          _monkeys = value;
          RaisePropertyChanged();
     }
}

Utilizaremos también un par de propiedades para determinar:

  • IsBusy: Esta propiedad nos indicará cuando se esta realizando la carga de más información. Utilizada en la UI para mostrar un indicador visual de carga en caso necesario.
  • CurrentPage: Un entero que almacena el número de página utilizado al cargar información. Gran cantidad de APIs soportan paginación. En la mayoría de ocasiones necesitamos indicar el número de página a cargar (justo esta propiedad) y el número de elementos por página.
public bool IsBusy { get; set; }

public int CurrentPage { get; set; }

En nuestro ejemplo, para simplificar todo en la medida de lo posible y centrarnos en el uso del Behavior, vamos a cargar datos locales:

private void LoadItems(int pageSize = 10)
{
     IsBusy = true;

     if(Monkeys == null)
     {
          Monkeys = new ObservableCollection<Monkey>();
     }

     for (int i = CurrentPage; i < CurrentPage + pageSize; i++)
     {
          Monkeys.Add(new Monkey()
          {
               MonkeyId = i + 1,
               Name = string.Format("Monkey {0}", i + 1)
          });
     }

     CurrentPage = Monkeys.Count;
     IsBusy = false;
}

El Behavior utilizará un comando para refrescar la información:

private ICommand _refreshCommand;

public ICommand RefreshCommand
{
     get { return _refreshCommand = _refreshCommand ?? new DelegateCommand<Monkey>(RefreshCommandExecute, RefreshCommandCanExecute); }
}

public bool RefreshCommandCanExecute(Monkey monkey)
{
     return !IsBusy && 
            Monkeys.Count != 0 && 
            Monkeys.Last().MonkeyId == monkey.MonkeyId;
}

public void RefreshCommandExecute(Monkey monkey)
{
     LoadItems();
}

Para utilizarlo en nuestra UI compartida XAML, debemos crear un namespace:

xmlns:behavior="clr-namespace:InfiniteScrollingBehavior.Behaviors;assembly=InfiniteScrollingBehavior"

Utilizando la propiedad Behaviors del listado, adjuntamos el Behavior creado enlazando con el comando previamente visto.

<ListView
     ItemsSource="{Binding Monkeys}"
     IsRefreshing="{Binding IsBusy}"
     HasUnevenRows="true">
     <ListView.ItemTemplate>
          <DataTemplate>
               <ViewCell>
                    <templates:MonkeyTemplate />
               </ViewCell>
           </DataTemplate>
       </ListView.ItemTemplate>
       <ListView.Behaviors>          
          <behavior:IniniteListScrollingBehavior  
                Command="{Binding RefreshCommand}">
          </behavior:IniniteListScrollingBehavior>
     </ListView.Behaviors>
</ListView>

El resultado:

inifinitescrollingbehavior

Sencillo y además facilmente reutilizable.

Tenéis el código fuente del ejemplo utilizado disponible en GitHub:

Ver GitHub

Recuerda, cualquier tipo de duda o sugerencia es bienvenida en los comentario del artículo.

Más información

[Podcast] Xamarin: Mitos y verdades

mic-02El podcast

Recientemente los compañeros Camilo Galiana y Rodrigo Díaz crearon un podcast llamado Just In Time. Un podcast sobre desarrollo movil, buenas practicas, lenguajes y desvarios varios.

En el primer captítulo, he tenido el placer de participar junto a Josué Yeray y Marcos Cobeña para hablar de Xamarin. El enfoque buscado era tratar aspectos importantes relacionados con el desarrollo y uso de Xamarin desde un punto de vista neutro y desde la experiencia. En el podcast tratamos aspectos como:

  • El rendimiento en comparación con aplicaciones nativas.
  • Cantidad de código compartido en aplicaciones “reales”.
  • Herramientas de Xamarin e integración de Visual Studio en comparación con las herramientas nativas.
  • Uso de plugins y de librerías nativas, ventajas y dificultades.
  • Frecuencia y estabilidad de cada nueva versión.
  • Etc.

Si te resulta interesante, puedes escuchar el podcast en el siguiente enlace.

Más información

[Xamarin.Forms] Propiedades específicas desde XAML para Windows Desktop y Mobile

Introducción

Xamarin.Forms añade una capa de abstracción sobre la capa de la interfaz de usuario permitiendo definir la misma una única vez siendo válida para todas las plataformas.

Xamarin.Forms

Xamarin.Forms

A pesar de definir la interfaz de usuario una única vez para todas las plataformas, tenemos la posibilidad de realizar personalizaciones y adaptaciones para ofrecer la mejor experiencia posible en cada una de las plataformas soportadas.

La clase Device

La clase Device sin duda alguna es una de las claves a la hora de personalizar la interfaz de usuario por plataforma. Esta clase contiene diversas propiedades y métodos para personalizar la UI y la funcionalidad en base a la plataforma.

La propiedad OS permite identificar la plataforma en la que se ejecuta la aplicación. Puede ser un valor de la enumeración TargetPlatform con uno de los siguientes valores:

  • iOS
  • Android
  • WinPhone (Windows 8 Silverlight)
  • Windows (Windows 8.1, Windows Phone 8.1 y UWP)

Permite de forma sencilla y efectiva personalizar la interfaz o la lógica de la aplicación en base a la plataforma:

if (Device.OS == TargetPlatform.iOS) 
{
    stackLayout.Padding = new Thickness (0, 20, 0, 0);
}

La interfaz de usuario de las aplicaciones Xamarin.Forms podemos definirla en C# o desde código XAML. Desde XAML también podemos realizar personalizaciones en base a la plataforma utilizando el método OnPlatform. Device.OnPlatform es un método que cuenta con uno de los siguientes parámetros opcionales:

  • iOS
  • Android
  • WinPhone
<BoxView 
     WidthRequest="100"
     HorizontalOptions="Center">
  <BoxView.Color>
    <OnPlatform x:TypeArguments="Color"
      iOS="Green"
      Android="#738182"
      WinPhone="Accent" />
  </BoxView.Color>
</BoxView>

Lo visto esta genial pero hay un pequeño detalle que nos puede causar problemas…

¿Qué ocurre si deseamos personalizar la UI desde XAML y dinstinguir entre Windows Phone y Windows?.

La clase OnPlatform no nos facilita la gestión completa. Siempre nos queda la posibilidad de hacer lo necesario desde código C# pero aspectos directamente relacionados con la UI sería fantástico poder llevarlo a cabo desde la propia UI o lo que es lo mismo desde código XAML.

CustomOnPlatform

Aquí es donde entra en juego un pequeños helper creado en código C#:

public sealed class CustomOnPlatform<T>
{
     public CustomOnPlatform()
     {
         Android = default(T);
         iOS = default(T);
         WinPhone = default(T);
         Windows = default(T);
     }

     public T Android { get; set; }

     public T iOS { get; set; }

     public T WinPhone { get; set; }

     public T Windows { get; set; }

     public static implicit operator T(CustomOnPlatform<T> onPlatform)
     {
         switch (Xamarin.Forms.Device.OS)
         {
             case Xamarin.Forms.TargetPlatform.Android:
                 return onPlatform.Android;
             case Xamarin.Forms.TargetPlatform.iOS:
                 return onPlatform.iOS;
             case Xamarin.Forms.TargetPlatform.WinPhone:
                 return onPlatform.WinPhone;
             case Xamarin.Forms.TargetPlatform.Windows:
                 if (Xamarin.Forms.Device.Idiom == Xamarin.Forms.TargetIdiom.Phone)
                     return onPlatform.WinPhone;
                 else
                     return onPlatform.Windows;
         }
     }
}

Sencillo. Utilizamos la propiedad OS de la clase Device para determinar la plataforma en la que estamos. En el caso de Windows, dado que nos indica el mismo valor en UWP (tanto si estamos en el Desktop como Mobile) hacemos uso combinado con la propiedad Idiom.

La propiedad Idiom tiene como objetivo fundamental determinar si la aplicación se ejecuta en teléfono, tableta o escritorio. Puede contener unos de los siguientes valores de la enumeración TargetIdiom:

  • Desktop: Detecta aplicación UWP en Windows 10.
  • Phone: La aplicación corre en iPhone, iPod Touch, móvil Android o Windows Phone.
  • Tablet: iPad, tableta Android o Windows 8.1.

De esta forma, además de detectar cuando se ejecuta en iOS y Android, podremos detectar cuando se ejecuta en Windows Phone y en Windows (UWP) tanto en escritorio como móvil.

Para usar el helper desde XAML, definimos el namespace:

xmlns:helpers="clr-namespace:CustomOnPlatform.Helpers;assembly=CustomOnPlatform"

Y lo usamos tal y como usaríamos OnPlatform:

<BoxView 
     HorizontalOptions="Center"
     VerticalOptions="Center"
     HeightRequest="100"
      WidthRequest="100">
     <BoxView.BackgroundColor>
         <helpers:CustomOnPlatform  
             x:TypeArguments="Color"
             Android="Red"
             iOS="Blue"
             WinPhone="Yellow"            
             Windows="Green"/>
     </BoxView.BackgroundColor>
</BoxView>

El resultado de la ejecución anterior es, cuadrado rojo en Android, azul en iOS, amarillo en Windows Phone (Silverlight) y Windows Mobile (UWP) siendo por último, verde en Windows escritorio.

Tenéis el código fuente del ejemplo utilizado disponible en GitHub:

Ver GitHub

Recuerda, cualquier tipo de duda o sugerencia es bienvenida en los comentario del artículo.

Más información