In this session we are going to see in depth the new .NET MAUI handlers, a comparison with the Xamarin.Forms renderers as well as other related aspects such as the possibilities when extending or customizing a handler, performance, etc.
Este documento presenta una introducción a la creación de controles personalizados en Xamarin.Forms. Explica cómo crear controles utilizando Custom Renderers, permitiendo personalizar la apariencia y comportamiento de controles existentes en cada plataforma. También explica cómo crear controles utilizando SkiaSharp, dibujando directamente en un canvas para obtener un alto rendimiento de forma multiplataforma. Finalmente, cubre aspectos como la creación de propiedades enlazables y el rendimiento al crear controles.
Analizando interfaces de usuario avanzadas con Xamarin.FormsJavier Suárez Ruiz
Este documento presenta las características avanzadas de interfaz de usuario que se pueden lograr con Xamarin.Forms, incluyendo interfaces compartidas entre plataformas, lógica de negocios compartida y renderizadores personalizados. También muestra varios ejemplos de aplicaciones como My Trip Countdown, Pulse Music y Netflix.
Este documento presenta sobre Xamarin.Forms y sus nuevas características en Xamarin.Forms 3.0. Ahora se puede crear aplicaciones para nuevas plataformas como Linux (usando GTK#), WPF, y la web. También hay soporte para nuevos dispositivos como wearables y Internet de las Cosas. Con nuevas características como SkiaSharp, FlexLayout y VisualStateManager es posible crear aplicaciones con una interfaz más atractiva.
Tech Club Asturias: Un vistazo al presente y futuro de Xamarin.FormsJavier Suárez Ruiz
Xamarin.Forms es un framework de código abierto de Microsoft para crear aplicaciones multiplataforma para iOS, Android y Windows desde una base de código común en C#. .NET MAUI es la evolución de Xamarin.Forms que permitirá crear interfaces de usuario nativas para múltiples dispositivos desde un solo proyecto de código con acceso a las API nativas de cada plataforma.
dotNetMálaga 2017 - Trucos y consejos rendimiento Xamarin.FormsJavier Suárez Ruiz
Este documento proporciona información sobre Xamarin.Forms y cómo mejorar el rendimiento de las aplicaciones desarrolladas con este framework. Se discuten temas como el uso adecuado de layouts, views, listviews y bindings para optimizar el rendimiento. También se mencionan técnicas como fast renderers, custom renderers y behaviors que pueden acelerar el desempeño de las aplicaciones. Finalmente, el documento brinda consejos adicionales como el uso de AOT, la optimización de recursos y el caching de imágenes.
Xamarin.Forms Shell introduce una nueva jerarquía para la organización de la interfaz de usuario de las aplicaciones móviles que maximiza la reutilización de código y facilita la creación de diseños consistentes entre plataformas. La nueva API de navegación basada en URLs mejora la experiencia de usuario y permite funcionalidades como deep linking. Además, Shell proporciona nuevas opciones de diseño visual para conseguir la misma apariencia en iOS y Android sin necesidad de código específico de plataforma.
Este documento presenta una introducción a la creación de controles personalizados en Xamarin.Forms. Explica cómo crear controles utilizando Custom Renderers, permitiendo personalizar la apariencia y comportamiento de controles existentes en cada plataforma. También explica cómo crear controles utilizando SkiaSharp, dibujando directamente en un canvas para obtener un alto rendimiento de forma multiplataforma. Finalmente, cubre aspectos como la creación de propiedades enlazables y el rendimiento al crear controles.
Analizando interfaces de usuario avanzadas con Xamarin.FormsJavier Suárez Ruiz
Este documento presenta las características avanzadas de interfaz de usuario que se pueden lograr con Xamarin.Forms, incluyendo interfaces compartidas entre plataformas, lógica de negocios compartida y renderizadores personalizados. También muestra varios ejemplos de aplicaciones como My Trip Countdown, Pulse Music y Netflix.
Este documento presenta sobre Xamarin.Forms y sus nuevas características en Xamarin.Forms 3.0. Ahora se puede crear aplicaciones para nuevas plataformas como Linux (usando GTK#), WPF, y la web. También hay soporte para nuevos dispositivos como wearables y Internet de las Cosas. Con nuevas características como SkiaSharp, FlexLayout y VisualStateManager es posible crear aplicaciones con una interfaz más atractiva.
Tech Club Asturias: Un vistazo al presente y futuro de Xamarin.FormsJavier Suárez Ruiz
Xamarin.Forms es un framework de código abierto de Microsoft para crear aplicaciones multiplataforma para iOS, Android y Windows desde una base de código común en C#. .NET MAUI es la evolución de Xamarin.Forms que permitirá crear interfaces de usuario nativas para múltiples dispositivos desde un solo proyecto de código con acceso a las API nativas de cada plataforma.
dotNetMálaga 2017 - Trucos y consejos rendimiento Xamarin.FormsJavier Suárez Ruiz
Este documento proporciona información sobre Xamarin.Forms y cómo mejorar el rendimiento de las aplicaciones desarrolladas con este framework. Se discuten temas como el uso adecuado de layouts, views, listviews y bindings para optimizar el rendimiento. También se mencionan técnicas como fast renderers, custom renderers y behaviors que pueden acelerar el desempeño de las aplicaciones. Finalmente, el documento brinda consejos adicionales como el uso de AOT, la optimización de recursos y el caching de imágenes.
Xamarin.Forms Shell introduce una nueva jerarquía para la organización de la interfaz de usuario de las aplicaciones móviles que maximiza la reutilización de código y facilita la creación de diseños consistentes entre plataformas. La nueva API de navegación basada en URLs mejora la experiencia de usuario y permite funcionalidades como deep linking. Además, Shell proporciona nuevas opciones de diseño visual para conseguir la misma apariencia en iOS y Android sin necesidad de código específico de plataforma.
El documento presenta las nuevas características y mejoras de .NET Core, incluyendo el soporte para Windows Desktop, IoT y AI en .NET Core 3, así como nuevas tecnologías como Blazor, ML.NET y Azure DevOps. También destaca el crecimiento continuo de la plataforma .NET y C# con más de un millón de nuevos desarrolladores .NET activos en el último año.
Este documento presenta las novedades y mejoras recientes en Xamarin.Forms y las herramientas de Xamarin. Entre las novedades se incluyen mejoras en las herramientas como Hot Reload y Hot Restart para reducir los tiempos de iteración, la introducción de Shell para simplificar la navegación, y nuevos controles como CarouselView y CollectionView. También se discuten las mejoras planificadas como soporte para GIFs, gradientes y nuevos controles.
A la hora de desarrollar aplicaciones con Xamarin.Forms el rendimiento suele ser un factor a tener en cuenta. En Xamarin.Forms, ¿sabes el ciclo de vida de un Layout?, ¿qué opciones de Layout son más óptimas?, ¿cómo afectan los Bindings al rendimiento y como tratarlos?, ¿qué debemos hacer para optimizar el trabajo con imágenes?, ¿ListView o CollectionView?, ¿y qué ocurre con Shell? A estas y otras preguntas habituales de rendimiento daremos solución, con datos y pruebas en forma de sencillos consejos a tener en cuenta a la hora de desarrollar una aplicación con Xamarin.Forms.
Xamarin.Forms es un framework que nos añade una capa de abstracción permitiendo desarrollar la interfaz de nuestras aplicaciones móviles multiplataforma una única vez, compartiendo el código de la UI. Veremos como crear aplicaciones con Xamarin.Forms además de centrarnos en cómo acceder a características propias de cada plataforma mediante la creación de servicios o Custom Renders.
Este documento describe un taller sobre el desarrollo de aplicaciones móviles con Xamarin.Forms empleando Machine Learning. El taller mostrará cómo crear la estructura de un proyecto Xamarin, diseñar interfaces de usuario, acceder a código específico de plataforma, realizar peticiones HTTP y más. La aplicación que se construirá podrá tomar fotos y analizarlas con Custom Vision para identificar si contienen perros calientes. El taller resolverá dudas y proporcionará recursos adicionales.
Este documento introduce Embeddinator-4000, una herramienta que permite convertir librerías .NET en librerías que puedan ser consumidas desde aplicaciones iOS con Objective-C, Android con Java, macOS, Linux y Windows. Embeddinator-4000 toma código C# compartido y genera código y archivos para cada plataforma objetivo, permitiendo reutilizar lógica entre plataformas.
¿Tienes una aplicación iOS?, ¿quieres reaprovechar tus conocimientos y código Objective-C para acceder a la plataforma universal Windows?. En esta sesión conoceremos el Bridge de Windows para iOS, convertiremos algunas aplicaciones iOS a UWP e incluso veremos como añadir características específicas de la plataforma Windows como el uso de Live Tiles por ejemplo.
Este documento resume las principales características presentadas en Xamarin Revolve 2016, incluyendo: 1) El lanzamiento de Xamarin como código abierto bajo licencia MIT; 2) La introducción de Xamarin Workbooks para crear documentación dinámica; y 3) Las nuevas funcionalidades de Xamarin.Forms como el previsualizador, temas y páginas de datos.
Este documento describe cómo configurar la integración continua con TeamCity para aplicaciones móviles multiplataforma desarrolladas con Xamarin. Explica los beneficios de la integración continua, como encontrar errores más rápido, consistencia en los builds y poder desplegar en cualquier momento. Luego, detalla los pasos para configurar TeamCity para compilar, empaquetar, restaurar paquetes y ejecutar pruebas unitarias de las aplicaciones Xamarin de forma automática.
El mercado móvil es hoy día un pilar importante tanto para usuarios como para desarrolladores. Sin embargo, tenemos un mercado amplio y diverso con una gran variedad de dispositivos y sistemas. Si entramos en el terrero de desarrolladores el problema se acentúa con diferentes entornos de desarrollo, lenguajes y otros elementos. En esta sesión repasaremos el estado actual, introduciremos Xamarin como herramienta para crear aplicaciones nativas multiplataforma desde Visual Studio analizando todas sus bondades y costes además de ver distintas opciones Xamarin Classic y Xamarin.Forms.
Xamarin Dev Days Málaga 2017 - Apps conectadas con AzureJavier Suárez Ruiz
Este documento presenta las diferentes opciones de plataforma móvil de Azure, incluidas las API móviles de Azure, la autenticación con proveedores de identidad de terceros, las notificaciones push con Azure Notification Hubs y la sincronización de datos offline. Se proporcionan ejemplos de código para crear una API móvil de Azure y usarla para obtener y modificar datos, así como para configurar la sincronización de datos offline.
Introducción a todas las novedades presentadas en Xamarin 4. Tratamos Xamarin.Forms 2.0, Xamarin Test Recorder, Xamarin Test Cloud o Xamarin Insights entre otros puntos.
¿Sabes el ciclo de vida de un Layout?, ¿qué opciones de Layout son más óptimas?, ¿cómo afectan los bindings al rendimiento y como tratarlos?, ¿rendimiento en listados?, ¿fast renderers?. A todas esas preguntas y a otras tantas, intentaremos dar solución en esta sesión.
El ecosistema Xamarin no cesa en las herramientas de desarrollo. Tenemos a dispositivos una gran variedad de servicios destinados a complementar el mismo, analíticas, testing, análisis de rendimiento, etc. En esta sesión vamos a hacer un repaso por todos los servicios disponibles realizando demos de cada uno de ellos.
La plataforma Universal Windows facilita gran cantidad de tareas a los desarrolladores para cubrir múltiples escenarios entre diferentes familias de dispositivos. Para facilitar esto, nos llegan novedades en controles XAML además de algunos nuevos, pero además nos llegan gran cantidad de novedades en el sistema de enlace a datos, rendimiento, herramientas, nueva API de perspectiva 3D, además de algunas novedades de peso más. En esta sesión vamos a realizar un repaso sobre todas las novedades en XAML recibidas.
Aprende como crear una aplicación móvil multiplataforma para iOS, Android y Windows con Xamarin.Forms. En este taller organizado en diferentes bloques, vamos a crear una aplicación desde cero, conoceremos todos los conceptos básicos, aplicaremos MVVM y terminaremos conectando la misma con la nube.
El documento proporciona una introducción a Xamarin.Forms, incluyendo cómo permite compartir código entre plataformas móviles, sus controles y layouts principales, y cómo mapea conceptos de Xamarin.Forms a las plataformas nativas. También cubre temas como data binding, navegación, animaciones, custom renderers y el uso de XAML.
Este documento describe las capacidades de Xamarin para desarrollar aplicaciones multiplataforma para iOS, Android y Windows usando C#. Xamarin permite compartir gran parte del código entre plataformas, incluyendo la lógica de negocio y capas de presentación, mientras que también proporciona acceso nativo a las API de cada sistema operativo. El documento resalta las mejoras recientes en Xamarin como la integración con Visual Studio, Xamarin.Forms 2.0, y nuevas tecnologías en vista previa como el Inspector y el Profiler.
Este documento presenta una introducción al patrón MVVM y su implementación en Xamarin.Forms. Explica que MVVM separa la interfaz de usuario, la lógica de presentación y los datos para facilitar el desarrollo multiplataforma. Describe las partes clave de MVVM como la vista, el modelo de vista y el modelo, y cómo se vinculan mediante enlace de datos y comandos. También resume algunas características clave de Xamarin.Forms como el código compartido, los controles nativos y las herramientas como Dependency
Comando de asistente, generalmente para ayuda o
información adicional.
Back: Comando para retroceder en la aplicación.
Cancel: Comando para cancelar una acción.
Exit: Comando para salir de la aplicación.
Help: Comando para mostrar ayuda.
Ok: Comando para confirmar una acción.
Options: Comando para mostrar opciones adicionales.
Screen: Comando genérico para cambiar de pantalla.
Los tipos más comunes son: OK, Cancel, Back y Screen
La interfaz CommandListener define el método commandAction que se
invocará cuando se pulse sobre un
El documento presenta las nuevas características y mejoras de .NET Core, incluyendo el soporte para Windows Desktop, IoT y AI en .NET Core 3, así como nuevas tecnologías como Blazor, ML.NET y Azure DevOps. También destaca el crecimiento continuo de la plataforma .NET y C# con más de un millón de nuevos desarrolladores .NET activos en el último año.
Este documento presenta las novedades y mejoras recientes en Xamarin.Forms y las herramientas de Xamarin. Entre las novedades se incluyen mejoras en las herramientas como Hot Reload y Hot Restart para reducir los tiempos de iteración, la introducción de Shell para simplificar la navegación, y nuevos controles como CarouselView y CollectionView. También se discuten las mejoras planificadas como soporte para GIFs, gradientes y nuevos controles.
A la hora de desarrollar aplicaciones con Xamarin.Forms el rendimiento suele ser un factor a tener en cuenta. En Xamarin.Forms, ¿sabes el ciclo de vida de un Layout?, ¿qué opciones de Layout son más óptimas?, ¿cómo afectan los Bindings al rendimiento y como tratarlos?, ¿qué debemos hacer para optimizar el trabajo con imágenes?, ¿ListView o CollectionView?, ¿y qué ocurre con Shell? A estas y otras preguntas habituales de rendimiento daremos solución, con datos y pruebas en forma de sencillos consejos a tener en cuenta a la hora de desarrollar una aplicación con Xamarin.Forms.
Xamarin.Forms es un framework que nos añade una capa de abstracción permitiendo desarrollar la interfaz de nuestras aplicaciones móviles multiplataforma una única vez, compartiendo el código de la UI. Veremos como crear aplicaciones con Xamarin.Forms además de centrarnos en cómo acceder a características propias de cada plataforma mediante la creación de servicios o Custom Renders.
Este documento describe un taller sobre el desarrollo de aplicaciones móviles con Xamarin.Forms empleando Machine Learning. El taller mostrará cómo crear la estructura de un proyecto Xamarin, diseñar interfaces de usuario, acceder a código específico de plataforma, realizar peticiones HTTP y más. La aplicación que se construirá podrá tomar fotos y analizarlas con Custom Vision para identificar si contienen perros calientes. El taller resolverá dudas y proporcionará recursos adicionales.
Este documento introduce Embeddinator-4000, una herramienta que permite convertir librerías .NET en librerías que puedan ser consumidas desde aplicaciones iOS con Objective-C, Android con Java, macOS, Linux y Windows. Embeddinator-4000 toma código C# compartido y genera código y archivos para cada plataforma objetivo, permitiendo reutilizar lógica entre plataformas.
¿Tienes una aplicación iOS?, ¿quieres reaprovechar tus conocimientos y código Objective-C para acceder a la plataforma universal Windows?. En esta sesión conoceremos el Bridge de Windows para iOS, convertiremos algunas aplicaciones iOS a UWP e incluso veremos como añadir características específicas de la plataforma Windows como el uso de Live Tiles por ejemplo.
Este documento resume las principales características presentadas en Xamarin Revolve 2016, incluyendo: 1) El lanzamiento de Xamarin como código abierto bajo licencia MIT; 2) La introducción de Xamarin Workbooks para crear documentación dinámica; y 3) Las nuevas funcionalidades de Xamarin.Forms como el previsualizador, temas y páginas de datos.
Este documento describe cómo configurar la integración continua con TeamCity para aplicaciones móviles multiplataforma desarrolladas con Xamarin. Explica los beneficios de la integración continua, como encontrar errores más rápido, consistencia en los builds y poder desplegar en cualquier momento. Luego, detalla los pasos para configurar TeamCity para compilar, empaquetar, restaurar paquetes y ejecutar pruebas unitarias de las aplicaciones Xamarin de forma automática.
El mercado móvil es hoy día un pilar importante tanto para usuarios como para desarrolladores. Sin embargo, tenemos un mercado amplio y diverso con una gran variedad de dispositivos y sistemas. Si entramos en el terrero de desarrolladores el problema se acentúa con diferentes entornos de desarrollo, lenguajes y otros elementos. En esta sesión repasaremos el estado actual, introduciremos Xamarin como herramienta para crear aplicaciones nativas multiplataforma desde Visual Studio analizando todas sus bondades y costes además de ver distintas opciones Xamarin Classic y Xamarin.Forms.
Xamarin Dev Days Málaga 2017 - Apps conectadas con AzureJavier Suárez Ruiz
Este documento presenta las diferentes opciones de plataforma móvil de Azure, incluidas las API móviles de Azure, la autenticación con proveedores de identidad de terceros, las notificaciones push con Azure Notification Hubs y la sincronización de datos offline. Se proporcionan ejemplos de código para crear una API móvil de Azure y usarla para obtener y modificar datos, así como para configurar la sincronización de datos offline.
Introducción a todas las novedades presentadas en Xamarin 4. Tratamos Xamarin.Forms 2.0, Xamarin Test Recorder, Xamarin Test Cloud o Xamarin Insights entre otros puntos.
¿Sabes el ciclo de vida de un Layout?, ¿qué opciones de Layout son más óptimas?, ¿cómo afectan los bindings al rendimiento y como tratarlos?, ¿rendimiento en listados?, ¿fast renderers?. A todas esas preguntas y a otras tantas, intentaremos dar solución en esta sesión.
El ecosistema Xamarin no cesa en las herramientas de desarrollo. Tenemos a dispositivos una gran variedad de servicios destinados a complementar el mismo, analíticas, testing, análisis de rendimiento, etc. En esta sesión vamos a hacer un repaso por todos los servicios disponibles realizando demos de cada uno de ellos.
La plataforma Universal Windows facilita gran cantidad de tareas a los desarrolladores para cubrir múltiples escenarios entre diferentes familias de dispositivos. Para facilitar esto, nos llegan novedades en controles XAML además de algunos nuevos, pero además nos llegan gran cantidad de novedades en el sistema de enlace a datos, rendimiento, herramientas, nueva API de perspectiva 3D, además de algunas novedades de peso más. En esta sesión vamos a realizar un repaso sobre todas las novedades en XAML recibidas.
Aprende como crear una aplicación móvil multiplataforma para iOS, Android y Windows con Xamarin.Forms. En este taller organizado en diferentes bloques, vamos a crear una aplicación desde cero, conoceremos todos los conceptos básicos, aplicaremos MVVM y terminaremos conectando la misma con la nube.
El documento proporciona una introducción a Xamarin.Forms, incluyendo cómo permite compartir código entre plataformas móviles, sus controles y layouts principales, y cómo mapea conceptos de Xamarin.Forms a las plataformas nativas. También cubre temas como data binding, navegación, animaciones, custom renderers y el uso de XAML.
Este documento describe las capacidades de Xamarin para desarrollar aplicaciones multiplataforma para iOS, Android y Windows usando C#. Xamarin permite compartir gran parte del código entre plataformas, incluyendo la lógica de negocio y capas de presentación, mientras que también proporciona acceso nativo a las API de cada sistema operativo. El documento resalta las mejoras recientes en Xamarin como la integración con Visual Studio, Xamarin.Forms 2.0, y nuevas tecnologías en vista previa como el Inspector y el Profiler.
Este documento presenta una introducción al patrón MVVM y su implementación en Xamarin.Forms. Explica que MVVM separa la interfaz de usuario, la lógica de presentación y los datos para facilitar el desarrollo multiplataforma. Describe las partes clave de MVVM como la vista, el modelo de vista y el modelo, y cómo se vinculan mediante enlace de datos y comandos. También resume algunas características clave de Xamarin.Forms como el código compartido, los controles nativos y las herramientas como Dependency
Comando de asistente, generalmente para ayuda o
información adicional.
Back: Comando para retroceder en la aplicación.
Cancel: Comando para cancelar una acción.
Exit: Comando para salir de la aplicación.
Help: Comando para mostrar ayuda.
Ok: Comando para confirmar una acción.
Options: Comando para mostrar opciones adicionales.
Screen: Comando genérico para cambiar de pantalla.
Los tipos más comunes son: OK, Cancel, Back y Screen
La interfaz CommandListener define el método commandAction que se
invocará cuando se pulse sobre un
Java ME es una plataforma para desarrollar aplicaciones móviles que provee APIs para interfaces gráficas, multimedia y más. Las aplicaciones se llaman MIDlets y siguen un ciclo de vida de inicio, pausa y destrucción. Los MIDlets usan elementos GUI como Forms, TextFields e Images para crear interfaces de usuario.
La web como Plataforma con Dojo ToolkitAlex Fuentes
Presenta una visión actual del fenómeno web y las tendencias de los principales borwser del mercado y la industria. Detalla los desafíos del desarrollo de aplicaciones RIA y como Dojo Toolkit permite la creación de aplicaciones RIA de manera fácil y ágil.. Además muestra como Comet, permite el desarrollo de soluciones Real Time sobre la Web.
Este documento presenta una agenda para un curso de programación en C#. La agenda incluye una introducción al .NET Framework, al lenguaje C# y a Visual Studio.NET. También cubre temas como aplicaciones de ventanas, ASP.NET, acceso a datos y más.
Estrategias para desarrollo crossplatform en Windows Phone 8 y Windows 8Sorey García
Este documento describe las similitudes y diferencias entre el desarrollo de aplicaciones para Windows Phone 8 y Windows 8. Ambas plataformas comparten el mismo marco de trabajo XAML y .NET, pero cada una tiene sus propias API. El documento explica cómo compartir código entre plataformas mediante bibliotecas compartidas, archivos enlazados y componentes Windows Runtime. También cubre temas como el patrón MVVM y la gestión de las diferencias entre plataformas.
Desymfony 2011 - Tutorial #1: Instalacion y primeros pasosJavier Eguiluz
Instalación y primeros pasos fue la primera ponencia impartida durante las Jornadas Symfony 2011. Se trata de la primera parte de las seis que forman el tutorial de desarrollo de la aplicación github.com/desymfony.
Durante la misma se explIca cómo instalar y configurar Symfony2, cómo instalar el proyecto deSymfony, cómo crear los bundles con el generador interactivo y también se introduce el funcionamiento de la arquitectura MVC en Symfony2 mediante la programación de la parte dedicada a mostrar las páginas estáticas de la aplicación.
El documento describe las características de los MIDlets en J2ME, que son aplicaciones móviles. Explica que un MIDlet debe implementar los métodos startApp(), pauseApp() y destroyApp(). También cubre las interfaces gráficas de usuario en MIDP como pantallas, TextBox, List, Alert y Form. Los Form permiten crear interfaces más ricas con varios componentes como TextField, DateField y ChoiceGroup. Los comandos se utilizan para procesar las acciones del usuario.
Diapositivas de mi curso introductorio de Android en 5 horas.
EN EL CONGRESO UNIVERSITARIO MOVIL 2012 SE USÓ ESTA PRESENTACIÓN PARA HABLAR DE ANDROID Y SE HIZO UNA APP PARLANCHINA COMO EJEMPLO DEL CONTENIDO, AQUI ESTÁ EL CODIGO FUENTE https://www.dropbox.com/s/1dbso3rb47be1hj/Hablar.zip?%20m
EyeOS es un sistema operativo web que permite acceder a aplicaciones desde cualquier navegador. Usa una arquitectura de micronúcleo con cuatro capas y servicios clave como MMAP, VFS y eyeX. Los desarrolladores pueden crear aplicaciones mediante widgets y la recepción de eventos en archivos .eyecode. Aunque ofrece portabilidad y disponibilidad, EyeOS depende de una conexión a internet y tiene limitaciones de rendimiento y seguridad al no controlar directamente el hardware.
GWT es un framework de desarrollo de Google que permite crear aplicaciones web complejas usando Java. Los proyectos GWT tienen una estructura de paquetes separando el código del cliente y servidor, e incluyen módulos, clases EntryPoint y llamadas RPC para comunicación con el servidor. GWT compila el código Java a JavaScript para ejecutarse en el navegador, permitiendo desarrollar interfaces gráficas ricas sin refrescos de página.
Este documento discute temas avanzados de GWT como pruebas de cliente, depuración, JSNI, enlace diferido, AJAX y RPC. Explica cómo ejecutar pruebas de cliente en diferentes modos como JUnit, Selenium y RemoteWeb. También cubre cómo depurar aplicaciones GWT de forma similar a otras aplicaciones Java y la recomendación de hacer TDD en lugar de depurar. Luego describe características clave de GWT como JSNI para usar JavaScript dentro de Java, enlace diferido para seleccionar implementaciones basadas en el navegador y AJ
Flutter es el SDK de aplicaciones móviles de Google para crear
interfaces nativas de alta calidad en iOS y Android en un tiempo
récord.
Sirve para crear fácilmente app móviles modernas, bonitas y de
alto desempeño Funciona para Android y iOS Es una herramienta open-source, desarrollada por Google
Actualmente se encuentra en Beta 3 Listo para producción.
El documento describe los componentes básicos para crear interfaces de usuario en aplicaciones MIDLET para dispositivos móviles, incluyendo Alerts, TextBoxes, Lists y Forms. Estos componentes heredan de la clase Screen y permiten mostrar información y recibir entrada del usuario de forma sencilla. El documento también explica cómo utilizar el objeto Display para cambiar entre diferentes pantallas y componentes de interfaz.
Xamarin permite llevar el desarrollo de .NET hacia el desarrollo móvil, facilitando a cada desarrollador el crear aplicaciones verdaderamente nativas para cualquier dispositivo con C# y F#. Utilizando herramientas de primer nivel que Microsoft a proporcionado para construir soluciones móviles de una manera rápida, fácil y flexible.
inLab FIB MeteorJS workshop by uLab UPC - Telefonica I+DinLabFIB
Este documento proporciona información sobre Meteor JS, una plataforma open source para crear aplicaciones web. Explica que Meteor utiliza DDP para transferir datos entre el cliente y el servidor, con Node.js y MongoDB en el servidor. También describe algunas ventajas como la reactividad y la compensación de latencia, así como desventajas como posibles problemas de seguridad. Finalmente, ofrece instrucciones sobre instalación, estructura de proyectos, paquetes y despliegue de aplicaciones Meteor.
Este documento presenta una introducción al desarrollo de aplicaciones móviles con Android. Explica que Android es un sistema operativo móvil de código abierto desarrollado por la Open Handset Alliance, y que incluye herramientas de desarrollo como el SDK de Android. También describe conceptos clave como actividades, servicios, el ciclo de vida de las actividades y los recursos de las aplicaciones Android.
Este documento habla sobre los custom renderers en Xamarin.Forms. Explica qué son los custom renderers y cuándo son necesarios (por ejemplo, para usar controles nativos o personalizar la apariencia de controles existentes). Luego, detalla los pasos para crear un custom renderer: 1) crear un control en Xamarin.Forms, 2) crear un renderer para cada plataforma, 3) agregar un atributo de exportación, y 4) consumir el control. Finalmente, incluye demos sobre cómo crear renderers y agregar propiedades personalizadas.
Xamarin.Forms permite crear interfaces de usuario nativas multiplataforma utilizando un código común. Sin embargo, en ocasiones necesitamos crear elementos específicos por plataforma o acceder a APIs nativas. En esta sesión veremos cómo extender Xamarin.Forms con Custom Renders, como acceder a APIs nativas utilizando el servicio de dependencia junto a otra serie de pequeños consejos.
Similar a Monkey Conf 2020: .NET MAUI Handlers (20)
Cape Town MS Developer User Group: Xamarin Community ToolkitJavier Suárez Ruiz
In this session we are going to talk about the Xamarin Community Toolkit, a collection of Animations, Behaviors, Converters Effects and Controls for mobile development with Xamarin.Forms.
We will see what it gives us, how to use it and also how you can contribute!
Monkey Conf 2020: Xamarin Community Toolkit: More possibilities with Xamarin....Javier Suárez Ruiz
In this session we are going to know the Xamarin Community Toolkit (XCT) along with all the options it offers like controls, converters, behaviors, etc.
Crear interfaces de usuario atractivas con Xamarin.FormsJavier Suárez Ruiz
This document discusses creating attractive interfaces with Xamarin.Forms. It covers current mobile app design trends, using resources and styles to customize themes, animations and transitions, using Lottie for simple animations, gradients as a current design trend, using the SkiaSharp graphics engine, new Xamarin.Forms controls, and third party libraries with common design templates. The document includes code examples and links to resources and the speaker's GitHub projects. It concludes with asking if there are any questions.
This document contains a summary of presentations for a Xamarin UI event in July. It lists over 30 presenters who will be sharing topics like creating banking apps, Uber clones, custom controls, animations, data entry, maps, and more using Xamarin Forms. The event will take place from July 1-31.
Este documento presenta las nuevas características de Xamarin.Forms 3.0, incluyendo FlexLayout, VisualStateManager, estilos con CSS, soporte para RTL y nuevas plataformas como Linux y WPF. FlexLayout permite diseños flexibles mediante propiedades como dirección, envuelto y alineación. VisualStateManager facilita la gestión de estados visuales. Los estilos CSS permiten aplicar estilos a elementos mediante selectores y propiedades. También se mejora el soporte para idiomas de derecha a izquierda y se añaden Linux y WPF como
El documento habla sobre el desarrollo de aplicaciones móviles con Xamarin. Explica que Xamarin permite crear aplicaciones nativas multiplataforma para iOS, Android y Windows. También menciona algunas herramientas de Xamarin como Xamarin Profiler e Inspector que ayudan a depurar y probar aplicaciones, y App Center que facilita el despliegue y gestión de las apps.
El documento presenta una introducción a Xamarin.Forms, un framework que permite desarrollar aplicaciones móviles multiplataforma compartiendo código C# entre iOS, Android y Windows. Xamarin.Forms incluye más de 40 controles y layouts preconstruidos, data binding bidireccional, navegación y animaciones. Permite escribir la interfaz de usuario una sola vez y ejecutarla en múltiples plataformas de forma nativa.
El documento introduce Xamarin, una plataforma que permite a los desarrolladores crear aplicaciones móviles nativas compartiendo código entre iOS, Android y Windows. Xamarin usa C# y Visual Studio para escribir una vez el código compartido y ejecutarlo en múltiples plataformas, dando acceso a las APIs nativas de cada sistema. El documento también describe las ventajas de Xamarin como la experiencia de desarrollo integrada en Visual Studio y la capacidad de compartir grandes porciones de código entre plataformas.
Plain Concepts Tech Day: Desarrollo de aplicaciones multiplataforma con XamarinJavier Suárez Ruiz
El documento describe un evento técnico organizado por Plain Concepts el 20 de diciembre de 2017. La agenda incluye charlas sobre CSS Grid Layout, desarrollo multiplataforma con Xamarin, Docker, Azure Relay y .NET Core, Swagger Code Generation y entrega continua con Visual Studio Team Services. Javier Suárez dará una presentación sobre desarrollo de aplicaciones multiplataforma con Xamarin.
El documento resume las novedades presentadas en Xamarin Connect(); 2017, incluyendo Visual Studio Live Share para desarrollo colaborativo en tiempo real, mejoras en Xamarin.Forms para aprovechar características nativas en iOS y Android, y la introducción de Xamarin Live Player y Visual Studio App Center para agilizar el desarrollo móvil multiplataforma.
El documento describe un taller sobre el desarrollo de aplicaciones multiplataforma con Xamarin. En el taller, los participantes crearán una aplicación de películas para Android, iOS, UWP y otras plataformas usando C# y compartiendo código entre plataformas. El taller cubrirá conceptos como la estructura de proyectos, diseño de interfaces, navegación y el acceso a APIs nativas de cada plataforma.
El documento presenta información sobre las HoloLens de Microsoft, incluyendo sus características principales como cámaras, procesador, memoria, almacenamiento, duración de batería y más. También describe cómo desarrollar aplicaciones para HoloLens usando el SDK de Microsoft con Visual Studio y Unity, así como las diferentes formas de interactuar con hologramas como mirada, gestos, voz y sonido espacial.
El documento describe Embeddinator-4000, una herramienta que convierte código .NET en bibliotecas nativas para que pueda reutilizarse en proyectos de Android, iOS, macOS y otros frameworks. Embeddinator-4000 exporta código .NET a varias plataformas como frameworks de iOS y Jars de Android, permitiendo que el código se consuma desde otros lenguajes como Objective-C, Swift y Java. La herramienta ayuda a reutilizar grandes bases de código existentes sin tener que empezar proyectos nativos desde cero.
Xamarin Hol - Módulo V: Mobile DevOps con Visual Studio Team Services y Hocke...Javier Suárez Ruiz
Este documento presenta una sesión sobre integración continua y entrega continua para aplicaciones móviles. Explica qué es la integración continua y sus beneficios como encontrar errores más rápido y minimizar problemas al fusionar código. Luego muestra demostraciones de cómo usar Visual Studio Team Services y HockeyApp/Mobile Center para habilitar la integración continua, pruebas automáticas, distribución de versiones beta y monitoreo continuo de aplicaciones móviles. El objetivo final es automatizar el proceso de desarrollo para entregar actual
Infografia TCP/IP (Transmission Control Protocol/Internet Protocol)codesiret
Los protocolos son conjuntos de
normas para formatos de mensaje y
procedimientos que permiten a las
máquinas y los programas de aplicación
intercambiar información.
Uso de las Tics en la vida cotidiana.pptx231485414
Las Tecnologías de la Información y las Comunicaciones (TIC), son el conjunto de recursos, herramientas, equipos, programas informáticos, aplicaciones, redes y medios.
LA GLOBALIZACIÓN RELACIONADA CON EL USO DE HERRAMIENTAS.pptxpauca1501alvar
Explica cómo las tecnologías digitales han facilitado e impulsado la globalización al eliminar barreras geográficas y permitir un flujo global sin precedentes de información, bienes, servicios y capital. Se describen los impactos de las herramientas digitales en áreas como la comunicación global, el comercio electrónico internacional, las finanzas y la difusión cultural. Además, se mencionan los beneficios como el crecimiento económico y el acceso a la información, así como los desafíos como la desigualdad y el impacto ambiental. Se concluye que la globalización y las herramientas digitales se refuerzan mutuamente, promoviendo una creciente interdependencia mundial.
Catalogo general tarifas 2024 Vaillant. Amado Salvador Distribuidor Oficial e...AMADO SALVADOR
Descarga el Catálogo General de Tarifas 2024 de Vaillant, líder en tecnología para calefacción, ventilación y energía solar térmica y fotovoltaica. En Amado Salvador, como distribuidor oficial de Vaillant, te ofrecemos una amplia gama de productos de alta calidad y diseño innovador para tus proyectos de climatización y energía.
Descubre nuestra selección de productos Vaillant, incluyendo bombas de calor altamente eficientes, fancoils de última generación, sistemas de ventilación de alto rendimiento y soluciones de energía solar fotovoltaica y térmica para un rendimiento óptimo y sostenible. El catálogo de Vaillant 2024 presenta una variedad de opciones en calderas de condensación que garantizan eficiencia energética y durabilidad.
Con Vaillant, obtienes más que productos de climatización: control avanzado y conectividad para una gestión inteligente del sistema, acumuladores de agua caliente de gran capacidad y sistemas de aire acondicionado para un confort total. Confía en la fiabilidad de Amado Salvador como distribuidor oficial de Vaillant, y en la resistencia de los productos Vaillant, respaldados por años de experiencia e innovación en el sector.
En Amado Salvador, distribuidor oficial de Vaillant en Valencia, no solo proporcionamos productos de calidad, sino también servicios especializados para profesionales, asegurando que tus proyectos cuenten con el mejor soporte técnico y asesoramiento. Descarga nuestro catálogo y descubre por qué Vaillant es la elección preferida para proyectos de climatización y energía en Amado Salvador.
5. – .De .NET 5 a .NET 6
.NET Framework
Mono / Xamarin
.NET Core.NET
Un SDK, un BCL, herramientas unificadas
Mobile & Desktop Cross-platform UI nativa
UI web Cross-platform
Investigaciones en la nube
Continuar mejorando la velocidad, tamaño, diagnóstico en
servicios Azure
La vision de un .NET
6. UI nativa multiplataforma
Proyecto único, base de código única
Implementar en múltiples dispositivos, móviles y de
escritorio
Evolución de Xamarin.Forms
Dirigido a .NET 6, disponible a finales del próximo año
Crear interfaces de usuario atractivas para cualquier dispositivo
La evolución de Xamarin.Forms
.NET MAUI
.NET Platform
7. .NET MAUI
Proyectos SDK-style
Proyecto único
Soporte CLI
.NET 6 BCL
Multi-paradigma
• Interfaz de usuario compatible con XAML y C#
• Listo para Blazor y C# MVU
DESKTOP MOBILE
Windows
macOS
iOS
Android
.NET MAUI
File | New
• Multi-platform App UI (.NET)
CLI
• dotnet install maui
• dotnet new maui
Namespaces
• System.Maui (previously Xamarin.Forms)
• System.Device (previously Xamarin.
9. La arquitectura de .NET MAUI
Las API de Android, iOS, macOS y Windows están unificadas en una API abstracta que permite una experiencia
de desarrollo que permita escribir una vez y ejecutar en cualquier plataforma, al tiempo que proporciona un
acceso total a todos los aspectos de cada plataforma nativa.
App Code interactúa principalmente con .NET
MAUI API (1).
Según sea necesario, App Code puede acceder
directamente las API de la plataforma (2) a través
Handlers, etc.
.NET MAUI accede directamente las API de la
plataforma nativa (3).
Android iOS macOS Windows
Xamarin.Android Xamarin.iOS Xamarin.Mac WinUI
.NET MAUI
App Code
Mono Runtime WinRT
.NET 6 BCL
1
2
3
14. ¿Cuáles son los problemas de arquitectura de Xamarin.Forms?
Xamarin.Forms.Button
- Los Renderers estan muy acoplados a componentes Xamarin.Forms
[assembly: ExportRenderer (typeof(MyEntry), typeof(MyEntryRenderer))]
namespace CustomRenderer.iOS {
public class MyEntryRenderer : EntryRenderer
- Assembly Scanning es realmente lento
- Realmente dificil de acceder a la plataforma nativa desde código xplat
using Xamarin.Forms.PlatformConfiguration;
using Xamarin.Forms.PlatformConfiguration.iOSSpecific;
boxView.On<iOS>().UseBlurEffect(BlurEffectStyle.ExtraLight);
15. Xamarin.Forms: Añadir un comportamiento personalizado, podría ser más sencillo
// You need to know to export this renderer and tie it to a core type…
[assembly: ExportRenderer (typeof(MyEntry), typeof(MyEntryRenderer))]
namespace CustomRenderer.iOS
{
// You need to know what type to inherit from…
public class MyEntryRenderer : EntryRenderer
{
// You need to know what method to override…
protected override void OnElementChanged (ElementChangedEventArgs<Entry> e)
{
// You need to know when to do your work (before? after?)
base.OnElementChanged (e);
// You need to know that we call the native view “Control”
// Spoiler alert: this varies from platform to platform and
// sometimes it even varies from renderer to renderer!
if (Control != null) {
// Finally! We can change the color!
public class MyEntry : Entry
{
}
16. Los objetivos con .NET MAUI
- Desacoplar los Renderers de Xamarin.Forms
IButton
17. Los objetivos con .NET MAUI
- Mejorar el rendimiento es uno de los objetivos principales
- Desde el proyecto xplat, registre fácilmente cualquier handler personalizado
RegistrarHandlers.Handlers.Register<Xamarin.Forms.Label, LabelHandler>();
#if MONOANDROID
RegistrarHandlers.Handlers.Register<Xamarin.Forms.Label,
Xamarin.Forms.Platform.Android.LabelRenderer>();
RegistrarHandlers.Handlers.Register<Xamarin.Forms.Button,
Xamarin.Forms.Platform.Android.AppCompat.ButtonRenderer>();
#endif
- No hacer assembly scanning
18. Los objetivos con .NET MAUI
- Permitir acceder a código nativo con facilidad
using Xamarin.Forms.PlatformConfiguration;
using Xamarin.Forms.PlatformConfiguration.iOSSpecific;
boxView.On<iOS>().UseBlurEffect(BlurEffectStyle.ExtraLight);
[assembly: ExportRenderer (typeof(MyEntry), typeof(MyEntryRenderer))]
namespace CustomRenderer.iOS {
public class MyEntryRenderer : EntryRenderer
- Eliminar APIs confusas
#if MONOANDROID
ViewHandler.ViewMapper[nameof(IView.BackgroundColor)] = (handler, view) =>
(handler.NativeView as
AView).SetBackgroundColor(Xamarin.Forms.Color.Purple.ToNative());
var textView = crossPlatformLabel.Handler.NativeView as TextView;
#endif
19. Los Renderers actuales
Fundamentalmente es un control nativo
Implementa IVisualElementRenderer
public interface IVisualElementRenderer
{
VisualElement Element { get; }
VisualElementTracker Tracker { get; }
AView View { get; }
event EventHandler<VisualElementChangedEventArgs> ElementChanged;
event EventHandler<PropertyChangedEventArgs> ElementPropertyChanged;
SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint);
void SetElement(VisualElement element);
void SetLabelFor(int? id);
void UpdateLayout();
}
22. La estrategia actual con Xamarin.Forms Renderers
protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs
e)
{
if (e.PropertyName == Button.TextColorProperty.PropertyName)
UpdateTextColor();
else if (e.PropertyName == VisualElement.IsEnabledProperty.PropertyName)
UpdateEnabled();
else if (e.PropertyName == Button.FontProperty.PropertyName)
UpdateFont();
else if (e.PropertyName == Button.CharacterSpacingProperty.PropertyName)
UpdateCharacterSpacing();
base.OnElementPropertyChanged(sender, e);
}
private void UpdateFont()
private void UpdateTextColor()
23. La estrategia con Handlers en .NET MAUI
public partial class LabelHandler : AbstractViewHandler<ILabel, TextView>
{
protected override TextView CreateView() => new TextView(Context);
public static void MapText(IViewHandler handler, ILabel view) =>
(handler as LabelHandler).TypedNativeView.UpdateText(view);
}
public static class TextViewExtensions
{
public static void UpdateText(this TextView textView, IText text)
{
textView.Text = text.Text;
}
public partial class LabelHandler
{
public static PropertyMapper<ILabel> LabelMapper =
new PropertyMapper<ILabel>(ViewHandler.ViewMapper)
{
[nameof(ILabel.Text)] = MapPropertyText,
24. Los Handlers son “solo” una reorganización
public static class TextViewExtensions
{
public static void UpdateText(this TextView textView, IText text)
{
textView.Text = text.Text;
}
public class LabelRenderer : ViewRenderer<Label, TextView>
{
void UpdateText()
{
textView.Text = text.Text;
}
25. Xamarin.Forms: Personalizar el comportamiento de un control
// You need to know to export this renderer and tie it to a core type…
[assembly: ExportRenderer (typeof(MyEntry), typeof(MyEntryRenderer))]
namespace CustomRenderer.iOS
{
// You need to know what type to inherit from…
public class MyEntryRenderer : EntryRenderer
{
// You need to know what method to override…
protected override void OnElementChanged (ElementChangedEventArgs<Entry> e)
{
// You need to know when to do your work (before? after?)
base.OnElementChanged (e);
// You need to know that we call the native view “Control”
// Spoiler alert: this varies from platform to platform and
// sometimes it even varies from renderer to renderer!
if (Control != null) {
// Finally! We can change the color!
public class MyEntry : Entry
{
}
26. Maui: Personalizar el comportamiento de un control
// You don’t need to register a new renderer.
public partial class EntryRenderer
{
// You know what method to call because you named it!
public static void MapBackgroundColor (IViewRenderer renderer, IView view)
{
// You don’t need to call any base methods here or worry about order.
// Every renderer is consistent; you know where the native view is.
var nativeView = (NativeView)renderer.NativeView;
var color = view.BackgroundColor;
if (color != null) {
// Phew! That was easy!
nativeView.BackgroundColor = UIColor.FromRGB (204, 153, 255);
}
}
}
public partial class EntryRenderer {
public static PropertyMapper<IView> ViewMapper = new
PropertyMapper<IView> {
// Add your own method to map to any property
[nameof(IView.BackgroundColor)] = MapBackgroundColor
};
}
27. Maui: Personalizar el comportamiento de un control
#if MONOANDROID
ButtonRenderer.ButtonMapper[nameof(IButton.TextColor)] = (handler, view) =>
{
var nativeView = handler.NativeView as Aview;
// Add your own logic to map the TextColor property
};
#endif
31. Renderer to Handler &
Handler to Renderer
Shims
https://github.com/xamarin/Xamarin.Forms/pull/12546
32. .NET MAUI e inyección de dependencias
.NET MAUI usará el concepto de Host similar a ASP.NET. Esto permitirá usar Containers y providers
para nuestros handlers al igual que permitir configuraciones con archivos appsettings, y otras
posibilidades como gestionar el ciclo de vida de cada plataforma, registrar servicios, logging
extensions etc.
El AppBuilder estará oculto por defecto, pero se podrá sobreescribir y usarlo para extender y registrar
servicios, configurar logging o registrar nuevos handlers.
En .NET MAUI, vamos a usar Microsoft Dependency Injection para permitir registrar custom handlers.
var (host,app) = App.CreateDefaultBuilder()
.RegisterHandler<IButton, CustomHandlers.CustomPinkTextButtonHandler>()
.ConfigureServices(ConfigureExtraServices)
.Init<MyApp>();
var page = app.GetStartup()
https://github.com/xamarin/Xamarin.Forms/pull/12460
33. ¿Y que ocurre con los renderers de Xamarin.Forms?
En Xamarin.Forms se usaba el atributo ExportRenderer para registrar un Renderer. Internamente en Xamarin.Forms, se usa el escaneo de
ensamblados para buscar y registrar los Renderers.
En .NET MAUI, el escaneo de ensamblado no se usará por defecto, y permitiremos registrar un Renderer de esta manera:
Sin embargo, permitiremos en los casos deseados registrar Renderers usando el escaneo de ensamblaje:
var (host,app) = App.CreateDefaultBuilder()
.RegisterRenderer<CustomBoxView, CustomBoxViewRenderer>()
.ConfigureServices(ConfigureExtraServices)
.Init<MyApp>();
var page = app.GetStartup()
var (host,app) = App.CreateDefaultBuilder()
.ConfigureRenderers( options => options.ScanForRendererAttribute = true)
.ConfigureServices(ConfigureExtraServices)
.Init<MyApp>();
var page = app.GetStartup()
34. Usando los Renderers “antiguos” en .NET MAUI
Puedes elegir la que más te convenga en cada caso, pero ten en cuenta
que:
Usando Handlers:
• Requiere "algo de tiempo" para la conversión de código.
• Cada Handler es equivalente a un Fast Renderer además de ser
gestionado de forma diferente por Layouts que tienen un mejor
rendimiento.
• Permita más opciones de extensibilidad.
Usando Renderers:
• No requiere cambios.
• No aprovecha ninguna de las mejoras de los Handlers (rendimiento,
extensibilidad, etc.)
36. La arquitectura de .NET MAUI
.NET MAUI utiliza Layouts multiplataforma, interfaces para definir controles, métodos de extension con las
vistas nativas e implementaciones usando vistas nativas. Se utilizan los mismos controles nativos
independientemente de MVVM, MVU, RxUI, Blazor, etc.
Interfaces
System.Maui.Views son interfaces que describen
cada control.
IButton > IText > IView
Handlers
Estos son las abstracciones e implementaciones de
cada control sin conocimiento de MVU o MVVM.
System.Maui.Handlers:
• ButtonHandler.Android.cs
• ButtonHandler.Mac.cs
• ButtonHandler.Standard.cs
• ButtonHandler.Win32.cs
• ButtonHandler.cs
• ButtonHandler.iOS.cs
Patrones
Estas implementaciones de controles añaden soporte a los
patrones de diseño soportados.
System.Maui.Bindables contiene las capacidades relacionadas con
MVVM, y controles con soporte a databinding.
37. El trabajo con .NET MAUI Handlers
• Nueva arquitectura de Renderers
• Nueva metodología
• Nueva organización
• Nueva arquitectura de Layouts
• Eliminar obsoletos
• Eliminar “slow” renderers
• Eliminar pre-AppCompat
• Unificar APIs entre Xamarin.Forms y
Xamarin.Essentials
• Usar
Microsoft.Extensions.DependencyInjection
• Cross-Platform Lifecycle
• Corregir “AndExpand”
• Corregir “MinHeightRequest” & similares
• Usar GlideX
Migration Tool con try-convert
Xamarin Native -> .NET 6
Xamarin.Forms -> .NET MAUI
38. • .NET 5.0 se ha lanzado en Noviembre 2020
• Xamarin.Forms 5.0 en Diciembre 2020
• .NET 6.0 MAUI + soporte a móvil previews con .NET 6 Preview 1
El roadmap de .NET
Dic 2019
.NET Core 3.1
LTS
Nov 2020
.NET 5.0
Nov 2021
.NET 6.0
LTS
Nov 2022
.NET 7.0
Nov 2023
.NET 8.0
LTS
Animated slide
Our vision for one .NET is to simplify the platform and choices for .NET developers and provide a single stack that supports the best of breed solutions for all modern workloads.
Last year at Build, we laid out our vision for one .NET starting with .NET 5. We said we would take .NET Core and Mono/Xamarin implementations and unify them into one base class library (BCL) and toolchain (SDK). In the wake of the global health pandemic, we have had to adapt to the changing needs of our customers and provide the support needed to assist with smooth operations. Our efforts continue to be anchored in helping our customers address their most urgent needs. As a result, we expect these features to be available in preview for the .NET 5 release but the unification will be truly completed with .NET 6, our Long-Term Support (LTS) release. Our vision has not changed, but our timeline has.
.NET 5 will have several cloud & web investments, such as smaller, faster, single file EXEs that use less memory which are appropriate for microservices and containerized applications across operating systems. We will continue to build on the work we have done.
We are still committed to one .NET platform and delivering a quality .NET 5 release to our millions of users in November this year. You will continue to see a wave of innovation happening with multiple previews along the way on the journey to one .NET.
I’m also excited to announce .NET Multi-platform App UI, or just .NET MAUI.
<CLICK>
It is a cross-platform, native UI stack so you’ll get great performance on any device.
<CLICK>
It will allow you to build these apps for any device from a single codebase and project system
<CLICK>
And that includes desktop and mobile across operating systems, like Windows, MacOS, iOS and Android.
<CLICK>
This is the evolution of Xamarin technology, building on Xamarin.Forms and expanding that to cross-platform desktop scenarios.
<CLICK>
It will be part of the unified .NET in the .NET 6 timeframe with previews available end of this year. You’ll see us working on it in the open on GitHub.
In Xamarin.Forms, the Renderers are tightly couple to Xamarin.Forms components.
In the ButtonRenderer, have several references to a Xamarin.Forms Button which is a bindable object implementing INotifyPropertyChanged, etc.
The other topic is, the Xamarin.Forms Registrar where register the available renderers, etc. In this case, use assembly scanning and it is really slow.
What happens is basically, Xamarin.Forms goes through and scans all your assemblies for assembly attributes and then automatically registers to the framework, and
Allow to use that components.
This is great because is easy to use, and try to remove some requirements from the user, but impact in the performance.
The third topic is, in some cases is really complex to reach the native platform from cross platform code.
Mainly, because the way that dependency tree works. The button renderer depends on button component so, the button has no concept of a renderer.
When you are in the Button context, have no context or reference to the renderer.
If you want to Access the native layer, you have different options. You can register your own custom renderer and interact with it or, use an API, that is great but very difficult to discover. I am talking about Platform Specifics. At the end, is not doing anything really special, just setting a cross platform pproperty to a native UI control property.
Relying on event handlers to orchestrate behavior and property changes
Lots of boilerplate code
Tons of knowledge required about order of events, both on the platform side and on the Xamarin.Forms side (i.e,, Does this need to happen on ElementChanged? What about ElementPropertyChanged? Etc.)
The main goal with .NET MAUI is to decouple the renderers. The basic idea is invert the dependency tree.
Now, the Xamarin.Forms Button depends on Ibutton and that interface is what is used by the Button and the ButtonHandler only knows about an IButton.
The Handler doesnt know nothing about the Button component.
This allow you to map different type of controls, because use the interface and have not any concept about what is .NET MAUI.
There are several ideas driving this, but one of the most important ones is performance minded and simplified.
Achieve a much better performance and allow to understand how everything Works in a easy way. Mostly, if you are a new developer. In Xamarin.Forms is a Little bit hard to understanding how to get the renderer, the lifecycle, etc.
Also, is complex as we mentioned to Access to any native element from the cross platform layer.
So, what we are doing is sort of moving everything into the cross-platform side to allow you Access things within the context of your shared application.
So you can see in the slides some samples, and as you can see, the idea is to allow register any handler you want. For sure, there are handlers registered by defaut, but, you can swap those in and out. The idea behind this is, we are not going to use assembly scanning by default. In next slides we will see that we will allow the use of scanning assembly for a very specific case.
This is for teo reason; first one, to gain performance and second one; to simplify the registration process.
Of course, the code sample from the slides, also Works with multitargeting so you can include it in cross platform code.
Ok, let’s continue talking about the goals of .NET MAUI.
Removing confusing APIs and this particular example refers again to Platform Specific.
So, the main idea is, you will have Access to native bits from a cross-platform standpoint. If I have a .NET MAUI Label, I can just Access the native View from cross platform context. You can use compilation directives or créate a platform specific file, then Access the native control and customize, modify whatever you want.
So, again, that is possible because we inverted the inversion as we said earlier, now .NET MAUI taking dependency on the renderes opposed the renderers taking dependency on Xamarin.Forms.
Let’s see the current Xamarin.Forms Renderers implementation. Is an IVisualElementRenderer.
This is what drives all the renderers at the native level. This is how the Layout system interact with the native controls, etc.
Can get basic information about what size should use, when should update a property, etc.
Ok, let’s see the changes between Xamarin.Forms and .NET MAUI.
IVisualElementRenderer is the Xamarin.Forms stuff, and the new one is IViewHandler.
If you do a quick comparison, are very close, or very much the same. Is a new interface that allow to represent controls using the new implementation, but no crazy changes, are close.
For example: SetView is SetElement, UpdateValue is mostly the same as ElementPropertyChanged, etc.
Again, for different points, but mostly again for the performance topic, we are removing eventing.
SetFrame is a Little bit more powerful in respect Xamarin.Forms, because we are applying some important changes in Layouts and want to be more aggresive projecting the sizing information to avoid some unnecesary measurements, etc.
IView is the interface that any cross platform UI element will implement.
For example: IButton.
IViewHandler is the interface that any Handler will implement.
Now, I am going to compare the ways renderers strategy Works in Xamarin.Forms and .NET MAUI.
In Xamarin.Forms, there are some huge if statements, some consistency problems, all of the methods to update any property are privates.
The .NET MAUI strategy is more function based. The idea here is that, all the update methods we have seen before, will be moved to extensión methods.
Why?. Will be public methods that you will be able to apply in your own handlers.
Also, is very powerful for cross-platform, because since the way everything Works is créate a standard API across all platforms, for example, the LabelExtensions, you can use it from a cross platform class, and you can say, handler, UpdateText and in every platform will use the same method with the correct implementation for the platform. So, image this, and we will see this in samples more later, but can have just one class to implement the Handler while in Xamarin.Forms we used several projects, several clases, etc.
Finally, the mapper is just a dictionary of functions, so before when you saw the Xamarin.Forms property changed stuff, what was doing is just mapping string with methods. And is what the mapper is doing but standarizing that to use a structure and something much more pluggable.
So, a quick summary before jump to code. The Handlers are just a reorganization, we are creating some new interfaces to allow some basic changes in how the renderers are created and how the layouts manage the native views; and also créate the mapper concept to allow more options to extend, and finally; move the logic used to update native views to extensions methods.
We are taking all the renderers and converting them to créate a more consistent API.
Relying on event handlers to orchestrate behavior and property changes
Lots of boilerplate code
Tons of knowledge required about order of events, both on the platform side and on the Xamarin.Forms side (i.e,, Does this need to happen on ElementChanged? What about ElementPropertyChanged? Etc.)
You don’t actually have to make this specific to iOS. You could actually make an extension method that changes the background color for each platform, and this mapping can live in one shared partial class…even less code!
Way easier to unit test, much less specific knowledge required about the inner workings of Maui to do something simple as change a color.
Button can be registered to either a Handler or a Renderer and the registrar will react accordingly. The ContentPage calls CreateRenderer on its content which will return an IVisualElementRenderer. If the Content is of type IViewHandler then it gets wrapped with a HandlerToRendererShim so that ContentPage can still render the control successfully.
Predictable releases helps everyone, not only the businesses that use .NET but also the open source projects that are built upon .NET.