Que Es Xamarin

Contents
Primeros pasos
¿Qué es Xamarin?
Instalación
Instalación de Xamarin en Windows
Instalación de versiones preliminares de Xamarin (Windows)
Desinstalación de Xamarin desde Visual Studio
Instalación de Visual Studio para Mac
Instalación de versiones preliminares de Xamarin (Mac)
Desinstalación de Visual Studio para Mac
Instrucciones de configuración del firewall para Xamarin
Plataformas compatibles
Primera aplicación
Guías de inicio rápido
Archivo > Nuevo
Varias páginas
Base de datos
Aplicación de estilos
Profundización
Tutoriales
Diseño de pila
Etiqueta
Botón
Entrada de texto
Editor de texto
Imágenes
Diseño de cuadrícula
Listas
Elementos emergentes
Ciclo de vida de la aplicación
Base de datos local
servicios Web
Obtener información sobre Xamarin
Desarrolladores de .NET
Desarrolladores de Java
Desarrolladores de Objective-C
Azure
Guía de desarrollo
¿Qué es Xamarin?
15/04/2020 • 10 minutes to read • Edit Online
Xamarin es una plataforma de código abierto para compilar aplicaciones modernas y con mejor rendimiento para
iOS, Android y Windows con .NET. Xamarin es una capa de abstracción que administra la comunicación de código
compartido con el código de plataforma subyacente. Xamarin se ejecuta en un entorno administrado que
proporciona ventajas como la asignación de memoria y la recolección de elementos no utilizados.
Xamarin permite a los desarrolladores compartir un promedio del 90 % de la aplicación entre plataformas. Este
patrón permite a los desarrolladores escribir toda la lógica de negocios en un solo lenguaje (o reutilizar el código
de aplicación existente), pero conseguir un rendimiento y una apariencia nativos en cada plataforma.
Las aplicaciones de Xamarin se pueden escribir en PC o Mac, y compilar en paquetes de aplicación nativos, como
un archivo .apk en Android o .ipa en iOS.
NOTE
Para la compilación e implementación de aplicaciones para iOS, en la actualidad se necesita un equipo MacOS. Para más
información sobre los requisitos de desarrollo, vea Requisitos del sistema.
A quién va destinado Xamarin

Xamarin es para desarrolladores con los siguientes objetivos:
Compartir código, pruebas y lógica de negocios entre plataformas.
Escribir aplicaciones multiplataforma en C# con Visual Studio.
Funcionamiento de Xamarin
En el diagrama se muestra la arquitectura general de una aplicación Xamarin multiplataforma. Xamarin permite
crear una interfaz de usuario nativa en cada plataforma y escribir lógica de negocios en C# que se comparte entre
plataformas. En la mayoría de los casos, con Xamarin se puede compartir el 80 % del código de la aplicación.
Xamarin se basa en Mono , una versión de código abierto de .NET Framework que se basa en los estándares ECMA
de .NET. Mono ha existido desde hace casi tanto tiempo como .NET Framework y se ejecuta en la mayoría de
plataformas, como Linux, Unix, FreeBSD y macOS. El entorno de ejecución Mono controla de forma automática
tareas como la asignación de memoria, la recolección de elementos no utilizados y la interoperabilidad con las
plataformas subyacentes.
Para más información sobre la arquitectura específica de la plataforma, vea Xamarin.Android y Xamarin.iOS.
Características agregadas
Xamarin combina las funciones de las plataformas nativas y agrega una serie de características, entre las que se
incluyen las siguientes:
1. Enlaces completos para los SDK subyacentes : Xamarin contiene enlaces para casi todos los SDK de
plataforma subyacentes en iOS y Android. Además, estos enlaces están fuertemente tipados, lo que significa que
la navegación y el uso son fáciles y que proporcionan una sólida comprobación de tipos en tiempo de
compilación y durante el desarrollo. Los enlaces fuertemente tipados producen menos errores en tiempo de
ejecución y aplicaciones de mayor calidad.
2. Interoperabilidad con Objective-C, Java, C y C++ : Xamarin ofrece funciones para invocar directamente
bibliotecas de Objective-C, Java, C y C++, lo que permite usar una amplia variedad de código de terceros. Estas
funciones permiten usar bibliotecas existentes de iOS y Android escritas en Objective-C, Java, C o C++. Además,
Xamarin ofrece proyectos de enlace que permiten enlazar bibliotecas nativas de Objective-C y Java mediante
una sintaxis declarativa.
3. Construcciones de lenguaje moderno : las aplicaciones Xamarin se escriben en C#, un lenguaje moderno
que incluye mejoras considerables con respecto a Objective-C y Java, como características de lenguaje dinámico,
construcciones funcionales como lambdas, LINQ, características de programación en paralelo, genéricos y
mucho más.
4. Biblioteca de clases base (BCL) sólida : las aplicaciones Xamarin usan la BCL de .NET, una gran colección de
clases con características completas y optimizadas, como una compatibilidad eficaz con XML, bases de datos,
serialización, E/S, cadenas, redes, etc. El código de C# existente se puede compilar para usarlo en una aplicación,
lo que proporciona acceso a miles de bibliotecas que agregan funcionalidad más allá de la BCL.
5. Entorno de desarrollo integrado (IDE) moderno : Xamarin usa Visual Studio, un IDE moderno que incluye
características como la finalización automática de código, un sofisticado sistema de administración de proyectos
y soluciones, una exhaustiva biblioteca de plantillas de proyecto, control de código fuente integrado, etc.
6. Compatibilidad multiplataforma móvil : Xamarin ofrece una compatibilidad multiplataforma sofisticada con
las tres principales plataformas: iOS, Android y Windows. Se pueden escribir aplicaciones de modo que
compartan hasta el 90 % del código, y Xamarin.Essentials ofrece una API unificada para acceder a recursos
comunes de las tres plataformas. El código compartido puede reducir considerablemente los costos de
desarrollo y el tiempo de salida al mercado para los desarrolladores para dispositivos móviles.
Xamarin.Android
Las aplicaciones Xamarin.Android se compilan desde C# en lenguaje intermedio (IL) que, después, se compila
Just-in-Time (JIT) en un ensamblado nativo cuando se inicia la aplicación. Las aplicaciones Xamarin.Android se
ejecutan en el entorno de ejecución Mono, en paralelo con la máquina virtual en tiempo de ejecución de Android
(ART). Xamarin proporciona enlaces .NET a los espacios de nombres Android.* y Java.*. El entorno de ejecución
Mono llama a estos espacios de nombres a través de contenedores administrados que se pueden llamar
(MCW) y proporciona a ART contenedores que se pueden llamar de Android (ACW) , lo que permite que
ambos entornos invoquen código entre sí.
Para más información, vea Arquitectura de Xamarin.Android.
Xamarin.iOS
Las aplicaciones Xamarin.iOS se compilan Ahead-of-Time (AOT) de forma completa desde código de C# en
código de ensamblado de ARM nativo. Xamarin usa selectores para exponer Objective-C en código de C#
administrado y registradores para exponer código de C# administrado en Objective-C. Los selectores y
registradores se denominan colectivamente "enlaces" y permiten la comunicación entre Objective-C y C#.
Para más información, vea Arquitectura de Xamarin.iOS.
Xamarin.Essentials
Xamarin.Essentials es una biblioteca que proporciona API multiplataforma para características de dispositivos
nativos. Como sucede con Xamarin, Xamarin.Essentials es una abstracción que simplifica el proceso de acceso a
funciones nativas. Algunos ejemplos de la funcionalidad proporcionada por Xamarin.Essentials son los siguientes:
Información del dispositivo
Sistema de archivos
Acelerómetro
Marcador telefónico
Texto a voz
Bloqueo de pantalla
Para más información, vea Xamarin.Essentials.
Xamarin.Forms
Xamarin.Forms es un marco de interfaz de usuario de código abierto. Xamarin.Forms permite a los desarrolladores
compilar aplicaciones iOS, Android y Windows desde un único código base compartido. Xamarin.Forms permite a
los desarrolladores crear interfaces de usuario en XAML con código subyacente en C#. Estas interfaces de usuario
se representan como controles nativos con mejor rendimiento en cada plataforma. Algunos ejemplos de
características proporcionadas por Xamarin.Forms son los siguientes:
Lenguaje de la interfaz de usuario de XAML
Enlace de datos
Gestos
Efectos
Para más información, vea Xamarin.Forms.
Primeros pasos
Las guías siguientes le ayudarán a compilar la primera aplicación con Xamarin:
Introducción a Xamarin.Forms
Introducción a Xamarin.Android
Introducción a Xamarin.iOS
Introducción a Xamarin.Mac
Vídeo relacionado
Encuentre más vídeos de Xamarin en Channel 9 y YouTube.
Instalación de Xamarin
Cómo configurar Visual Studio y Xamarin para comenzar a crear aplicaciones móviles con .NET.
Instrucciones paso a paso

Xamarin se puede instalar como parte de una nueva instalación de Visual Studio 2019, con los pasos siguientes:
1. Descargue Visual Studio 2019 Community, Visual Studio Professional o Visual Studio Enterprise desde la
página de Visual Studio (en la parte inferior se encuentran los vínculos de descarga).
2. Haga doble clic en el paquete descargado para iniciar la instalación.
3. Seleccione la carga de trabajo Desarrollo para dispositivos móviles con .NET en la pantalla de
instalación:
4. Cuando esté listo para comenzar la instalación de Visual Studio 2019, haga clic en el botón Instalar de la
esquina inferior derecha:
Use las barras de progreso para supervisar la instalación:

5. Cuando haya finalizado la instalación de Visual Studio 2019, haga clic en el botón Iniciar para iniciar Visual
Studio:
Adición de Xamarin a Visual Studio 2019

Si Visual Studio 2019 ya está instalado, para agregar Xamarin vuelva a ejecutar el instalador de Visual Studio 2019
para modificar las cargas de trabajo (vea Modificación de Visual Studio para más información). Después, siga los
pasos indicados anteriormente para instalar Xamarin.
Para más información sobre la descarga e instalación de Visual Studio 2019, vea Instalación de Visual Studio 2019.

instalación:
4. Con la opción Desarrollo para dispositivos móviles con .NET seleccionada, eche un vistazo al panel
Detalles de la instalación de la derecha. Aquí puede anular la selección de opciones de desarrollo para
dispositivos móviles que no quiera instalar.
5. Cuando esté listo para comenzar la instalación de Visual Studio 2017, haga clic en el botón Instalar situado
en la esquina inferior derecha:
En función de la edición de Visual Studio 2017 que vaya a instalar, el proceso de instalación puede tardar
bastante tiempo. Puede usar las barras de progreso para supervisar la instalación:
Studio:
Agregar Xamarin a Visual Studio 2017

Si Visual Studio 2017 ya está instalado, agregue Xamarin al volver a ejecutar el instalador de Visual Studio 2017
para modificar las cargas de trabajo (consulte Modificar Visual Studio para más información). Después, siga los
Para obtener más información sobre la descarga e instalación de Visual Studio 2017, consulte Instalación de Visual
Studio 2017.
Instalación de Xamarin en macOS

Además de este vídeo, hay una guía de instalación paso a paso que cubre Visual Studio para Mac y Xamarin.
Vínculos relacionados
Desinstalación de Xamarin
Instrucciones de configuración del firewall de Xamarin
Instalación de Xamarin en Visual Studio 2019
Compruebe los requisitos del sistema antes de empezar.
Instalación
instalación:
4. Cuando esté listo para comenzar la instalación de Visual Studio 2019, haga clic en el botón Instalar de la
esquina inferior derecha:
Use las barras de progreso para supervisar la instalación:
Studio:
Adición de Xamarin a Visual Studio 2019

Si Visual Studio 2019 ya está instalado, para agregar Xamarin vuelva a ejecutar el instalador de Visual Studio 2019
para modificar las cargas de trabajo (vea Modificación de Visual Studio para más información). Después, siga los
Para más información sobre la descarga e instalación de Visual Studio 2019, vea Instalación de Visual Studio 2019.
En Visual Studio 2019, compruebe que Xamarin está instalado; para ello, haga clic en el menú Ayuda . Si está
instalado, debería ver el elemento de menú Xamarin , como se muestra en esta captura de pantalla:
Puede hacer clic en Ayuda > Acerca de Microsoft Visual Studio y desplazarse por la lista de productos
instalados para ver si Xamarin está instalado:
Para obtener más información sobre cómo encontrar la información de la versión, consulte Where can I find my
version information and logs? (¿Dónde puedo encontrar los registros y la información de la versión?).
Pasos siguientes
La instalación de Xamarin en Visual Studio 2019 le permite empezar a escribir código para las aplicaciones, pero
requiere configuración adicional para compilar e implementar las aplicaciones en el simulador, el emulador y el
dispositivo. Consulte las siguientes guías para completar la instalación y empezar a compilar aplicaciones
multiplataforma.
iOS
Para obtener información detallada, consulte la guía de instalación de Xamarin.iOS en Windows.
1. Instalación de Visual Studio para Mac
2. Conexión de Visual Studio con el host de compilación del equipo Mac
3. Configuración del desarrollador de iOS: necesaria para ejecutar la aplicación en el dispositivo
4. Simulador remoto de iOS
5. Introducción a Xamarin.iOS para Visual Studio
Android
Para obtener información detallada, consulte la guía de instalación de Xamarin.Android en Windows.
1. Configuración de Xamarin.Android
2. Uso del administrador de Android SDK de Xamarin
3. Emulador de Android SDK
4. Configurar el dispositivo para el desarrollo
Instalación de la versión preliminar de Xamarin en
Windows
En Visual Studio 2019 y Visual Studio 2017 no se admiten los canales alfa, beta ni estable de la misma manera que
en versiones anteriores. En su lugar, hay solo dos opciones:
Lanzamiento : equivalente al canal estable en Visual Studio para Mac
Versión preliminar : equivalente a los canales alfa y beta en Visual Studio para Mac
TIP
Para probar las características de versión preliminar, debe descargar el instalador de Visual Studio Preview, que le ofrece la
opción de instalar versiones preliminares de Visual Studio en paralelo con la versión estable (versión de lanzamiento). En
las notas de la versión puede encontrar más información sobre las novedades de Visual Studio 2019.
La versión preliminar de Visual Studio puede contener las versiones preliminares correspondientes de la
funcionalidad de Xamarin, incluidas:
Xamarin.Forms
Xamarin.iOS
Xamarin.Android
Generador de perfiles de Xamarin
Xamarin Inspector
Simulador iOS remoto de Xamarin
La captura de pantalla del instalador de versión preliminar siguiente muestra las opciones de versión
preliminar y lanzamiento (tenga en cuenta los números de versión en gris: la versión 15.0 es de lanzamiento y la
versión 15.1 es una versión preliminar):
Durante el proceso de instalación, se puede aplicar un alias de instalación a la instalación en paralelo (por lo que
pueden distinguirse en el menú Inicio), tal y como se muestra a continuación:
Desinstalación de Visual Studio 2019 Preview

El Instalador de Visual Studio también se debe usar para desinstalar las versiones preliminares de Visual
Studio 2019. Lea la guía de desinstalación de Xamarin para más información.
Desinstalación de Xamarin de Visual Studio
En esta guía se explica cómo quitar Xamarin de Visual Studio en Windows.
Visual Studio 2019 y Visual Studio 2017

Xamarin se desinstala de Visual Studio 2019 y Visual Studio 2017 mediante la aplicación del instalador:
1. Use el menú Inicio para abrir el instalador de Visual Studio .
2. Pulse el botón Modificar para la instancia que quiera cambiar.
3. En la pestaña Cargas de trabajo , anule la selección de la opción Desarrollo móvil con .NET (en la
sección Dispositivos móviles y juegos ).
4. Haga clic en el botón Modificar en la parte inferior derecha de la ventana.

5. El instalador quitará los componentes cuya selección se haya anulado (Visual Studio 2017 debe cerrarse
antes de que el instalador pueda realizar cambios).
Se quiere desinstalar componentes individuales de Xamarin, como el generador de perfiles o los libros, puede
cambiar a la pestaña Componentes individuales en el paso 3 y desactivar componentes específicos:
Para desinstalar completamente Visual Studio 2017, elija Desinstalar en el menú de tres barras que hay junto al
botón Iniciar .
IMPORTANT
Si tiene dos o más instancias de Visual Studio instaladas en paralelo (SxS), como una versión de lanzamiento y una versión
preliminar, es posible que al desinstalar una instancia se quiten algunas funciones de Xamarin de las otras instancias de Visual
Studio, incluidas:
Generador de perfiles de Xamarin
Libros/Inspector de Xamarin
Simulador iOS remoto de Xamarin
SDK de Apple Bonjour
Bajo ciertas condiciones, la desinstalación de una de las instancias SxS puede ocasionar la eliminación incorrecta de estas
características. Esto puede degradar el rendimiento de la plataforma Xamarin en las instancias de Visual Studio que
permanecen en el sistema después de desinstalar la instancia SxS.
Esto se puede resolver mediante la ejecución de la opción Reparación en el instalador de Visual Studio, que volverá a instalar
los componentes que falten.
Visual Studio 2015 y anterior

Para desinstalar Visual Studio 2015 por completo, use la respuesta de soporte técnico que encontrará en
visualstudio.com.
Xamarin puede desinstalarse de un equipo Windows mediante el Panel de control . Vaya a Programas y
características o Programas > Desinstalar un programa como se muestra a continuación:
Desde el Panel de control, desinstale cualquiera de los siguientes elementos:
Xamarin
Xamarin para Windows
Xamarin.Android
Xamarin.iOS
Xamarin para Visual Studio
En el Explorador, elimine los archivos restantes de las carpetas de la extensión de Xamarin Visual Studio (todas las
versiones, incluidas las de Archivos de programa y Archivos de programa (x86)):
C:\Program Files*\Microsoft Visual Studio 1*.0\Common7\IDE\Extensions\Xamarin
Elimine el directorio de la caché del componente MEF de Visual Studio, que debería estar en la ubicación siguiente:
%LOCALAPPDATA%\Microsoft\VisualStudio\1*.0\ComponentModelCache
Consulte el directorio Vir tualStore para ver si es posible que Windows haya almacenado allí algún archivo de
superposición para los directorios Extensions\Xamarin o ComponentModelCache :
%LOCALAPPDATA%\VirtualStore
Abra el editor del Registro (regedit) y busque la siguiente clave:
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\SharedDlls
Busque y elimine las entradas que coincidan con este patrón:
C:\Program Files*\Microsoft Visual Studio 1*.0\Common7\IDE\Extensions\Xamarin
Busque esta clave:
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\1*.0\ExtensionManager\PendingDeletions
Elimine las entradas que parezca que puedan estar relacionadas con Xamarin. Por ejemplo, todo lo que contenga
los términos mono o xamarin .
Abra un símbolo de sistema de administrador cmd.exe y, después, ejecute los comandos devenv /setup y
devenv /updateconfiguration para cada versión instalada de Visual Studio. Por ejemplo, para Visual Studio 2015:
"%ProgramFiles(x86)%\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe" /setup

"%ProgramFiles(x86)%\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe" /updateconfiguration
Instrucciones de configuración de firewall para
Xamarin
Lista de los hosts que se deben permitir en el firewall para que la plataforma de Xamarin funcione en la empresa.
Para que los productos de Xamarin se instalen y funcionen correctamente, determinados puntos de conexión
deben ser accesibles para descargar las herramientas y las actualizaciones necesarias para el software. Si usted o la
empresa tienen una configuración de firewall estricta, puede experimentar problemas con la instalación, las
licencias, los componentes, etc. En este documento se indican algunos de los puntos de conexión conocidos que se
deben permitir en el firewall para que Xamarin funcione. No se incluyen los puntos de conexión necesarios para las
herramientas de otros fabricantes incluidas en la descarga. Si después de repasar esta lista sigue teniendo
problemas, consulte las guías de solución de problemas de instalación de Apple o Android.
Puntos de conexión permitidos

Instalador de Xamarin
Para que el software se instale correctamente con la versión más reciente del instalador de Xamarin, tiene que
agregar las siguientes direcciones conocidas:
xamarin.com (manifiestos del instalador)
dl.xamarin.com (ubicación de descarga del paquete)
dl.google.com (para descargar el SDK de Android)
download.oracle.com (JDK)
visualstudio.com (configurar ubicación de descarga de paquetes)
go.microsoft.com (configurar URL de resolución)
aka.ms (configurar URL de resolución)
Si está usando un equipo Mac y tiene problemas de instalación de Xamarin.Android, asegúrese de que macOS
pueda descargar Java.
NuGet (incluye Xamarin.Forms)
Para obtener acceso a NuGet (Xamarin.Forms está empaquetado como NuGet), tiene que agregar las siguientes
direcciones:
www.nuget.org (para acceder a NuGet)
globalcdn.nuget.org (descargas de NuGet)
dl-ssl.google.com (componentes de Google para Android y Xamarin.Forms)
Actualizaciones de software
Para garantizar que las actualizaciones de software se descarguen correctamente, tendrá que agregar las siguientes
direcciones:
software.xamarin.com (servicio de actualizador)
download.visualstudio.microsoft.com
dl.xamarin.com
Xamarin Mac Agent

Para conectar Visual Studio a un host de compilación de Mac mediante Xamarin Mac Agent, el puerto SSH tiene
que estar abierto. De forma predeterminada, es el puer to 22 .
Plataformas compatibles con Xamarin.Forms
Las aplicaciones de Xamarin.Forms pueden escribirse para los siguientes sistemas operativos:
iOS 9 o versiones posteriores.
Android 4.4 (API 19) o versiones posteriores (más detalles). Pero se recomienda Android 5.0 (API 21) como la
API mínima. Esto garantiza la compatibilidad total con todas las bibliotecas de compatibilidad de Android, a la
vez que se destina a la mayoría de los dispositivos Android.
Plataforma universal de Windows de Windows 10.
Las aplicaciones Xamarin.Forms para iOS, Android y la plataforma universal de Windows (UWP) se pueden
compilar en Visual Studio. Pero se necesita un equipo Mac en red para el desarrollo de iOS con la última versión de
Xcode y la versión mínima de macOS que especifica Apple. Para más información, vea Requisitos de Windows.
Las aplicaciones Xamarin.Forms para iOS y Android se pueden compilar en Visual Studio para Mac. Para más
información, vea Requisitos de macOS.
NOTE
Para desarrollar aplicaciones con Xamarin.Forms es necesario estar familiarizado con .NET Standard.
Compatibilidad con plataforma adicional

Xamarin.Forms admite otras plataformas además de iOS, Android y Windows:
Samsung Tizen
macOS
GTK#
WPF
El estado de estas plataformas está disponible en la wiki de compatibilidad con la plataforma de GitHub para
Xamarin.Forms.
Compatibilidad con la plataforma Android

Debe tener instalada la plataforma más reciente de Android SDK Tools y de la API de Android. Puede actualizar a las
versiones más recientes con Android SDK Manager.
Además, la versión de compilación o de destino de los proyectos de Android debe establecerse en Usar la última
plataforma instalada, aunque la versión mínima se puede establecer en API 19 para que pueda seguir admitiendo
dispositivos que usen Android 4.4 y versiones más recientes. Estos valores se establecen en Opciones del
proyecto :
Visual Studio
Visual Studio para Mac
Opciones de proyecto > Aplicación > Propiedades de la aplicación
Plataformas en desuso
Cuando se usa Xamarin.Forms 3.0 o una versión posterior no se admiten estas plataformas:
Windows 8.1 / Windows Phone 8.1 WinRT
Windows Phone 8 Silverlight
Creación de una primera aplicación de
Xamarin.Forms
Vea este vídeo y siga el tutorial para crear una primera aplicación móvil con Xamarin.Forms.
Instrucciones paso a paso para Windows

Descargar el ejemplo
Siga estos pasos, junto con el vídeo anterior:
1. Elija Archivo > Nuevo > Proyecto... o presione el botón Crear nuevo proyecto... :
2. Busque "Xamarin" o elija Dispositivos móviles en el menú Tipo de proyecto . Seleccione el tipo de
proyecto Aplicación móvil (Xamarin.Forms) :
3. Elija un nombre de proyecto; en el ejemplo se usa "AwesomeApp":
4. Haga clic en el tipo de proyecto En blanco y asegúrese de que Android e iOS estén seleccionados:
5. Espere hasta que se restauren los paquetes de NuGet (aparecerá un mensaje de "Restauración completada"
en la barra de estado).
6. Las nuevas instalaciones de Visual Studio 2019 no tendrán un emulador de Android configurado. Haga clic
en la flecha desplegable del botón Depurar y elija Crear Android Emulator para iniciar la pantalla de
creación del emulador:
7. En la pantalla de creación del emulador, use la configuración predeterminada y haga clic en el botón Crear :
8. Al crear un emulador, se le devolverá a la ventana Administrador de dispositivos. Haga clic en el botón

Iniciar para iniciar el nuevo emulador:
9. Ahora en Visual Studio 2019 se debería mostrar el nombre del nuevo emulador en el botón Depurar :
10. Haga clic en el botón Depurar para compilar e implementar la aplicación en el emulador de Android:
Personalización de la aplicación
La aplicación se puede personalizar para agregar funcionalidad interactiva. Realice los pasos siguientes para
agregar la interacción del usuario a la aplicación:
1. Edite MainPage.xaml , agregando este XAML antes del final de </StackLayout> :
<Button Text="Click Me" Clicked="Button_Clicked" />
2. Edite MainPage.xaml , agregando este código al final de la clase:
int count = 0;
void Button_Clicked(object sender, System.EventArgs e)
{
count++;
((Button)sender).Text = $"You clicked {count} times.";
}
3. Depurar la aplicación en Android:
NOTE
En la aplicación de ejemplo se incluye la funcionalidad interactiva adicional que no se trata en el vídeo.
Compilación de una aplicación iOS en Visual Studio 2019

Es posible crear y depurar la aplicación iOS desde Visual Studio con un equipo Mac en red. Consulte las
instrucciones de configuración para obtener más información.
En este vídeo se describe el proceso de compilación y prueba de una aplicación iOS con Visual Studio 2019 en
Windows:
Instrucciones paso a paso para Windows
1. Elija Archivo > Nuevo > Proyecto... o presione el botón Crear proyecto nuevo... y, a continuación,
seleccione Visual C# > Multiplataforma > Aplicación móvil (Xamarin.Forms) :
2. Asegúrese de que Android y iOS están seleccionados, con uso compartido del código .NET Standard :
3. Espere hasta que se restauren los paquetes de NuGet (aparecerá un mensaje de "Restauración completada"
en la barra de estado).
4. Inicie Android Emulator presionando el botón de depuración (o el elemento de menú Depurar > Iniciar
depuración ).
<Button Text="Click Me" Clicked="Button_Clicked" />

int count = 0;
void Button_Clicked(object sender, System.EventArgs e)
{
count++;
}
TIP
Es posible crear y depurar la aplicación de iOS desde Visual Studio con un equipo Mac en red. Consulte las
instrucciones de configuración para obtener más información.
Instrucciones paso a paso para Mac

1. Elija Archivo > Nueva solución... o presione el botón Nuevo proyecto... y, posteriormente, seleccione
Multiplataforma > Aplicación > Aplicación de Forms en blanco :
2. Asegúrese de que Android y iOS están seleccionados, con uso compartido del código .NET Standard :
3. Restaurar paquetes de NuGet, haciendo clic en el botón derecho en la solución:
4. Inicie Android Emulator presionando el botón de depuración (o Ejecutar > Iniciar depuración ).
<Button Text="Click Me" Clicked="Handle_Clicked" />
int count = 0;
void Handle_Clicked(object sender, System.EventArgs e)
{
count++;
}

8. Haga clic con el botón derecho para establecer iOS en el Proyecto de inicio :
9. Depurar la aplicación en iOS:

Puede descargar el código completo desde la galería de ejemplos o puede verlo en GitHub.
Pasos siguientes
Inicio rápido de una sola página: compilación de una aplicación más funcional.
Ejemplos de Xamarin.Forms: descarga y ejecución de ejemplos de código y aplicaciones de muestra.
Libro electrónico Creación de aplicaciones móviles: capítulos detallados en los que se describe el desarrollo de
Xamarin.Forms, disponible como archivo PDF y que incluye cientos de ejemplos adicionales.
Inicios rápidos de Xamarin.Forms
Obtenga información sobre cómo crear aplicaciones para dispositivos móviles con Xamarin.Forms.
Creación de una aplicación Xamarin.Forms de página única

Obtenga información sobre cómo crear una aplicación multiplataforma de una página de Xamarin.Forms, que
permite escribir una nota y conservarla en el almacenamiento del dispositivo.
Navegación en una aplicación Xamarin.Forms de varias páginas

Obtenga información sobre cómo convertir una aplicación de una página, capaz de almacenar una sola nota, en
una aplicación de varias páginas, capaz de almacenar varias notas.
Almacenamiento de datos en una base de datos de SQLite.NET local

Obtenga información sobre cómo almacenar datos en una base de datos local de SQLite.NET.
Estilo de una aplicación Xamarin.Forms multiplataforma

Obtenga información sobre cómo diseñar una aplicación de Xamarin.Forms multiplataforma con estilos XAML.
Análisis detallado de inicio rápido

Obtenga información sobre los aspectos básicos del desarrollo de aplicaciones con Xamarin.Forms, centrándose en
la aplicación desarrollada en los inicios rápidos.
Creación de una aplicación Xamarin.Forms de página
única
En este inicio rápido aprenderá a:
Crear una aplicación Xamarin.Forms multiplataforma.
Definir la interfaz de usuario para una página mediante el lenguaje XAML.
Interactuar con los elementos de la interfaz de usuario XAML desde el código.
El inicio rápido le guía sobre cómo crear una aplicación Xamarin.Forms multiplataforma que permite escribir una
nota y conservarla en el almacenamiento del dispositivo. A continuación se muestra la aplicación final:
Requisitos previos
Visual Studio 2019 (última versión), con la carga de trabajo Desarrollo para dispositivos móviles con
.NET instalada.
Conocimientos de C#.
(opcional) Un equipo Mac emparejado para compilar la aplicación en iOS.
Para más información sobre estos requisitos previos, vea Instalación de Xamarin. Para obtener información sobre
cómo conectar Visual Studio 2019 a un host de compilación de Mac, consulte Emparejar con Mac para el
desarrollo de Xamarin.iOS.
Introducción a Visual Studio 2019

1. Inicie Visual Studio 2019 y, en la ventana de inicio, haga clic en Crear un proyecto nuevo para crear un
proyecto:
2. En la ventana Crear un proyecto nuevo , seleccione Dispositivos móviles en la lista desplegable Tipo
de proyecto , seleccione la plantilla Aplicación móvil (Xamarin.Forms) y haga clic en el botón
Siguiente :
3. En el cuadro de diálogo Configure su nuevo proyecto , establezca Nombre del proyecto en Notes ,
elija una ubicación adecuada para el proyecto y haga clic en el botón Crear :
IMPORTANT
Los fragmentos de XAML y C# en este inicio rápido requieren que la solución se denomine Notes . El uso de otro
nombre dará como resultado errores de compilación al copiar el código de este inicio rápido en la solución.
4. En el cuadro de diálogo Nueva aplicación multiplataforma , haga clic en Aplicación en blanco y

después en el botón Aceptar :
Para obtener más información sobre la biblioteca de .NET Standard creada, vea Anatomía de una aplicación
de Xamarin.Forms en Análisis detallado de inicio rápido de Xamarin.Forms.
5. En el Explorador de soluciones , en el proyecto Notes , haga doble clic en MainPage.xaml para abrirlo:
6. En MainPage.xaml , quite todo el código de plantilla y sustitúyalo por el siguiente código:
<?xml version="1.0" encoding="utf-8"?>

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
x:Class="Notes.MainPage">
<StackLayout Margin="10,35,10,10">
<Label Text="Notes"
HorizontalOptions="Center"
FontAttributes="Bold" />
<Editor x:Name="editor"
Placeholder="Enter your note"
HeightRequest="100" />
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<Button Text="Save"
Clicked="OnSaveButtonClicked" />
<Button Grid.Column="1"
Text="Delete"
Clicked="OnDeleteButtonClicked"/>
</Grid>
</StackLayout>
</ContentPage>
Este código define mediante declaración la interfaz de usuario para la página, que consta de una instancia
de Label para mostrar texto, una instancia de Editor para entrada de texto y dos instancias de Button
que dirigen la aplicación para guardar o eliminar un archivo. Las dos instancias de Button se disponen
horizontalmente en Grid , mientras que Label , Editor y Grid se disponen verticalmente en
StackLayout . Para más información sobre la creación de la interfaz de usuario, vea Interfaz de usuario en
Análisis detallado de inicio rápido de Xamarin.Forms.
Guarde los cambios en MainPage.xaml presionando CTRL+S y cierre el archivo.
7. En el Explorador de soluciones , en el proyecto Notes , expanda MainPage.xaml y haga doble clic en
MainPage.xaml.cs para abrirlo:
8. En MainPage.xaml.cs , quite todo el código de plantilla y sustitúyalo por el siguiente código:
using System;
using System.IO;
using Xamarin.Forms;
namespace Notes
{
public partial class MainPage : ContentPage
{
string _fileName =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "notes.txt");
public MainPage()
{
InitializeComponent();
if (File.Exists(_fileName))
{
editor.Text = File.ReadAllText(_fileName);
}
}
void OnSaveButtonClicked(object sender, EventArgs e)

{
File.WriteAllText(_fileName, editor.Text);
}
void OnDeleteButtonClicked(object sender, EventArgs e)

{
{
File.Delete(_fileName);
}
editor.Text = string.Empty;
}
}
}
Este código define un campo _fileName , que hace referencia a un archivo denominado notes.txt que
almacenará los datos de la nota en la carpeta de datos de la aplicación local para la aplicación. Cuando se
ejecuta el constructor de páginas, el archivo se lee, si existe, y se muestra en el Editor . Al presionar el
control Button Guardar , se ejecuta el controlador de eventos OnSaveButtonClicked , que guarda el
contenido de Editor en el archivo. Al presionar el control Button Eliminar , se ejecuta el controlador de
eventos OnDeleteButtonClicked , que elimina el archivo, siempre que exista, y quita cualquier texto de
Editor . Para más información sobre la interacción del usuario, vea Respuesta a la interacción del usuario
en Análisis detallado de inicio rápido de Xamarin.Forms.
Guarde los cambios en MainPage.xaml.cs presionando CTRL+S y cierre el archivo.
Compilar el tutorial rápido
1. En Visual Studio, seleccione el elemento de menú Compilación > Compilar solución (o presione F6). La
solución se compilará y aparecerá un mensaje de operación correcta en la barra de estado de Visual Studio:
Si hay errores, repita los pasos anteriores y corrija los errores hasta que la solución se compile
correctamente.
2. En la barra de herramientas de Visual Studio, pulse el botón Iniciar (el botón triangular que parece un
botón de reproducción) para iniciar la aplicación en la instancia elegida de Android Emulator:
Escriba una nota y pulse el botón Guardar .

Para más información sobre cómo se inicia la aplicación en cada plataforma, vea Inicio de la aplicación en
cada plataforma en Análisis detallado de inicio rápido de Xamarin.Forms.
NOTE
Los pasos siguientes solo deben realizarse si se tiene un equipo Mac emparejado que cumpla los requisitos del
sistema para el desarrollo de Xamarin.Forms.
3. En la barra de herramientas de Visual Studio, haga clic con el botón derecho en el proyecto Notes.iOS y
seleccione Establecer como proyecto de inicio .
botón de reproducción) para iniciar la aplicación en la instancia elegida de iOS Simulator:

Requisitos previos
Visual Studio 2017, con la carga de trabajo Desarrollo para dispositivos móviles con .NET instalada.
(opcional) Un equipo Mac emparejado para compilar la aplicación en iOS.
Para más información sobre estos requisitos previos, vea Instalación de Xamarin. Para obtener información sobre
cómo conectar Visual Studio 2019 a un host de compilación de Mac, consulte Emparejar con Mac para el
desarrollo de Xamarin.iOS.
Introducción a Visual Studio 2017

1. Para crear un proyecto, inicie Visual Studio 2017 y, en la página de inicio, haga clic en Crear nuevo
proyecto... :
2. En el cuadro de diálogo Nuevo proyecto , haga clic en Multiplataforma , seleccione la plantilla

Aplicación móvil (Xamarin.Forms) , establezca el nombre en Notes , elija una ubicación adecuada para
el proyecto y haga clic en el botón Aceptar :
IMPORTANT
Los fragmentos de XAML y C# en este inicio rápido requieren que la solución se denomine Notes . El uso de otro
nombre dará como resultado errores de compilación al copiar el código de este inicio rápido en la solución.
3. En el cuadro de diálogo New Cross Platform App (Nueva aplicación multiplataforma), haga clic en
Aplicación en blanco , seleccione .NET Standard como estrategia de código de uso compartido y haga
clic en el botón Aceptar :
4. En el Explorador de soluciones , en el proyecto Notes , haga doble clic en MainPage.xaml para abrirlo:

<Label Text="Notes"
<Grid>
<Button Text="Save"
Text="Delete"
</Grid>
</StackLayout>
</ContentPage>
Guarde los cambios en MainPage.xaml presionando CTRL+S y cierre el archivo.
6. En el Explorador de soluciones , en el proyecto Notes , expanda MainPage.xaml y haga doble clic en
using System;
using System.IO;
namespace Notes
{
{
string _fileName =
public MainPage()
{
{
}
}

{
}

{
{
}
}
}
}
Guarde los cambios en MainPage.xaml.cs presionando CTRL+S y cierre el archivo.
Compilar el tutorial rápido
1. En Visual Studio, seleccione el elemento de menú Compilación > Compilar solución (o presione F6). La
solución se compilará y aparecerá un mensaje de operación correcta en la barra de estado de Visual Studio:
correctamente.
botón de reproducción) para iniciar la aplicación en la instancia elegida de Android Emulator:

NOTE
Los pasos siguientes solo deben realizarse si se tiene un equipo Mac emparejado que cumpla los requisitos del
sistema para el desarrollo de Xamarin.Forms.
3. En la barra de herramientas de Visual Studio, haga clic con el botón derecho en el proyecto Notes.iOS y
seleccione Establecer como proyecto de inicio .
botón de reproducción) para iniciar la aplicación en la instancia elegida de iOS Simulator:

Requisitos previos
Visual Studio para Mac (última versión) con compatibilidad con la plataforma iOS y Android.
Xcode (última versión).
Para más información sobre estos requisitos previos, vea Instalación de Xamarin.
Introducción a Visual Studio para Mac

1. Para crear un proyecto, inicie Visual Studio para Mac y, en la ventana de inicio, haga clic en Nuevo :
2. En el cuadro de diálogo Elija una plantilla para el nuevo proyecto , haga clic en Multiplataforma >
Aplicación , seleccione la plantilla Aplicación de Forms en blanco y haga clic en el botón Siguiente :
3. En el cuadro de diálogo Configurar su nueva aplicación de Forms en blanco , asigne a la nueva

aplicación el nombre Notes , asegúrese de que el botón de radio Usar .NET Standard esté seleccionado y
haga clic en el botón Siguiente :
4. En el cuadro de diálogo Configurar su nueva aplicación de Forms en blanco , deje los nombres de
solución y de proyecto establecidos en Notes , elija una ubicación adecuada para el proyecto y haga clic en
el botón Crear para crearlo:
IMPORTANT
Los fragmentos de XAML y C# en este inicio rápido requieren que tanto la solución como el proyecto se denominen
Notes . El uso de otro nombre dará como resultado errores de compilación al copiar el código de este inicio rápido
en la solución.
5. En el Panel de solución , en el proyecto Notes , haga doble clic en MainPage.xaml para abrirlo:

<Label Text="Notes"
<Grid>
<Button Text="Save"
Text="Delete"
</Grid>
</StackLayout>
</ContentPage>
Guarde los cambios en MainPage.xaml eligiendo Archivo > Guardar (o presionando ⌘ + S ) y cierre el
archivo.
7. En el Panel de solución , en el proyecto Notes , expanda MainPage.xaml y haga doble clic en
using System;
using System.IO;
namespace Notes
{
{
string _fileName =
public MainPage()
{
{
}
}

{
}

{
{
}
}
}
}
Guarde los cambios en MainPage.xaml.cs eligiendo Archivo > Guardar (o presionando ⌘ + S ) y cierre
el archivo.
Compilación del inicio rápido
1. En Visual Studio para Mac, seleccione el elemento de menú Compilación > Compilar todo (o pulse ⌘ +
B ). El proyecto se compilará y aparecerá un mensaje de operación correcta en la barra de herramientas de
Visual Studio para Mac.
correctamente.
2. En el Panel de solución , seleccione el proyecto Notes.iOS , haga clic con el botón derecho y seleccione
Establecer como proyecto de inicio :
3. En la barra de herramientas de Visual Studio para Mac, pulse el botón Iniciar (el botón triangular similar a
un botón de reproducción) para iniciar la aplicación en la instancia elegida de iOS Simulator:

4. En el Panel de solución , seleccione el proyecto Notes.Droid , haga clic con el botón derecho y seleccione
Establecer como proyecto de inicio :
5. En la barra de herramientas de Visual Studio para Mac, pulse el botón Iniciar (el botón triangular similar a
un botón de reproducción) para iniciar la aplicación en la instancia elegida de Android Emulator:

Pasos siguientes
En este inicio rápido ha aprendido a:
Crear una aplicación Xamarin.Forms multiplataforma.
Definir la interfaz de usuario para una página mediante el lenguaje XAML.
Interactuar con los elementos de la interfaz de usuario XAML desde el código.
Para convertir esta aplicación de página única en una de varias páginas, continúe con el siguiente inicio rápido.
Siguiente
Notes (ejemplo)
Análisis detallado de inicio rápido de Xamarin.Forms
Navegación en una aplicación Xamarin.Forms de
varias páginas
Agregar páginas adicionales a una solución de Xamarin.Forms.
Realizar la navegación entre las páginas.
Usar el enlace de datos para sincronizar datos entre los elementos de la interfaz de usuario y su origen de
datos.
En este inicio rápido se describe cómo convertir una aplicación Xamarin.Forms multiplataforma de página única,
capaz de almacenar una sola nota, en una aplicación de varias páginas, capaz de almacenar varias notas. A
continuación se muestra la aplicación final:
Requisitos previos
Antes de intentar este inicio rápido, debe completar correctamente el inicio rápido anterior. También puede
descargar el ejemplo del inicio rápido anterior y usarlo como punto de partida para este.
Actualizar la aplicación con Visual Studio

1. Inicie Visual Studio. En la ventana de inicio, haga clic en la solución Notes en la lista de proyectos o
soluciones recientes, o bien haga clic en Abrir un proyecto o una solución y, en el cuadro de diálogo
Abrir proyecto o solución , seleccione el archivo de solución del proyecto Notes:
2. En el Explorador de soluciones , haga clic con el botón derecho en el proyecto Notes y seleccione
Agregar > Nueva carpeta :
3. En el Explorador de soluciones , asigne el nombre Modelos a la nueva carpeta:

4. En el Explorador de soluciones , seleccione la carpeta Modelos , haga clic con el botón derecho y
seleccione Agregar > Nuevo elemento... :
5. En el cuadro de diálogo Agregar nuevo elemento , seleccione Elementos de Visual C# > Clase , asigne
el nombre Note al nuevo archivo y haga clic en el botón Agregar :
Esto agregará una clase denominada Note a la carpeta Modelos del proyecto Notes .
6. En Note.cs , quite todo el código de plantilla y sustitúyalo por el siguiente:
using System;
namespace Notes.Models
{
public class Note
{
public string Filename { get; set; }
public string Text { get; set; }
public DateTime Date { get; set; }
}
}
Esta clase define un modelo Note que almacenará los datos sobre cada nota en la aplicación.
Presione CTRL+S para guardar los cambios en Note.cs y cierre el archivo.
Agregar > Nuevo elemento... . En el cuadro de diálogo Agregar nuevo elemento , seleccione
Elementos de Visual C# > Xamarin.Forms > Página de contenido , asigne el nombre
NoteEntr yPage al nuevo archivo y haga clic en el botón Agregar :
Esto agregará una página nueva denominada NoteEntr yPage a la carpeta raíz del proyecto. Esta página
será la segunda de la aplicación.
8. En NoteEntr yPage.xaml , quite todo el código de plantilla y reemplácelo por el siguiente:
<?xml version="1.0" encoding="UTF-8"?>
x:Class="Notes.NoteEntryPage"
Title="Note Entry">
<StackLayout Margin="20">
<Editor Placeholder="Enter your note"
Text="{Binding Text}"
<Grid>
<Button Text="Save"
Text="Delete"
</Grid>
</StackLayout>
</ContentPage>
de Editor para la entrada de texto y dos instancias de Button que dirigen la aplicación para guardar o
eliminar un archivo. Las dos instancias de Button se disponen horizontalmente en Grid , mientras que
Editor y Grid se disponen en vertical en StackLayout . Además, Editor usa el enlace de datos para
enlazar con la propiedad Text del modelo Note . Para más información sobre el enlace de datos, vea
Enlace de datos en Análisis detallado de inicio rápido de Xamarin.Forms.
Presione CTRL+S para guardar los cambios en NoteEntr yPage.xaml y cierre el archivo.
9. En NoteEntr yPage.xaml.cs , quite todo el código de plantilla y reemplácelo por el siguiente:
using System;
using System.IO;
using Notes.Models;
namespace Notes
{
public partial class NoteEntryPage : ContentPage
{
public NoteEntryPage()
{
}
async void OnSaveButtonClicked(object sender, EventArgs e)

{
var note = (Note)BindingContext;
if (string.IsNullOrWhiteSpace(note.Filename))
{
// Save
var filename = Path.Combine(App.FolderPath, $"{Path.GetRandomFileName()}.notes.txt");
File.WriteAllText(filename, note.Text);
}
else
{
// Update
File.WriteAllText(note.Filename, note.Text);
}
await Navigation.PopAsync();
}
async void OnDeleteButtonClicked(object sender, EventArgs e)

{
if (File.Exists(note.Filename))
{
File.Delete(note.Filename);
}
}
}
}
Este código almacena una instancia de Note , que representa una única nota, en el elemento
BindingContext de la página. Cuando se presiona el objeto Button Guardar se ejecuta el controlador de
eventos OnSaveButtonClicked , que guarda el contenido de Editor en un archivo nuevo con un nombre de
archivo generado de forma aleatoria, o bien en un archivo existente si se va a actualizar una nota. En ambos
casos, el archivo se almacena en la carpeta de datos de la aplicación local. Después, el método regresa a la
página anterior. Al pulsar el objeto Button Eliminar , se ejecuta el controlador de eventos
OnDeleteButtonClicked , que elimina el archivo, siempre que exista, y regresa a la página anterior. Para más
información sobre la navegación, vea Navegación en Análisis detallado de inicio rápido de Xamarin.Forms.
Presione CTRL+S para guardar los cambios en NoteEntr yPage.xaml.cs y cierre el archivo.
WARNING
Si en este momento intenta compilar la aplicación, se producirán errores que se corregirán en pasos posteriores.
Agregar > Nuevo elemento... . En el cuadro de diálogo Agregar nuevo elemento , seleccione
Elementos de Visual C# > Xamarin.Forms > Página de contenido , asigne el nombre NotesPage al
nuevo archivo y haga clic en el botón Agregar .
Esto agregará una página nueva denominada NotesPage a la carpeta raíz del proyecto. Esta página será la
página raíz de la aplicación.
11. En NotesPage.xaml , quite todo el código de plantilla y sustitúyalo por el siguiente:

x:Class="Notes.NotesPage"
Title="Notes">
<ContentPage.ToolbarItems>
<ToolbarItem Text="+"
Clicked="OnNoteAddedClicked" />
</ContentPage.ToolbarItems>
<ListView x:Name="listView"
Margin="20"
ItemSelected="OnListViewItemSelected">
<ListView.ItemTemplate>
<DataTemplate>
<TextCell Text="{Binding Text}"
Detail="{Binding Date}" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</ContentPage>
Este código define mediante declaración la interfaz de usuario de la página, que consiste en los objetos
ListView y ToolbarItem . En ListView se usa el enlace de datos para mostrar las notas recuperadas por la
aplicación y, al seleccionar una nota, se navegará a NoteEntryPage donde la nota se puede modificar. Como
alternativa, se puede presionar el objeto ToolbarItem para crear una nota. Para más información sobre el
enlace de datos, vea Enlace de datos en Análisis detallado de inicio rápido de Xamarin.Forms.
Presione CTRL+S para guardar los cambios en NotesPage.xaml y cierre el archivo.
12. En NotesPage.xaml.cs , quite todo el código de plantilla y sustitúyalo por el siguiente:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Notes.Models;
namespace Notes
{
public partial class NotesPage : ContentPage
{
public NotesPage()
{
}
protected override void OnAppearing()

{
base.OnAppearing();
var notes = new List<Note>();
var files = Directory.EnumerateFiles(App.FolderPath, "*.notes.txt");

foreach (var filename in files)
{
notes.Add(new Note
{
Filename = filename,
Text = File.ReadAllText(filename),
Date = File.GetCreationTime(filename)
});
}
listView.ItemsSource = notes
.OrderBy(d => d.Date)
.ToList();
}
async void OnNoteAddedClicked(object sender, EventArgs e)

{
await Navigation.PushAsync(new NoteEntryPage
{
BindingContext = new Note()
});
}
async void OnListViewItemSelected(object sender, SelectedItemChangedEventArgs e)

{
if (e.SelectedItem != null)
{
{
BindingContext = e.SelectedItem as Note
});
}
}
}
}
Este código define la funcionalidad de NotesPage . Cuando aparece la página, se ejecuta el método
OnAppearing , que rellena el objeto ListView con las notas que se han recuperado de la carpeta de datos de
la aplicación local. Cuando se presiona ToolbarItem , se ejecuta el controlador de eventos
OnNoteAddedClicked . Este método navega hasta NoteEntryPage , y establece el elemento BindingContext de
NoteEntryPage en una instancia nueva de Note . Cuando se selecciona un elemento de ListView , se ejecuta
el controlador de eventos OnListViewItemSelected . Este método navega hasta NoteEntryPage , y establece el
elemento BindingContext de NoteEntryPage en la instancia de Note seleccionada. Para más información
sobre la navegación, vea Navegación en Análisis detallado de inicio rápido de Xamarin.Forms.
Presione CTRL+S para guardar los cambios en NotesPage.xaml.cs y cierre el archivo.
WARNING
13. En el Explorador de soluciones , haga doble clic en App.xaml.cs para abrirlo. Después, reemplace el
código existente con el siguiente:
using System;
using System.IO;
namespace Notes
{
public partial class App : Application
{
public static string FolderPath { get; private set; }
public App()
{
FolderPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
MainPage = new NavigationPage(new NotesPage());
}
// ...
}
}
Este código agrega una declaración de espacio de nombres para el espacio de nombres System.IO y una
declaración para una propiedad FolderPath estática de tipo string . La propiedad FolderPath se usa para
almacenar la ruta de acceso en el dispositivo en el que se almacenarán los datos de la nota. Además, el
código inicializa la propiedad FolderPath en el constructor App e inicializa la propiedad MainPage para
que sea un elemento NavigationPage que hospede una instancia de NotesPage . Para más información
Guarde los cambios en App.xaml.cs presionando CTRL+S y cierre el archivo.
14. En el Explorador de soluciones , en el proyecto Notes , haga clic con el botón derecho en
MainPage.xaml y seleccione Eliminar . En el cuadro de diálogo que aparece, presione el botón Aceptar
para quitar el archivo del disco duro.
Esto quita una página que ya no se usa.
15. Compile y ejecute el proyecto en cada plataforma. Para más información, vea Compilación del inicio rápido.
En NotesPage presione el botón + para ir hasta NoteEntr yPage y escriba una nota. Después de guardar
la nota, la aplicación volverá a NotesPage .
Escriba un número de notas, de longitud variable, para observar el comportamiento de la aplicación.
Actualizar la aplicación con Visual Studio para Mac

1. Inicie Visual Studio para Mac. En la ventana de inicio, haga clic en Abrir y, en el cuadro de diálogo,
seleccione el archivo de solución para el proyecto Notes:
2. En el Panel de solución , seleccione el proyecto Notes , haga clic con el botón derecho y seleccione
Agregar > Nueva carpeta :
3. En el Panel de solución , asigne el nombre Modelos a la nueva carpeta:

4. En el Panel de solución , seleccione la carpeta Modelos , haga clic con el botón derecho y seleccione
Agregar > Nuevo archivo... :
5. En el cuadro de diálogo Nuevo archivo , seleccione General > Clase vacía , asigne el nombre Note al
nuevo archivo y haga clic en el botón Nuevo :
Esto agregará una clase denominada Note a la carpeta Modelos del proyecto Notes .
6. En Note.cs , quite todo el código de plantilla y sustitúyalo por el siguiente:
using System;
{
public class Note
{
public string Filename { get; set; }
}
}
Esta clase define un modelo Note que almacenará los datos sobre cada nota en la aplicación.
Para guardar los cambios en Note.cs , seleccione Archivo > Guardar (o bien presione ⌘ + S ) y cierre el
archivo.
Agregar > Nuevo archivo . En el cuadro de diálogo Nuevo archivo , seleccione Formularios > XAML
ContentPage de Forms , asigne el nombre NoteEntr yPage al nuevo archivo, y haga clic en el botón
Nuevo :
Esto agregará una página nueva denominada NoteEntr yPage a la carpeta raíz del proyecto. Esta página
será la segunda de la aplicación.
8. En NoteEntr yPage.xaml , quite todo el código de plantilla y reemplácelo por el siguiente:

Title="Note Entry">
<StackLayout Margin="20">
<Grid>
<Button Text="Save"
Text="Delete"
</Grid>
</StackLayout>
</ContentPage>
de Editor para la entrada de texto y dos instancias de Button que dirigen la aplicación para guardar o
eliminar un archivo. Las dos instancias de Button se disponen horizontalmente en Grid , mientras que
Editor y Grid se disponen en vertical en StackLayout . Además, Editor usa el enlace de datos para
enlazar con la propiedad Text del modelo Note . Para más información sobre el enlace de datos, vea
Enlace de datos en Análisis detallado de inicio rápido de Xamarin.Forms.
Para guardar los cambios en NoteEntr yPage.xaml , seleccione Archivo > Guardar (o bien presione ⌘ +
S ) y cierre el archivo.
9. En NoteEntr yPage.xaml.cs , quite todo el código de plantilla y reemplácelo por el siguiente:
using System;
using System.IO;
using Notes.Models;
namespace Notes
{
public partial class NoteEntryPage : ContentPage
{
public NoteEntryPage()
{
}

{
if (string.IsNullOrWhiteSpace(note.Filename))
{
// Save
var filename = Path.Combine(App.FolderPath, $"{Path.GetRandomFileName()}.notes.txt");
File.WriteAllText(filename, note.Text);
}
else
{
// Update
File.WriteAllText(note.Filename, note.Text);
}
}

{
if (File.Exists(note.Filename))
{
File.Delete(note.Filename);
}
}
}
}
Este código almacena una instancia de Note , que representa una única nota, en el elemento
BindingContext de la página. Cuando se presiona el objeto Button Guardar se ejecuta el controlador de
eventos OnSaveButtonClicked , que guarda el contenido de Editor en un archivo nuevo con un nombre de
archivo generado de forma aleatoria, o bien en un archivo existente si se va a actualizar una nota. En ambos
casos, el archivo se almacena en la carpeta de datos de la aplicación local. Después, el método regresa a la
página anterior. Al pulsar el objeto Button Eliminar , se ejecuta el controlador de eventos
OnDeleteButtonClicked , que elimina el archivo, siempre que exista, y regresa a la página anterior. Para más
información sobre la navegación, vea Navegación en Análisis detallado de inicio rápido de Xamarin.Forms.
Para guardar los cambios en NoteEntr yPage.xaml.cs , seleccione Archivo > Guardar (o bien presione ⌘
+ S ) y cierre el archivo.
WARNING
Agregar > Nuevo archivo . En el cuadro de diálogo Nuevo archivo , seleccione Formularios > XAML
ContentPage de Forms , asigne el nombre NotesPage al nuevo archivo y haga clic en el botón Nuevo .
Esto agregará una página nueva denominada NotesPage a la carpeta raíz del proyecto. Esta página será la
página raíz de la aplicación.
11. En NotesPage.xaml , quite todo el código de plantilla y sustitúyalo por el siguiente:

Title="Notes">
Margin="20"
<DataTemplate>
</DataTemplate>
</ListView>
</ContentPage>
Este código define mediante declaración la interfaz de usuario de la página, que consiste en los objetos
ListView y ToolbarItem . En ListView se usa el enlace de datos para mostrar las notas recuperadas por la
aplicación y, al seleccionar una nota, se navegará a NoteEntryPage donde la nota se puede modificar. Como
alternativa, se puede presionar el objeto ToolbarItem para crear una nota. Para más información sobre el
enlace de datos, vea Enlace de datos en Análisis detallado de inicio rápido de Xamarin.Forms.
Para guardar los cambios en NotesPage.xaml , seleccione Archivo > Guardar (o bien presione ⌘ + S ) y
cierre el archivo.
12. En NotesPage.xaml.cs , quite todo el código de plantilla y sustitúyalo por el siguiente:
using System;
using System.IO;
using System.Linq;
using Notes.Models;
namespace Notes
{
public partial class NotesPage : ContentPage
{
public NotesPage()
{
}
protected override void OnAppearing()

{
base.OnAppearing();
var notes = new List<Note>();
var files = Directory.EnumerateFiles(App.FolderPath, "*.notes.txt");

foreach (var filename in files)
{
notes.Add(new Note
{
Filename = filename,
Text = File.ReadAllText(filename),
Date = File.GetCreationTime(filename)
});
}
listView.ItemsSource = notes
.OrderBy(d => d.Date)
.ToList();
}

{
{
});
}

{
{
{
});
}
}
}
}
Este código define la funcionalidad de NotesPage . Cuando aparece la página, se ejecuta el método
OnAppearing , que rellena el objeto ListView con las notas que se han recuperado de la carpeta de datos de
la aplicación local. Cuando se presiona ToolbarItem , se ejecuta el controlador de eventos
OnNoteAddedClicked . Este método navega hasta NoteEntryPage , y establece el elemento BindingContext de
NoteEntryPage en una instancia nueva de Note . Cuando se selecciona un elemento de ListView , se ejecuta
el controlador de eventos OnListViewItemSelected . Este método navega hasta NoteEntryPage , y establece el
elemento BindingContext de NoteEntryPage en la instancia de Note seleccionada. Para más información
Para guardar los cambios en NotesPage.xaml.cs , seleccione Archivo > Guardar (o bien presione ⌘ +
WARNING
13. En el Panel de solución , haga doble clic en App.xaml.cs para abrirlo. Después, reemplace el código
existente con el siguiente:
using System;
using System.IO;
namespace Notes
{
{
public static string FolderPath { get; private set; }
public App()
{
FolderPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
}
// ...
}
}
Este código agrega una declaración de espacio de nombres para el espacio de nombres System.IO y una
declaración para una propiedad FolderPath estática de tipo string . La propiedad FolderPath se usa para
almacenar la ruta de acceso en el dispositivo en el que se almacenarán los datos de la nota. Además, el
código inicializa la propiedad FolderPath en el constructor App e inicializa la propiedad MainPage para
que sea un elemento NavigationPage que hospede una instancia de NotesPage . Para más información
Guarde los cambios en App.xaml.cs eligiendo Archivo > Guardar (o presionando ⌘ + S ) y cierre el
archivo.
14. En el Panel de solución , en el proyecto Notes , haga clic con el botón derecho en MainPage.xaml y
seleccione Quitar . En el cuadro de diálogo que aparece, presione el botón Eliminar para quitar el archivo
del disco duro.
Esto quita una página que ya no se usa.
Pasos siguientes
Agregar páginas adicionales a una solución de Xamarin.Forms.
Realizar la navegación entre las páginas.
Usar el enlace de datos para sincronizar datos entre los elementos de la interfaz de usuario y su origen de
datos.
Para modificar la aplicación de modo que almacene sus datos en una base de datos de SQLite.NET local, continúe
con el inicio rápido siguiente.
Siguiente
Notes (ejemplo)
Almacenamiento de datos en una base de datos de
SQLite.NET local
Usar el Administrador de paquetes de NuGet para agregar un paquete NuGet a un proyecto.
Almacenar datos de forma local en una base de datos de SQLite.NET.
En el inicio rápido se le guía sobre cómo almacenar datos en una base de datos de SQLite.NET local. A
continuación se muestra la aplicación final:
Requisitos previos

1. Inicie Visual Studio y abra la solución Notes.
2. En el Explorador de soluciones , seleccione el proyecto Notes , haga clic con el botón derecho y, después,
seleccione Administrar paquetes NuGet… :
3. En el Administrador de paquetes NuGet , seleccione la pestaña Examinar , busque el paquete NuGet
sqlite-net-pcl , selecciónelo y haga clic en el botón Instalar para agregarlo al proyecto:
NOTE
Hay varios paquetes NuGet con nombres similares. El paquete correcto tiene estos atributos:
Autores: Frank A. Krueger
Id.: sqlite-net-pcl
Vínculo de NuGet: sqlite-net-pcl
A pesar del nombre del paquete, este paquete NuGet puede usarse en proyectos de .NET Standard.
Este paquete se usará para incorporar operaciones de bases de datos en la aplicación.

4. En el Explorador de soluciones , en el proyecto Notes , abra Note.cs en la carpeta Modelos y reemplace
el código existente por el siguiente:
using System;
using SQLite;
{
public class Note
{
[PrimaryKey, AutoIncrement]
public int ID { get; set; }
}
}
Esta clase define un modelo Note que almacenará los datos sobre cada nota en la aplicación. La propiedad
ID está marcada con los atributos PrimaryKey y AutoIncrement para garantizar que cada instancia de
Note en la base de datos de SQLite.NET tenga un identificador único proporcionado por SQLite.NET.
Presione CTRL+S para guardar los cambios en Note.cs y cierre el archivo.
WARNING
5. En el Explorador de soluciones , agregue una nueva carpeta denominada Datos al proyecto Notes .
6. En el Explorador de soluciones , en el proyecto Notes , agregue una nueva clase denominada
NoteDatabase a la carpeta Datos .
7. En NoteDatabase.cs , reemplace el código existente con el siguiente:
using System.Threading.Tasks;
using SQLite;
using Notes.Models;
namespace Notes.Data
{
public class NoteDatabase
{
readonly SQLiteAsyncConnection _database;
public NoteDatabase(string dbPath)

{
_database = new SQLiteAsyncConnection(dbPath);
_database.CreateTableAsync<Note>().Wait();
}
public Task<List<Note>> GetNotesAsync()

{
return _database.Table<Note>().ToListAsync();
}
public Task<Note> GetNoteAsync(int id)

{
return _database.Table<Note>()
.Where(i => i.ID == id)
.FirstOrDefaultAsync();
}
public Task<int> SaveNoteAsync(Note note)

{
if (note.ID != 0)
{
return _database.UpdateAsync(note);
}
else
{
return _database.InsertAsync(note);
}
}
public Task<int> DeleteNoteAsync(Note note)

{
return _database.DeleteAsync(note);
}
}
}
Esta clase contiene código para crear la base de datos, leer datos de ella, escribir datos en ella y eliminarlos.
El código usa API asincrónicas de SQLite.NET que mueven las operaciones de base de datos a subprocesos
en segundo plano. Además, el constructor NoteDatabase toma la ruta de acceso del archivo de base de
datos como un argumento. La clase App proporcionará esta ruta de acceso en el paso siguiente.
Presione CTRL+S para guardar los cambios en NoteDatabase.cs y cierre el archivo.
WARNING
8. En el Explorador de soluciones , en el proyecto Notes , haga doble clic en App.xaml.cs para abrirlo.
Después, reemplace el código existente con el siguiente:
using System;
using System.IO;
using Notes.Data;
namespace Notes
{
{
static NoteDatabase database;
public static NoteDatabase Database

{
get
{
if (database == null)
{
database = new
NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Notes.db3"));
}
return database;
}
}
public App()
{
}
protected override void OnStart()

{
// Handle when your app starts
}
protected override void OnSleep()

{
// Handle when your app sleeps
}
protected override void OnResume()

{
// Handle when your app resumes
}
}
}
Este código define una propiedad Database que crea una instancia de NoteDatabase como singleton, y pasa
el nombre de archivo de la base de datos como argumento al constructor NoteDatabase . La ventaja de
exponer la base de datos como un singleton es que se crea una conexión de base de datos única que se
mantiene abierta mientras la aplicación se ejecuta, lo que evita el gasto de abrir y cerrar el archivo de base
de datos cada vez que se realiza una operación de base de datos.
Guarde los cambios en App.xaml.cs presionando CTRL+S y cierre el archivo.
WARNING
9. En el Explorador de soluciones , en el proyecto Notes , haga doble clic en NotesPage.xaml.cs para

abrirlo. Después, reemplace el método OnAppearing con el código siguiente:
protected override async void OnAppearing()
{
base.OnAppearing();
listView.ItemsSource = await App.Database.GetNotesAsync();

}
Este código rellena el elemento ListView con todas las notas almacenadas en la base de datos.
Presione CTRL+S para guardar los cambios en NotesPage.xaml.cs y cierre el archivo.
WARNING
10. En el Explorador de soluciones , haga doble clic en NoteEntr yPage.xaml.cs para abrirlo. Después,
reemplace los métodos OnSaveButtonClicked y OnDeleteButtonClicked con el código siguiente:

{
note.Date = DateTime.UtcNow;
await App.Database.SaveNoteAsync(note);
}

{
await App.Database.DeleteNoteAsync(note);
}
NoteEntryPage almacena una instancia de Note , que representa una única nota, en el objeto
BindingContext de la página. Cuando se ejecuta el controlador de eventos OnSaveButtonClicked , la instancia
de Note se guarda en la base de datos y la aplicación regresa a la página anterior. Cuando se ejecuta el
controlador de eventos OnDeleteButtonClicked , la instancia de Note se elimina de la base de datos y la
aplicación regresa a la página anterior.
Presione CTRL+S para guardar los cambios en NoteEntr yPage.xaml.cs y cierre el archivo.

1. Inicie Visual Studio para Mac y abra el proyecto Notes.
Agregar > Agregar paquetes NuGet... :
3. En la ventana Agregar paquetes , busque el paquete NuGet sqlite-net-pcl , selecciónelo y haga clic en el
botón Agregar paquete para agregarlo al proyecto:
NOTE
Hay varios paquetes NuGet con nombres similares. El paquete correcto tiene estos atributos:
Autor : Frank A. Krueger
Id.: sqlite-net-pcl
Vínculo de NuGet: sqlite-net-pcl
A pesar del nombre del paquete, este paquete NuGet puede usarse en proyectos de .NET Standard.
Este paquete se usará para incorporar operaciones de bases de datos en la aplicación.

4. En el Panel de solución , en el proyecto Notes , abra Note.cs en la carpeta Modelos y reemplace el
código existente por el siguiente:
using System;
using SQLite;
{
public class Note
{
[PrimaryKey, AutoIncrement]
public int ID { get; set; }
}
}
Esta clase define un modelo Note que almacenará los datos sobre cada nota en la aplicación. La propiedad
ID está marcada con los atributos PrimaryKey y AutoIncrement para garantizar que cada instancia de
Note en la base de datos de SQLite.NET tenga un identificador único proporcionado por SQLite.NET.
Para guardar los cambios en Note.cs , seleccione Archivo > Guardar (o bien presione ⌘ + S ) y cierre el
archivo.
WARNING
5. En el Panel de solución , agregue una nueva carpeta denominada Datos al proyecto Notes .
6. En el Panel de solución , en el proyecto Notes , agregue una nueva clase denominada NoteDatabase a la
carpeta Datos .
7. En NoteDatabase.cs , reemplace el código existente con el siguiente:
using SQLite;
using Notes.Models;
namespace Notes.Data
{
public class NoteDatabase
{
readonly SQLiteAsyncConnection _database;
public NoteDatabase(string dbPath)

{
_database = new SQLiteAsyncConnection(dbPath);
_database.CreateTableAsync<Note>().Wait();
}
public Task<List<Note>> GetNotesAsync()

{
return _database.Table<Note>().ToListAsync();
}
public Task<Note> GetNoteAsync(int id)

{
return _database.Table<Note>()
.Where(i => i.ID == id)
.FirstOrDefaultAsync();
}
public Task<int> SaveNoteAsync(Note note)

{
if (note.ID != 0)
{
return _database.UpdateAsync(note);
}
else
{
return _database.InsertAsync(note);
}
}
public Task<int> DeleteNoteAsync(Note note)

{
return _database.DeleteAsync(note);
}
}
}
Esta clase contiene código para crear la base de datos, leer datos de ella, escribir datos en ella y eliminarlos.
El código usa API asincrónicas de SQLite.NET que mueven las operaciones de base de datos a subprocesos
en segundo plano. Además, el constructor NoteDatabase toma la ruta de acceso del archivo de base de
datos como un argumento. La clase App proporcionará esta ruta de acceso en el paso siguiente.
Para guardar los cambios en NoteDatabase.cs , seleccione Archivo > Guardar (o bien presione ⌘ + S ) y
cierre el archivo.
WARNING
8. En el Panel de solución , en el proyecto Notes , haga doble clic en App.xaml.cs para abrirlo. Después,
reemplace el código existente con el siguiente:
using System;
using System.IO;
using Notes.Data;
namespace Notes
{
{
static NoteDatabase database;
public static NoteDatabase Database

{
get
{
if (database == null)
{
database = new
NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"Notes.db3"));
}
return database;
}
}
public App()
{
}
protected override void OnStart()

{
// Handle when your app starts
}
protected override void OnSleep()

{
// Handle when your app sleeps
}
protected override void OnResume()

{
// Handle when your app resumes
}
}
}
Este código define una propiedad Database que crea una instancia de NoteDatabase como singleton, y pasa
el nombre de archivo de la base de datos como argumento al constructor NoteDatabase . La ventaja de
exponer la base de datos como un singleton es que se crea una conexión de base de datos única que se
mantiene abierta mientras la aplicación se ejecuta, lo que evita el gasto de abrir y cerrar el archivo de base
de datos cada vez que se realiza una operación de base de datos.
Guarde los cambios en App.xaml.cs eligiendo Archivo > Guardar (o presionando ⌘ + S ) y cierre el
archivo.
WARNING
9. En el Panel de solución , en el proyecto Notes , haga doble clic en NotesPage.xaml.cs para abrirlo.
Después, reemplace el método OnAppearing con el código siguiente:

{
base.OnAppearing();

}
Para guardar los cambios en NotesPage.xaml.cs , seleccione Archivo > Guardar (o bien presione ⌘ +
WARNING
10. En el Panel de solución , haga doble clic en NoteEntr yPage.xaml.cs para abrirlo. Después, reemplace los
métodos OnSaveButtonClicked y OnDeleteButtonClicked con el código siguiente:

{
}

{
await App.Database.DeleteNoteAsync(note);
}
NoteEntryPage almacena una instancia de Note , que representa una única nota, en el objeto
BindingContext de la página. Cuando se ejecuta el controlador de eventos OnSaveButtonClicked , la instancia
de Note se guarda en la base de datos y la aplicación regresa a la página anterior. Cuando se ejecuta el
controlador de eventos OnDeleteButtonClicked , la instancia de Note se elimina de la base de datos y la
aplicación regresa a la página anterior.
Para guardar los cambios en NoteEntr yPage.xaml.cs , seleccione Archivo > Guardar (o bien presione ⌘
+ S ) y cierre el archivo.
Pasos siguientes
Usar el Administrador de paquetes de NuGet para agregar un paquete NuGet a un proyecto.
Almacenar datos de forma local en una base de datos de SQLite.NET.
Para aplicar estilo a la aplicación con estilos XAML, continúe con el inicio rápido siguiente.
Siguiente
Notes (ejemplo)
Estilo de una aplicación Xamarin.Forms
multiplataforma
Aplicar estilo a una aplicación Xamarin.Forms mediante estilos XAML.
En el inicio rápido se describe cómo aplicar estilo a una aplicación Xamarin.Forms multiplataforma con estilos
XAML. A continuación se muestra la aplicación final:
Requisitos previos

1. Inicie Visual Studio y abra la solución Notes.
2. En el Explorador de soluciones , en el proyecto Notes , haga doble clic en App.xaml para abrirlo.
<Application xmlns="http://xamarin.com/schemas/2014/forms"
x:Class="Notes.App">
<Application.Resources>
<Thickness x:Key="PageMargin">20</Thickness>


<Color x:Key="AppBackgroundColor">AliceBlue</Color>
<Color x:Key="NavigationBarColor">#1976D2</Color>
<Color x:Key="NavigationBarTextColor">White</Color>


<Style TargetType="{x:Type NavigationPage}">
<Setter Property="BarBackgroundColor"
Value="{StaticResource NavigationBarColor}" />
<Setter Property="BarTextColor"
Value="{StaticResource NavigationBarTextColor}" />
</Style>
<Style TargetType="{x:Type ContentPage}"

ApplyToDerivedTypes="True">
<Setter Property="BackgroundColor"
Value="{StaticResource AppBackgroundColor}" />
</Style>
</Application.Resources>
</Application>
En este código se define un valor Thickness , una serie de valores Color y estilos implícitos para los
objetos NavigationPage y ContentPage . Tenga en cuenta que estos estilos, que están en el objeto
ResourceDictionary de nivel de aplicación, se pueden consumir en toda la aplicación. Para más información
sobre los estilos XAML, vea Aplicación de estilos en Análisis detallado de inicio rápido de Xamarin.Forms.
Presione CTRL+S para guardar los cambios en App.xaml y cierre el archivo.
3. En el Explorador de soluciones , en el proyecto Notes , haga doble clic en NotesPage.xaml para abrirlo.
Title="Notes">
<ContentPage.Resources>
<Style TargetType="{x:Type ListView}">
</Style>
</ContentPage.Resources>
Margin="{StaticResource PageMargin}"
<DataTemplate>
TextColor="Black"
</DataTemplate>
</ListView>
</ContentPage>
Este código agrega un estilo implícito para ListView al objeto ResourceDictionary de nivel de página, y
establece la propiedad ListView.Margin en un valor definido en el objeto ResourceDictionary de nivel de la
aplicación. Tenga en cuenta que el estilo implícito ListView se ha agregado al objeto ResourceDictionary
de nivel de página, porque solo lo usa NotesPage . Para más información sobre los estilos XAML, vea
Aplicación de estilos en Análisis detallado de inicio rápido de Xamarin.Forms.
Presione CTRL+S para guardar los cambios en NotesPage.xaml y cierre el archivo.
4. En el Explorador de soluciones , en el proyecto Notes , haga doble clic en NoteEntr yPage.xaml para
abrirlo. Después, reemplace el código existente con el siguiente:
Title="Note Entry">
<Style TargetType="{x:Type Editor}">
</Style>
<Style TargetType="Button"
ApplyToDerivedTypes="True"
CanCascade="True">
<Setter Property="FontSize" Value="Medium" />
<Setter Property="BackgroundColor" Value="#1976D2" />
<Setter Property="TextColor" Value="White" />
<Setter Property="CornerRadius" Value="5" />
</Style>
<StackLayout Margin="{StaticResource PageMargin}">

<Grid>
<Button Text="Save"
Text="Delete"
Clicked="OnDeleteButtonClicked" />
</Grid>
</StackLayout>
</ContentPage>
Este código agrega estilos implícitos para las vistas Editor y Button al objeto ResourceDictionary de nivel
de página, y establece la propiedad StackLayout.Margin en un valor definido en el objeto
ResourceDictionary de nivel de la aplicación. Tenga en cuenta que los estilos implícitos Editor y Button
sen ha agregado al objeto ResourceDictionary de nivel de página, porque solo los usa NoteEntryPage . Para
más información sobre los estilos XAML, vea Aplicación de estilos en Análisis detallado de inicio rápido de
Xamarin.Forms.
Presione CTRL+S para guardar los cambios en NoteEntr yPage.xaml y cierre el archivo.
En NotesPage presione el botón + para ir hasta NoteEntr yPage y escriba una nota. En cada página,
observe cómo ha cambiado el estilo con respecto al inicio rápido anterior.

1. Inicie Visual Studio para Mac y abra el proyecto Notes.
2. En el Panel de solución , en el proyecto Notes , haga doble clic en App.xaml para abrirlo. Después,
<Thickness x:Key="PageMargin">20</Thickness>


<Color x:Key="AppBackgroundColor">AliceBlue</Color>
<Color x:Key="NavigationBarColor">#1976D2</Color>
<Color x:Key="NavigationBarTextColor">White</Color>

Value="{StaticResource NavigationBarColor}" />
Value="{StaticResource NavigationBarTextColor}" />
</Style>
<Style TargetType="{x:Type ContentPage}"

ApplyToDerivedTypes="True">
</Style>
</Application>
En este código se define un valor Thickness , una serie de valores Color y estilos implícitos para los
objetos NavigationPage y ContentPage . Tenga en cuenta que estos estilos, que están en el objeto
ResourceDictionary de nivel de aplicación, se pueden consumir en toda la aplicación. Para más información
sobre los estilos XAML, vea Aplicación de estilos en Análisis detallado de inicio rápido de Xamarin.Forms.
Para guardar los cambios en App.xaml , seleccione Archivo > Guardar (o presione ⌘ + S ) y cierre el
archivo.
3. En el Panel de solución , en el proyecto Notes , haga doble clic en NotesPage.xaml para abrirlo. Después,
Title="Notes">
<Style TargetType="{x:Type ListView}">
</Style>
<DataTemplate>
TextColor="Black"
</DataTemplate>
</ListView>
</ContentPage>
Este código agrega un estilo implícito para ListView al objeto ResourceDictionary de nivel de página, y
establece la propiedad ListView.Margin en un valor definido en el objeto ResourceDictionary de nivel de la
aplicación. Tenga en cuenta que el estilo implícito ListView se ha agregado al objeto ResourceDictionary
de nivel de página, porque solo lo usa NotesPage . Para más información sobre los estilos XAML, vea
Aplicación de estilos en Análisis detallado de inicio rápido de Xamarin.Forms.
Para guardar los cambios en NotesPage.xaml , seleccione Archivo > Guardar (o bien presione ⌘ + S ) y
cierre el archivo.
4. En el Panel de solución , en el proyecto Notes , haga doble clic en NoteEntr yPage.xaml para abrirlo.
Title="Note Entry">
</Style>
<Style TargetType="Button"
ApplyToDerivedTypes="True"
CanCascade="True">
<Setter Property="FontSize" Value="Medium" />
<Setter Property="BackgroundColor" Value="#1976D2" />
<Setter Property="TextColor" Value="White" />
<Setter Property="CornerRadius" Value="5" />
</Style>

<Grid>
<Button Text="Save"
Text="Delete"
Clicked="OnDeleteButtonClicked" />
</Grid>
</StackLayout>
</ContentPage>
Este código agrega estilos implícitos para las vistas Editor y Button al objeto ResourceDictionary de nivel
de página, y establece la propiedad StackLayout.Margin en un valor definido en el objeto
ResourceDictionary de nivel de la aplicación. Tenga en cuenta que los estilos implícitos Editor y Button
sen ha agregado al objeto ResourceDictionary de nivel de página, porque solo los usa NoteEntryPage . Para
más información sobre los estilos XAML, vea Aplicación de estilos en Análisis detallado de inicio rápido de
Xamarin.Forms.
Para guardar los cambios en NoteEntr yPage.xaml , seleccione Archivo > Guardar (o bien presione ⌘ +
En NotesPage presione el botón + para ir hasta NoteEntr yPage y escriba una nota. En cada página,
observe cómo ha cambiado el estilo con respecto al inicio rápido anterior.
Pasos siguientes
Aplicar estilo a una aplicación Xamarin.Forms mediante estilos XAML.
Para obtener más información sobre los aspectos básicos del desarrollo de aplicaciones con Xamarin.Forms,
continúe con el análisis detallado de inicio rápido.
Siguiente
Notes (ejemplo)
Análisis detallado de inicio rápido de
Xamarin.Forms
En Inicio rápido de Xamarin.Forms se ha creado la aplicación Notes. En este artículo se revisa lo

que se ha compilado para comprender los aspectos fundamentales del funcionamiento de las
aplicaciones de Xamarin.Forms.
Introducción a Visual Studio

Visual Studio organiza el código en soluciones y proyectos. Una solución es un contenedor que
puede incluir uno o varios proyectos. Un proyecto puede ser una aplicación, una biblioteca
auxiliar o una aplicación de prueba, entre otros. La aplicación Notes consta de una solución que
contiene cuatro proyectos, como se muestra en la captura de pantalla siguiente:
Los proyectos son:

Notes: este proyecto es el de la biblioteca de .NET Standard que incluye todo el código
compartido y la interfaz de usuario compartida.
Notes.Android: este proyecto incluye el código específico de Android y es el punto de entrada
de la aplicación Android.
Notes.iOS: este proyecto incluye el código específico de iOS y es el punto de entrada de la
aplicación iOS.
Notes.UWP: este proyecto incluye el código específico de Plataforma universal de Windows
(UWP) y es el punto de entrada de la aplicación para UWP.
Anatomía de una aplicación de Xamarin.Forms

En la captura de pantalla siguiente se muestra el contenido del proyecto de biblioteca de .NET
Standard Notes en Visual Studio:
El proyecto tiene un nodo Dependencias que contiene los nodos NuGet y SDK :
NuGet : los paquetes NuGet Xamarin.Forms y sqlite-net-pcl que se han agregado al proyecto.
SDK : el metapaquete NETStandard.Library que hace referencia al conjunto completo de
paquetes NuGet que definen .NET Standard.
Introducción a Visual Studio para Mac

Visual Studio para Mac sigue la práctica de Visual Studio consistente en organizar el código en
soluciones y proyectos. Una solución es un contenedor que puede incluir uno o varios proyectos.
Un proyecto puede ser una aplicación, una biblioteca auxiliar o una aplicación de prueba, entre
otros. La aplicación Notes consta de una solución que contiene tres proyectos, como se muestra
en la captura de pantalla siguiente:
Los proyectos son:

Notes: este proyecto es el de la biblioteca de .NET Standard que incluye todo el código
compartido y la interfaz de usuario compartida.
Notes.Android: este proyecto incluye el código específico de Android y es el punto de entrada
de las aplicaciones Android.
Notes.iOS: este proyecto incluye el código específico de iOS y es el punto de entrada de las
aplicaciones iOS.
Anatomía de una aplicación de Xamarin.Forms

En la captura de pantalla siguiente se muestra el contenido del proyecto de biblioteca de .NET
Standard Notes en Visual Studio para Mac:
El proyecto tiene un nodo Dependencias que contiene los nodos NuGet y SDK :
NuGet : los paquetes NuGet Xamarin.Forms y sqlite-net-pcl que se han agregado al proyecto.
SDK : el metapaquete NETStandard.Library que hace referencia al conjunto completo de
paquetes NuGet que definen .NET Standard.
El proyecto también consta de varios archivos:
Data\NoteDatabase.cs : esta clase contiene código para crear la base de datos, leer datos de
ella, escribir datos en ella y eliminarlos.
Models\Note.cs : esta clase define un modelo Note cuyas instancias almacenarán datos
sobre cada nota en la aplicación.
App.xaml : el marcado XAML para la clase App , que define un diccionario de recursos para la
aplicación.
App.xaml.cs : el código subyacente para la clase App , que es el responsable de crear
instancias de la primera página que se mostrarán mediante la aplicación en cada plataforma, y
para controlar los eventos del ciclo de vida de la aplicación.
AssemblyInfo.cs : este archivo contiene un atributo de aplicación sobre el proyecto, que se
aplica en el nivel de ensamblado.
NotesPage.xaml : el marcado XAML para la clase NotesPage , que define la interfaz de usuario
para la página que se muestra al iniciar la aplicación.
NotesPage.xaml.cs : el código subyacente para la clase NotesPage , que contiene la lógica de
negocios que se ejecuta cuando el usuario interactúa con la página.
NoteEntr yPage.xaml : el marcado XAML para la clase NoteEntryPage , que define la interfaz
de usuario para la página que se muestra cuando el usuario escribe una nota.
NoteEntr yPage.xaml.cs : el código subyacente para la clase NoteEntryPage , que contiene la
lógica de negocios que se ejecuta cuando el usuario interactúa con la página.
Para obtener más información sobre la anatomía de una aplicación de Xamarin.iOS, consulte
Anatomía de una aplicación de Xamarin.iOS. Para obtener más información sobre la anatomía de
una aplicación de Xamarin.Android, consulte Anatomía de una aplicación de Xamarin.Android.
Arquitectura y aspectos básicos de la aplicación

Una aplicación de Xamarin.Forms tiene la misma arquitectura que una aplicación
multiplataforma tradicional. El código compartido normalmente se coloca en una biblioteca de
.NET Standard, y las aplicaciones específicas de la plataforma consumen el código compartido. En
el diagrama siguiente se muestra información general de esta relación para la aplicación Notes:
Para maximizar la reutilización del código de inicio, las aplicaciones de Xamarin.Forms tienen una
clase única denominada App que es responsable de crear instancias de la primera página que
mostrará la aplicación en cada plataforma, como se muestra en el siguiente ejemplo de código:
namespace Notes
{
{
public App()
{
}
...
}
}
En este código se establece la propiedad MainPage de la clase App en una instancia de

NavigationPage cuyo contenido es una instancia de NotesPage .
Además, el archivo AssemblyInfo.cs contiene un único atributo de aplicación, que se aplica en

el nivel de ensamblado:
using Xamarin.Forms.Xaml;
[assembly: XamlCompilation(XamlCompilationOptions.Compile)]
El atributo XamlCompilation activa el compilador XAML, para que XAML se compile directamente
en lenguaje intermedio. Para obtener más información, consulte Compilación XAML.
Inicio de la aplicación en cada plataforma

iOS
Para abrir la página inicial de Xamarin.Forms en iOS, en el proyecto Notes.iOS se define la clase
AppDelegate , que hereda de la clase FormsApplicationDelegate :
namespace Notes.iOS
{
[Register("AppDelegate")]
public partial class AppDelegate :
global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate
{
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
global::Xamarin.Forms.Forms.Init();
LoadApplication(new App());
return base.FinishedLaunching(app, options);
}
}
}
El reemplazo FinishedLaunching inicializa el marco de Xamarin.Forms mediante una llamada al

método Init . Esto provoca que la implementación específica de iOS de Xamarin.Forms se
cargue en la aplicación antes de que se establezca el controlador de vista raíz mediante la
llamada al método LoadApplication .
Android
Para iniciar la página de inicio de Xamarin.Forms en Android, el proyecto Notes.Droid incluye
código para crear un elemento Activity con el atributo MainLauncher , y la actividad se hereda
de la clase FormsAppCompatActivity :
namespace Notes.Droid
{
[Activity(Label = "Notes",
Icon = "@mipmap/icon",
Theme = "@style/MainTheme",
MainLauncher = true,
ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
{
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(savedInstanceState);
global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
LoadApplication(new App());
}
}
}
El reemplazo OnCreate inicializa el marco de Xamarin.Forms mediante una llamada al método

Init . Esto provoca que la implementación específica de Android de Xamarin.Forms se cargue en
la aplicación antes de que lo haga la aplicación de Xamarin.Forms.
Plataforma universal de Windows
En las aplicaciones de plataforma universal de Windows (UWP), el método Init que inicializa el
marco de Xamarin.Forms se invoca desde la clase App :
Xamarin.Forms.Forms.Init (e);
if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
{
...
}
Esto provoca que la implementación específica de UWP de Xamarin.Forms se cargue en la

aplicación. La página inicial de Xamarin.Forms se inicia mediante la clase MainPage :
namespace Notes.UWP
{
public sealed partial class MainPage
{
public MainPage()
{
this.InitializeComponent();
this.LoadApplication(new Notes.App());
}
}
}
La aplicación de Xamarin.Forms se carga con el método LoadApplication .

NOTE
Las aplicaciones para la Plataforma universal de Windows se pueden compilar con Xamarin.Forms, pero
solo mediante Visual Studio en Windows.
Interfaz de usuario
Existen cuatro grupos de controles principales que se usan para crear la interfaz de usuario de
una aplicación Xamarin.Forms:
1. Páginas : las páginas de Xamarin.Forms representan pantallas de aplicaciones móviles
multiplataforma. En la aplicación Notes se usa la clase ContentPage para mostrar pantallas
únicas. Para obtener más información sobre las páginas, consulte Xamarin.Forms Pages
(Páginas de Xamarin.Forms).
2. Vistas : las vistas de Xamarin.Forms son los controles que se muestran en la interfaz de
usuario, como etiquetas, botones y cuadros de entrada de texto. En la aplicación Notes
terminada se usan las vistas ListView , Editor y Button . Para obtener más información
sobre las vistas, consulte Xamarin.Forms Views (Vistas de Xamarin.Forms).
3. Diseños : los diseños de Xamarin.Forms son contenedores que se usan para crear vistas en
estructuras lógicas. En la aplicación Notes se usa la clase StackLayout para organizar las
vistas en una pila vertical y la clase Grid para organizar los botones de forma horizontal.
Para obtener más información sobre los diseños, consulte Xamarin.Forms Layouts (Diseños de
Xamarin.Forms).
4. Celdas : las celdas de Xamarin.Forms son elementos especializados que se usan para los
elementos de una lista, y describen cómo debe dibujarse cada elemento de una lista. En la
aplicación Notes se usa TextCell para mostrar dos elementos para cada fila de la lista. Para
obtener más información sobre las celdas, consulte Xamarin.Forms Cells (Celdas de
Xamarin.Forms).
En tiempo de ejecución, cada control se asignará a su equivalente nativo, que es lo que se
representará.
Diseño
En la aplicación Notes se usa StackLayout para simplificar el desarrollo de aplicaciones
multiplataforma mediante la disposición automática de las vistas en la pantalla,
independientemente del tamaño de esta. Cada elemento secundario se coloca uno detrás del
otro, ya sea horizontal o verticalmente, en el orden en el que se ha agregado. La cantidad de
espacio que usará la clase StackLayout depende de cómo se establezcan las propiedades
HorizontalOptions y VerticalOptions , pero StackLayout intentará usar toda la pantalla de
forma predeterminada.
En el código XAML siguiente se muestra un ejemplo de uso de una clase StackLayout para
organizar el control NoteEntryPage :
Title="Note Entry">
...
<Grid>
...
</Grid>
</StackLayout>
</ContentPage>
De forma predeterminada, StackLayout asume una orientación vertical. Pero se puede cambiar a
una orientación horizontal si se establece la propiedad StackLayout.Orientation en el miembro
de enumeración StackOrientation.Horizontal .
NOTE
El tamaño de las vistas se puede establecer a través de las propiedades HeightRequest y
WidthRequest .
Para obtener más información sobre la clase StackLayout , consulte StackLayout.

Responder a la interacción del usuario
Un objeto que se ha definido en XAML puede desencadenar un evento que se controla en el
archivo de código subyacente. En el ejemplo de código siguiente se muestra el método
OnSaveButtonClicked del código subyacente de la clase NoteEntryPage , que se ejecuta en
respuesta al evento Clicked que se desencadena en el botón Guardar.

{
}
El método OnSaveButtonClicked guarda la nota en la base de datos y regresa a la página anterior.
NOTE
El archivo de código subyacente de una clase XAML puede tener acceso a un objeto que se ha definido
en XAML con el nombre asignado a él con el atributo x:Name . El valor que se ha asignado a este
atributo tiene las mismas reglas que las variables de C#, ya que debe comenzar con una letra o guion
bajo y no contener espacios incrustados.
La conexión del botón Guardar con el método OnSaveButtonClicked se realiza en el marcado

XAML de la clase NoteEntryPage :
<Button Text="Save"
Listas
ListView es responsable de mostrar una colección de elementos de forma vertical en una lista.
Cada elemento de ListView se incluirá en una sola celda.
En el ejemplo de código siguiente se muestra el elemento ListView de NotesPage :
<DataTemplate>
</DataTemplate>
</ListView>
El diseño de cada fila de ListView se define dentro del elemento ListView.ItemTemplate y se usa
el enlace de datos para mostrar las notas recuperadas por la aplicación. La propiedad
ListView.ItemsSource está establecida en el origen de datos, en NotesPage.xaml.cs :

{
base.OnAppearing();

}
Cuando se selecciona una fila en ListView , se desencadena el evento ItemSelected . Cuando se
desencadena el evento, se ejecuta un controlador de eventos denominado
OnListViewItemSelected :

{
{
...
}
}
El evento ItemSelected puede acceder al objeto asociado a la celda a través de la propiedad

e.SelectedItem .
Para más información sobre la clase ListView , vea ListView.
Navegación
Xamarin.Forms proporciona una serie de experiencias de navegación de páginas diferente, en
función del tipo de Page que se use. Para las instancias de ContentPage , la navegación puede ser
jerárquica o modal. Para obtener información sobre la navegación modal, vea Páginas modales
de Xamarin.Forms.
NOTE
Las clases CarouselPage , MasterDetailPage y TabbedPage proporcionan experiencias de navegación
alternativas. Para obtener más información, consulte Navigation (Navegación).
En la navegación jerárquica, se usa la clase NavigationPage para navegar por una pila de objetos
ContentPage , hacia delante y atrás, como se prefiera. La clase implementa la navegación como
una pila de objetos Page en la que el último en entrar es el primero en salir (LIFO). Para pasar de
una página a otra, una aplicación insertará una nueva página en la pila de navegación, donde se
convertirá en la página activa. Para volver a la página anterior, la aplicación mostrará la página
actual de la pila de navegación y la nueva página de nivel superior se convertirá en la página
activa.
La clase NavigationPage también agregará una barra de navegación en la parte superior de la
página que muestra un título y un botón Atrás adecuado para la plataforma para volver a la
página anterior.
La primera página que se agrega a una pila de navegación se denomina página raíz de la
aplicación y, en el ejemplo de código siguiente, se muestra cómo se consigue esto en la
aplicación Notes:
public App ()
{
...
MainPage = new NavigationPage (new NotesPage ());
}
Todas las instancias ContentPage tienen una propiedad Navigation que expone métodos para
modificar la pila de la página. Solo se deberían invocar estos métodos si la aplicación incluye una
NavigationPage . Para navegar a la NoteEntryPage , es necesario invocar el método PushAsync
como se muestra en el ejemplo de código siguiente:
await Navigation.PushAsync(new NoteEntryPage());
Esto hace que el nuevo objeto NoteEntryPage se inserte en la pila de navegación, donde se
convierte en la página activa.
La página activa se puede extraer de la pila de navegación. Para ello, pulse el botón Atrás del
dispositivo, independientemente de si se trata de un botón físico en el dispositivo o de un botón
en la pantalla. Para volver mediante programación a la página original, el objeto NoteEntryPage
debe invocar el método PopAsync , como se muestra en el ejemplo de código siguiente:
Para obtener más información sobre la navegación jerárquica, consulte Hierarchical Navigation
(Navegación jerárquica).
Enlace de datos
El enlace de datos se usa para simplificar la forma en que una aplicación de Xamarin.Forms
muestra e interactúa con sus datos. Establece una conexión entre la interfaz de usuario y la
aplicación subyacente. La clase BindableObject contiene gran parte de la infraestructura para
admitir el enlace de datos.
El enlace de datos conecta dos objetos, denominados origen y destino. El objeto de origen
proporciona los datos. El objeto de destino usa (y, a menudo, muestra) los datos del objeto de
origen. Por ejemplo, un control Editor (objeto de destino) normalmente enlazará su propiedad
Text a una propiedad string pública en un objeto de origen. En el diagrama siguiente se
muestra la relación de enlace:
El principal beneficio del enlace de datos es que ya no tiene que preocuparse de sincronizar los
datos entre las vistas y el origen de datos. Los cambios en el objeto de origen se insertan
automáticamente en el objeto de destino en segundo plano por medio del marco de enlace,
mientras que los cambios en el objeto de destino pueden insertarse de manera opcional en el
objeto de origen.
El establecimiento del enlace de datos es un proceso de dos pasos:
La propiedad BindingContext del objeto de destino se debe establecer en el de origen.
Es necesario establecer un enlace entre el destino y el origen. En XAML, esto se consigue
mediante la extensión de marcado Binding .
En la aplicación Notes, el destino de enlace es el elemento Editor que muestra una nota,
mientras que la instancia de Note establecida como BindingContext de NoteEntryPage es el
origen de enlace.
El objeto BindingContext de NoteEntryPage se establece durante la navegación de la página,
como se muestra en el ejemplo de código siguiente:

{
{
});
}

{
{
{
});
}
}
En el método OnNoteAddedClicked , que se ejecuta cuando se agrega una nueva nota a la

aplicación, el objeto BindingContext de NoteEntryPage se establece en una nueva instancia de
Note . En el método OnListViewItemSelected , que se ejecuta cuando se selecciona una nota
existente en el elemento ListView , el objeto BindingContext de NoteEntryPage se establece en la
instancia de Note seleccionada, a la que se accede a través de la propiedad e.SelectedItem .
IMPORTANT
Aunque la propiedad BindingContext de cada objeto de destino se puede establecer de manera
individual, no es necesario hacerlo. BindingContext es una propiedad especial que heredan todos sus
elementos secundarios. Por tanto, cuando la propiedad BindingContext de ContentPage se establece
en una instancia de Note , todos los elementos secundarios de ContentPage tienen la misma
propiedad BindingContext y se pueden enlazar a propiedades públicas del objeto Note .
Después, el objeto Editor de NoteEntryPage se enlaza a la propiedad Text del objeto Note :

... />
Se establece un enlace entre la propiedad Editor.Text y la propiedad Text del objeto de origen.
Los cambios realizados en Editor se propagarán de forma automática al objeto Note . De forma
similar, si se realizan cambios en la propiedad Note.Text , el motor de enlace de Xamarin.Forms
también actualizará el contenido de Editor . Esto se conoce como enlace bidireccional.
Para obtener más información sobre el enlace de datos, vea Enlace de datos de Xamarin.Forms.
Las aplicaciones de Xamarin.Forms suelen contener varios elementos visuales que tienen un
aspecto idéntico. Establecer la apariencia de cada elemento visual puede ser repetitivo y
propenso a errores. En su lugar, se pueden crear estilos que definan el aspecto y, después,
aplicarlos a los elementos visuales necesarios.
La clase Style agrupa una colección de valores de propiedad en un objeto que después se
puede aplicar a varias instancias de elementos visuales. Los estilos se almacenan en un objeto
ResourceDictionary , ya sea en el nivel de la aplicación, de la página o de la vista. La elección de
dónde se puede definir un elemento Style afecta a dónde se puede usar:
Las instancias de Style definidas en el nivel de aplicación se pueden aplicar en toda la
aplicación.
Las instancias de Style definidas en el nivel de página se pueden aplicar a la página y a sus
elementos secundarios.
Las instancias de Style definidas en el nivel de vista se pueden aplicar a la vista y a sus
elementos secundarios.
IMPORTANT
Todos los estilos que se usen en la aplicación se almacenan en el diccionario de recursos de la aplicación
para evitar la duplicación. Pero el código de XAML que es específico de una página no debería incluirse en
el diccionario de recursos de la aplicación, dado que los recursos se analizarán en el inicio de la aplicación
en lugar de cuando los solicite una página.
Cada instancia de Style contiene una colección de uno o varios objetos Setter , donde cada
objeto Setter tiene un elemento Property y un elemento Value . Property es el nombre de la
propiedad enlazable del elemento al que se aplica el estilo y Value es el valor que se aplica a la
propiedad. En el ejemplo de código siguiente se muestra un estilo de NoteEntryPage :
Title="Note Entry">
</Style>
...
...
</ContentPage>
Este estilo se aplica a cualquier instancia de Editor de la página.

Al crear un elemento Style , siempre se requiere la propiedad TargetType .
NOTE
Normalmente, la aplicación de estilo a una aplicación Xamarin.Forms se realiza mediante estilos XAML.
Pero Xamarin.Forms también admite aplicar estilo a los elementos visuales mediante Hojas de estilo CSS
(CSS). Para más información, vea Aplicación de estilos para aplicaciones Xamarin.Forms con hojas de estilo
(CSS).
Para obtener más información sobre los estilos XAML, vea Styling Xamarin.Forms Apps using
XAML Styles (Aplicación de estilo a aplicaciones Xamarin.Forms mediante XAML).
Proporcionar estilos específicos de la plataforma
Las extensiones de marcado OnPlatform permiten personalizar la apariencia de la interfaz de
usuario para cada plataforma:
...
<Color x:Key="iOSNavigationBarColor">WhiteSmoke</Color>
<Color x:Key="AndroidNavigationBarColor">#2196F3</Color>
<Color x:Key="iOSNavigationBarTextColor">Black</Color>
<Color x:Key="AndroidNavigationBarTextColor">White</Color>

Value="{OnPlatform iOS={StaticResource iOSNavigationBarColor},
Android={StaticResource AndroidNavigationBarColor}}"
/>
Value="{OnPlatform iOS={StaticResource iOSNavigationBarTextColor},
Android={StaticResource
AndroidNavigationBarTextColor}}" />
</Style>
...
</Application>
Este elemento Style establece otros valores Color para las propiedades BarBackgroundColor y
BarTextColor de NavigationPage , en función de la plataforma que se use.
Para más información sobre las extensiones de marcado, vea Extensiones de marcado para el
lenguaje XAML. Para obtener información sobre de la extensión de marcado OnPlatform , vea
Extensión de marcado OnPlatform.
Pruebas e implementación
Tanto Visual Studio para Mac como Visual Studio ofrecen numerosas opciones para probar e
implementar una aplicación. Depurar aplicaciones es una parte común del ciclo de vida del
desarrollo de la aplicación y ayuda a diagnosticar problemas de código. Para obtener más
información, consulte Set a Breakpoint (Establecer un punto de interrupción), Step Through Code
(Recorrer el código paso a paso) y Output Information to the Log Window (Información de salida
para la ventana Registro).
Los simuladores son un buen lugar para comenzar a implementar y probar una aplicación, y
cuentan con una funcionalidad que resulta útil a la hora de probar las aplicaciones. Sin embargo,
los usuarios no usarán la aplicación final en un simulador, por lo que las aplicaciones deben
probarse en dispositivos reales desde el primer momento y con frecuencia. Para obtener más
información sobre el aprovisionamiento de dispositivos de iOS, consulte Aprovisionamiento de
dispositivos. Para obtener más información sobre el aprovisionamiento de dispositivos de
Android, consulte Configurar el dispositivo para el desarrollo.
Pasos siguientes
En este análisis detallado se han examinado los aspectos fundamentales del desarrollo de
aplicaciones con Xamarin.Forms. Se recomienda que, como paso siguiente, lea sobre las
funcionalidades que se indican a continuación:
Existen cuatro grupos de control principales que se usan para crear la interfaz de usuario de
una aplicación de Xamarin.Forms. Para obtener más información, vea Referencia de controles.
El enlace de datos es la técnica que consiste en vincular las propiedades de dos objetos para
que los cambios en una propiedad se reflejen automáticamente en la otra propiedad. Para
obtener más información, vea Enlace de datos.
Xamarin.Forms proporciona una serie de experiencias de navegación de páginas diferente, en
función del tipo de página que se use. Para obtener más información, consulte Navigation
(Navegación).
Los estilos permiten reducir el uso de marcado repetitivo y conseguir que la apariencia de las
aplicaciones pueda cambiarse con mayor facilidad. Para obtener más información, vea
Aplicación de estilos a aplicaciones de Xamarin.Forms.
Las extensiones de marcado XAML extienden las funciones avanzadas y la flexibilidad de
XAML al permitir establecer atributos de elementos desde orígenes distintos de cadenas de
texto literales. Para obtener más información, vea Extensiones de marcado XAML.
Las plantillas de datos permiten definir la presentación de los datos en las vistas admitidas.
Para obtener más información, consulte Data Templates (Plantillas de datos).
Cada página, diseño y control se representan de forma diferente en cada plataforma mediante
una clase Renderer que, a su vez, crea un control nativo, lo organiza en la pantalla y agrega el
comportamiento especificado al código compartido. Los desarrolladores pueden implementar
sus propias clases Renderer personalizadas para personalizar la apariencia o el
comportamiento de un control. Para obtener más información, consulte Custom Renderers
(Representadores personalizados).
Los efectos también permiten personalizar los controles nativos de cada plataforma. Los
efectos se crean en proyectos específicos de la plataforma mediante la creación de subclases
de la clase PlatformEffect . Para usarlos, se adjuntan a un control adecuado de
Xamarin.Forms. Para obtener más información, consulte Effects (Efectos).
El código compartido puede tener acceso a la funcionalidad nativa mediante la clase
DependencyService . Para obtener más información, consulte Accessing Native Features with
DependencyService (Acceso a características nativas con DependencyService).
También es recomendable el libro de Charles Petzold titulado Creating Mobile Apps with
Xamarin.Forms (Creación de aplicaciones móviles con Xamarin.Forms) para obtener más
información sobre Xamarin.Forms. El libro está disponible como un archivo PDF o en una
variedad de formatos de libro electrónico.
Lenguaje XAML (eXtensible Application Markup Language)
Enlace de datos
Controls Reference (Referencia de controles)
Extensiones de marcado XAML
Xamarin.Forms Samples (Ejemplos de Xamarin.Forms)
Getting Started Samples (Ejemplos de introducción)
Referencia de la API de Xamarin.Forms
Aprendizaje autoguiado gratuito (vídeo)
Vídeo relacionado
Encuentre más vídeos de Xamarin en Channel 9 y YouTube.

Multiplataforma para desarrolladores de escritorio
Esta sección contiene información para ayudar a los desarrolladores de WPF y Windows Forms a aprender el
desarrollo de aplicaciones móviles con Xamarin, mediante la referencia cruzada de los conocimientos y la
experiencia existentes a los lenguajes móviles, y proporcionando ejemplos de migración de aplicaciones de
escritorio a Mobile.
Comparación del ciclo de vida de la aplicación

Descripción de las diferencias entre el inicio de la aplicación de WPF y el de Xamarin. Forms.
Comparación de controles de interfaz de usuario

Referencia rápida para buscar controles equivalentes en Windows Forms, WPF y Xamarin. Forms, incluidas
instrucciones adicionales sobre las diferencias entre WPF y Xamarin. Forms.
Guía de migración
Usar el analizador de portabilidad para ayudar a migrar el código de aplicación de escritorio (excluida la interfaz de
usuario) a Xamarin. Forms.
Muestras
Ejemplos de referencia que muestran la arquitectura de aplicaciones empresariales y el código de portabilidad de
WPF a Xamarin. Forms.
Obtener más información

Xamarin para desarrolladores de Java
Si es usted es desarrollador de Java, ya tiene la posibilidad de empezar a aprovechar sus habilidades y el código
existente de Xamarin en la plataforma Xamarin, al tiempo que disfruta de los beneficios de reutilizar código de C#.
Observará que la sintaxis de C# es muy similar a la sintaxis de Java y que ambos lenguajes ofrecen características
muy similares. Además, encontrará características exclusivas de C# que facilitarán el trabajo a los desarrolladores.
Información general
En este artículo se proporciona una introducción a la programación en C# para los desarrolladores de Java y se
centra principalmente en las características del lenguaje C# con las que se encontrará al desarrollar aplicaciones
Xamarin.Android. Además, en este artículo se explican las diferencias de estas características con respecto a las de
Java y, además, se presentan características importantes de C# (relevantes para Xamarin.Android) que no se
encuentran disponibles en Java. Se incluyen vínculos a material de referencia adicional, para que pueda usar este
artículo como un punto de partida para obtener más información sobre C# y .NET.
Si está familiarizado con Java, no tardará en sentirse cómodo con la sintaxis de C#. La sintaxis de C# es muy similar
a la de Java – C# es un lenguaje "de apertura" como Java, C y C++. En muchos sentidos, la sintaxis de C# se lee
como un superconjunto de la sintaxis de Java, pero con algunas palabras clave agregadas y con el nombre
cambiado.
Muchas características clave de Java pueden encontrarse en C#:
Programación orientada a objetos basados en clases
Tipado fuerte
Compatibilidad con interfaces
Genéricos
Recolección de elementos no utilizados
Compilación en tiempo de ejecución
Java y C# se compilan en un lenguaje intermedio que se ejecuta en un entorno de ejecución administrado. C# y
Java son tipos estáticos, y ambos lenguajes tratan las cadenas como tipos inmutables. Ambos lenguajes utilizan una
jerarquía de clases de raíz única. Al igual que Java, C# solo admite una herencia única y no acepta los métodos
globales. En ambos lenguajes, los objetos se crean en el montón con la palabra clave new y se recoleccionan los
objetos no utilizados cuando ya no se utilizan. Ambos lenguajes ofrecen una compatibilidad formal con el control
de excepciones mediante la semántica try / catch . Los dos ofrecen también compatibilidad con la sincronización y
administración de subprocesos.
No obstante, existen muchas diferencias entre Java y C#. Por ejemplo:
Java (tal como se usa en Android) no admite las variables locales con tipo implícito (C# admite la palabra
clave var ).
En Java, puede pasar parámetros solo por valor, mientras que en C# puede pasarlos tanto por referencia
como por valor. (C# ofrece las palabras clave ref y out para pasar los parámetros por referencia; no hay
ningún equivalente en Java).
Java no admite las directivas de preprocesador como #define .
Java no admite los tipos de enteros sin signo, mientras que C# sí que proporciona tipos de enteros sin signo
como ulong , uint , ushort y byte .
Java no admite la sobrecarga de operador; en C# se pueden sobrecargar operadores y conversiones.
En una instrucción Java switch , el código puede pasar a la siguiente sección del modificador; en cambio, en
C#, el final de cada sección switch debe terminar el modificador (el final de cada sección debe cerrarse con
una instrucción break ).
En Java, puede especificar las excepciones generadas por un método con la palabra clave throws , pero C#
no tiene ningún concepto de excepciones comprobadas; la palabra clave throws no se admite en C#.
C# admite Language Integrated Query (LINQ), que permite usar las palabras reservadas from , select y
where para escribir consultas de colecciones de forma similar a las consultas de bases de datos.
Por supuesto, hay muchas más diferencias entre C# y Java que pueden tratarse en este artículo. Además, Java y C#
continúan evolucionando (por ejemplo, Java 8, que aún no se encuentra en la cadena de herramientas de Android,
admite expresiones lambda del estilo de C#), por lo que estas diferencias seguirán evolucionando. Aquí solo se
destacan las diferencias más importantes que han detectado los desarrolladores de Java que son nuevos en
Xamarin.Android.
En Pasar del desarrollo en Java al desarrollo en C# se ofrece una introducción a las diferencias
fundamentales entre C# y Java.
En Características de la programación orientada a objetos se explican las diferencias más importantes de la
característica orientada a objetos entre ambos lenguajes.
En Diferencias de palabras claves se ofrece una lista de equivalentes de palabras claves útiles, solo palabras
claves de C# y vínculos a las definiciones de las palabras claves de C#.
C# proporciona muchas características claves de Xamarin.Android que actualmente no están disponibles para los
desarrolladores de Java en Android. Estas características pueden ayudarle a escribir código mejor y en menos
tiempo:
Propiedades – Con el sistema de propiedades de C#, puede acceder a las variables de miembros de forma
segura y directa sin tener que escribir métodos de establecedor y captador.
Expresiones lambda – En C# puede usar métodos anónimos (también denominados lambdas) para expresar
la funcionalidad de forma más sucinta y eficaz. Puede evitar la sobrecarga de tener que escribir objetos de
un solo uso, y puede pasar el estado local a un método sin tener que agregar parámetros.
Control de eventos – C# ofrece compatibilidad a nivel de lenguaje para la programación orientada a eventos,
donde se puede registrar un objeto para recibir una notificación cuando se produzca algún evento de
interés. La palabra clave event define un mecanismo de multidifusión que una clase de publicador puede
usar para informar a los suscriptores de eventos.
Programación asincrónica – Las características de la programación asincrónica de C# ( async / await )
mantienen la capacidad de respuesta de las aplicaciones. La compatibilidad a nivel de lenguaje de esta
característica permite que la programación asincrónica resulte fácil de implementar y que sea menos
propensa a errores.
Además, Xamarin le permite aprovechar los recursos de Java existentes mediante una tecnología que se conoce
como enlaces. Puede llamar al código, los marcos de trabajo y las bibliotecas de Java existentes desde C# con el uso
de generadores de enlaces automáticos de Xamarin. Para ello, basta con crear una biblioteca estática en Java y
exponerla en C# mediante un enlace.
NOTE
La programación de Android usa una versión específica del lenguaje Java que admite todas las características de Java 7 y un
subconjunto de Java 8.
Algunas características mencionadas en esta página (como la palabra clave var en C#) están disponibles en versiones más
recientes de Java (p. ej., var en Java 10), pero siguen si estar a disposición de los desarrolladores de Android.
Pasar del desarrollo en Java al desarrollo en C#

En las secciones siguientes se describen las diferencias básicas de "introducción" entre C# y Java; en una sección
posterior se describen las diferencias orientadas a objetos entre estos lenguajes.
Bibliotecas frente a ensamblados
Java suele empaquetar clases relacionadas en archivos .jar . Sin embargo, en C# and .NET, los bits reutilizables de
código precompilado se empaquetan en ensamblados, que suelen empaquetarse como archivos .dll. Un
ensamblado es una unidad de implementación de código de C#/.NET, y cada ensamblado suele asociarse con un
proyecto de C#. Los ensamblados contienen código intermedio que se compilan Just-In-Time en tiempo de
ejecución.
Para obtener más información sobre los ensamblados, vea el tema Ensamblados y caché global de ensamblados.
Paquetes frente a espacios de nombres
C# usa la palabra clave namespace para agrupar tipos relacionados; es similar a la palabra clave package de Java.
Normalmente, una aplicación de Xamarin.Android residirá en un espacio de nombres creado para esa aplicación.
Por ejemplo, el siguiente código de C# declara el contenedor del espacio de nombres WeatherApp para un
aplicación de información meteorológica:
namespace WeatherApp
{
...
Importación de tipos
Al usar tipos definidos en los espacios de nombres externos, importe estos tipos con una instrucción using (que es
muy similar a la instrucción import de Java). En Java, puede importar un solo tipo con una instrucción similar a la
siguiente:
import javax.swing.JButton
Puede importar un paquete de Java completo con una instrucción como esta:
import javax.swing.*
La instrucción using de C# funciona de forma muy similar, pero permite importar un paquete completo sin
especificar un carácter comodín. Por ejemplo, a menudo verá una serie de instrucciones using al principio de los
archivos de origen de Xamarin.Android, como se observa en este ejemplo:
using System;
using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;
using System.Net;
using System.IO;
using System.Json;
Estas instrucciones importan la funcionalidad desde los espacios de nombres System , Android.App ,
Android.Content , etc.
Genéricos
Tanto Java como C# admiten genéricos, que son marcadores de posición que permiten conectar diferentes tipos en
tiempo de compilación. Sin embargo, los genéricos funcionan de forma algo diferente en C#. En Java, el borrado de
tipos habilita la información sobre tipos solo en tiempo de compilación, pero no en tiempo de ejecución. Por el
contrario, .NET Common Language Runtime (CLR) proporciona compatibilidad explícita para los tipos genéricos, lo
que significa que C# tiene acceso a información sobre tipos en tiempo de ejecución. En el desarrollo diario de
Xamarin.Android, la importancia de esta distinción no suele ser evidente, pero si usa la reflexión, dependerá de esta
característica para acceder a la información sobre tipos en tiempo de ejecución.
En Xamarin.Android, verá con frecuencia el método genérico FindViewById utilizado para obtener una referencia a
un control de diseño. Este método acepta un parámetro de tipo genérico que especifica el tipo de control que se
buscará. Por ejemplo:
TextView label = FindViewById<TextView> (Resource.Id.Label);
En este ejemplo de código, FindViewById obtiene una referencia al control TextView que se define en el diseño
como etiqueta ; a continuación, se devuelve como un tipo TextView .
Para obtener más información sobre los genéricos, vea el tema Genéricos. Tenga en cuenta que existen algunas
limitaciones en la compatibilidad de Xamarin.Android con las clases genéricas de C#; para más información, vea
Limitaciones.
Características de la programación orientada a objetos

Java y C# utilizan expresiones de programación orientada a objetos muy similares:
Todas las clases derivan en última instancia de un único objeto raíz; todos los objetos de Java derivan de
java.lang.Object , mientras que los de C# derivan de System.Object .
Las instancias de clases son tipos de referencia.

Cuando acceda a las propiedades y los métodos de una instancia, use el operador " . ".
Todas las instancias de clases se crean en el montón mediante el operador new .
Debido a que ambos lenguajes usan la recolección de elementos no utilizados, no hay ningún método para
liberar de forma explícita los objetos no utilizados (es decir, no hay ninguna palabra clave delete como hay
en C++).
Puede extender las clases mediante la herencia, y ambos lenguajes solo permiten una única clase base por
tipo.
Puede definir interfaces y una clase puede heredar de varias definiciones de interfaz (es decir, implementar).
Sin embargo, también hay algunas diferencias importantes:
Java tiene dos características eficaces que C# no admite: las clases anónimas y las clases internas. (Sin
embargo, C# permite el anidamiento de las definiciones de clases; las clases anidadas de C# son similares a
las clases anidadas estáticas de Java).
C# admite tipos de estructuras del estilo de C ( struct ), pero Java no.
En C#, puede implementar una definición de clase en los archivos de código fuente independientes mediante
la palabra clave partial .
Las interfaces de C# no pueden declarar campos.
C# utiliza la sintaxis de destructores de estilo de C++ para expresar los finalizadores. La sintaxis es diferente
del método finalize de Java, pero la semántica es prácticamente la misma. (Tenga en cuenta que, en C#, los
destructores llaman automáticamente al destructor de clase base –, a diferencia de Java, donde se usa una
llamada explícita a super.finalize ).
Herencia de clases
Para extender una clase de Java, utilice la palabra clave extends . Para extender una clase de C#, utilice dos puntos (
: ) para indicar la derivación. Por ejemplo, en aplicaciones de Xamarin.Android, a menudo verá derivaciones de
clases que se parecen al fragmento de código siguiente:
public class MainActivity : Activity

{
...
En este ejemplo, MainActivity hereda de la clase Activity .

Para declarar la compatibilidad con una interfaz en Java, use la palabra clave implements . Sin embargo, en C#, solo
tiene que agregar nombres de interfaz a la lista de clases de la que se hereda, como se muestra en este fragmento
de código:
public class SensorsActivity : Activity, ISensorEventListener

{
...
En este ejemplo, SensorsActivity hereda de Activity e implementa la funcionalidad declarada en la interfaz

ISensorEventListener . Tenga en cuenta que la lista de interfaces debe aparecer después de la clase base o, de lo
contrario, se producirá un error en tiempo de compilación. Por convención, los nombres de interfaz de C# van
precedidos de una letra mayúscula "I"; esto permite determinar qué clases son interfaces sin requerir una palabra
clave implements .
Si desea impedir que una clase derive en subclases en C#, coloque sealed – delante del nombre de clase; en Java,
coloque final delante del nombre de clase.
Para obtener más información sobre las definiciones de clases de C#, vea los temas Clases y Herencia.
Propiedades
En Java, los métodos mutadores (establecedores) y los métodos de inspector (captadores) a menudo se utilizan
para controlar cómo se realizan los cambios en los miembros de clase al ocultarlos y protegerlos del código
externo. Por ejemplo, la clase TextView de Android proporciona los métodos getText y setText . C# proporciona
un mecanismo similar pero más directo conocido como propiedades. Los usuarios de una clase de C# pueden
acceder a una propiedad de la misma manera en que accederían a un campo, pero cada acceso realmente produce
una llamada de método que es transparente para el autor de la llamada. Este método "pormenorizado" puede
implementar los efectos secundarios, como establecer otros valores, realizar conversiones o cambiar el estado del
objeto.
Las propiedades suelen utilizarse para acceder a los miembros de objetos de la interfaz de usuario y para
modificarlos. Por ejemplo:
int width = rulerView.MeasuredWidth;

int height = rulerView.MeasuredHeight;
...
rulerView.DrawingCacheEnabled = true;
En este ejemplo, se leen los valores de anchura y altura del objeto rulerView mediante el acceso a sus propiedades
MeasuredWidth y MeasuredHeight . Cuando se leen estas propiedades, los valores de sus valores de campos
asociados, pero ocultos, se capturan en segundo plano y se devuelven al autor de la llamada. El objeto rulerView
puede almacenar los valores de anchura y altura en una unidad de medida (es decir, píxeles) y convertirlos sobre la
marcha en una unidad de medida distinta (por ejemplo, milímetros) al acceder a las propiedades MeasuredWidth y
MeasuredHeight .
El objeto rulerView también tiene una propiedad denominada DrawingCacheEnabled – el código de ejemplo
establece esta propiedad en true para habilitar la caché de dibujo en rulerView . En segundo plano, se actualiza
un campo oculto asociado con el nuevo valor y es posible que se modifiquen otros aspectos del estado rulerView .
Por ejemplo, cuando DrawingCacheEnabled está establecido en false , rulerView también puede borrar cualquier
información de la caché de dibujo ya acumulada en el objeto.
El acceso a las propiedades puede ser de lectura/escritura, solo lectura o solo escritura. Además, puede usar
distintos modificadores de acceso para leer y escribir. Por ejemplo, puede definir una propiedad que tenga acceso
de lectura público, pero acceso de escritura privado.
Para obtener más información sobre las propiedades de C#, vea el tema Propiedades.
Llamar a métodos de clase base
Para llamar a un constructor de clase base en C#, utilice dos puntos ( : ) seguidos de la palabra clave base y una
lista de inicializadores; esta llamada al constructor base se coloca inmediatamente después de la lista de
parámetros del constructor derivada. Se llama al constructor de clase base al introducir el constructor derivado; el
compilador inserta la llamada en el constructor base al inicio del cuerpo del método. El siguiente fragmento de
código muestra un constructor base llamado desde un constructor derivado en una aplicación de Xamarin.Android:
public class PictureLayout : ViewGroup

{
...
public PictureLayout (Context context)
: base (context)
{
...
}
...
}
En este ejemplo, la clase PictureLayout se deriva de la clase ViewGroup . El constructor PictureLayout que se
muestra en este ejemplo acepta un argumento context y lo pasa al constructor ViewGroup mediante la llamada
base(context) .
Para llamar a un método de clase base en C#, use la palabra clave base . Por ejemplo, las aplicaciones de
Xamarin.Android suelen realizar llamadas a los métodos base, como se muestra aquí:
public class MainActivity : Activity
{
...
protected override void OnCreate (Bundle bundle)
{
base.OnCreate (bundle);
En este caso, el método OnCreate definido por la clase derivada ( MainActivity ) llama al método OnCreate de la
clase base ( Activity ).
Modificadores de acceso
Java y C# admiten los modificadores de acceso public , private y protected . Sin embargo, C# admite dos
modificadores de acceso adicionales:
internal – Al miembro de clase se puede acceder únicamente dentro del ensamblado actual.
protected internal – Al miembro de clase se puede acceder dentro del ensamblado de definición, de la
clase de definición y de las clases derivadas (tienen acceso las clases derivadas dentro y fuera del
ensamblado).
Para obtener más información sobre los modificadores de acceso de C#, vea el tema Modificadores de acceso.
Métodos virtuales y de invalidación
Java y C# admiten el polimorfismo, que es la capacidad de tratar objetos relacionados de la misma manera. En
ambos lenguajes, se puede usar una referencia de clase base para hacer referencia a un objeto de clases derivada, y
los métodos de una clase derivada pueden invalidar los métodos de sus clases base. Ambos lenguajes tienen el
concepto de un método virtual, que es un método de una clase base diseñado para sustituirse por un método de
una clase derivada. Al igual que Java, C# admite clases y métodos abstract .
Sin embargo, hay algunas diferencias entre Java y C# en cómo declarar métodos virtuales e invalidarlos:
En C#, los métodos son no virtuales de forma predeterminada. Las clases principales deben etiquetar de
forma explícita qué métodos deben invalidarse con el uso de la palabra clave virtual . Por el contrario,
todos los métodos de Java son virtuales de forma predeterminada.
Para evitar la invalidación de un método en C#, solo tiene que excluir la palabra clave virtual . Por el
contrario, Java usa la palabra clave final para marcar un método con "override is not allowed" (No se
permite la invalidación).
Las clases derivadas de C# deben usar la palabra clave override para indicar de forma explícita que se va a
anular un método de clase base virtual.
Para obtener más información sobre la compatibilidad de C# con el polimorfismo, vea el tema Polimorfismo.
Expresiones lambda
C# permite crear clausuras: métodos anónimos insertados que pueden acceder al estado del método en que están
incluidos. Con el uso de expresiones lambda, puede escribir menos líneas de código para implementar la misma
funcionalidad que hubiera implementado en Java con muchas más líneas de código.
Las expresiones lambda permiten omitir los pasos adicionales necesarios para crear una clase de un solo uso o una
clase anónima que debería aplicar en Java; en su lugar, solo puede escribir la lógica de negocios del código del
método insertado. Además, como las expresiones lambda tienen acceso a las variables del método adyacente, no
tiene que crear una lista larga de parámetros para pasar el estado al código del método.
En C#, las expresiones lambda se crean con el operador => , como se muestra a continuación:
(arg1, arg2, ...) => {
// implementation code
};
En Xamarin.Android, a menudo se usan expresiones lambda para definir controladores de eventos. Por ejemplo:
button.Click += (sender, args) => {

clickCount += 1; // access variable in surrounding code
button.Text = string.Format ("Clicked {0} times.", clickCount);
};
En este ejemplo, el código de la expresión lambda (el código encerrado entre llaves) incrementa un recuento de
clics y actualiza el texto button para mostrar el recuento de clics. Esta expresión lambda se registra con el objeto
button como un controlador de eventos de clics al que se llama cada vez que se pulsa un botón. (Los
controladores de eventos se explican con más detalle a continuación). En este ejemplo, el código de la expresión
lambda no usa los parámetros sender y args , pero sí son necesarios en la expresión lambda para satisfacer los
requisitos de firma del método para el registro del evento. En segundo plano, el compilador de C# convierte la
expresión lambda en un método anónimo al que se llama cada vez que se hace clic en un botón.
Para obtener más información sobre C# y las expresiones lambda, vea el tema Expresiones lambda.
Control de eventos
Un eventos es la forma en que un objeto notifica a los suscriptores registrados cuándo sucede algo interesante a
dicho objeto. A diferencia de Java, donde un suscriptor que suele implementar una interfaz Listener que contiene
un método de devolución de llamada, C# ofrece compatibilidad a nivel de lenguaje para el control de eventos
mediante delegados. Un delegado es similar a un puntero de función con seguridad de tipos orientado a objetos;
encapsula una referencia de objeto y un token de método. Si un objeto de cliente desea suscribirse a un evento,
crea un delegado y pasa el delegado al objeto notificador. Cuando se produce el evento, el objeto notificador invoca
el método representado por el objeto delegado, para notificar al objeto de cliente de suscripción del evento. En C#,
los controladores de eventos básicamente no son más que métodos que se invocan mediante delegados.
Para obtener más información sobre los delegados, vea el tema Delegados.
En C#, los eventos son multidifusión; esto quiere decir que se puede notificar a más de un agente de escucha
cuando se produce un evento. Esta diferencia se observa al tener en cuenta las diferencias sintácticas entre el
registro de eventos de Java y C#. En Java, se llama a SetXXXListener para registrar notificaciones de eventos; en C#,
se usa el operador += para registrar notificaciones de eventos al "agregar" el delegado a la lista de agentes de
escucha de eventos. En Java, se llama a SetXXXListener para anular el registro, mientras que en C# se utiliza -=
para "restar" el delegado de la lista de agentes de escucha.
En Xamarin.Android, los eventos se usan con frecuencia para informar a los objetos cuando un usuario realiza una
acción en un control de interfaz de usuario. Normalmente, un control de interfaz de usuario tendrá miembros que
se definen con la palabra clave event ; asocie los delegados con estos miembros para suscribirse a eventos de ese
control de interfaz de usuario.
Para suscribirse a un evento:
1. Cree un objeto delegado que haga referencia al método que quiere invocar cuando se produce el evento.
2. Use el operador += para asociar el delegado al evento al que se va a suscribir.
En el ejemplo siguiente se define un delegado (con el uso explícito de la palabra clave delegate ) para suscribirse a
los clics de botón. Este controlador de clics de botón inicia una nueva actividad:
startActivityButton.Click += delegate {
Intent intent = new Intent (this, typeof (MyActivity));
StartActivity (intent);
};
Sin embargo, también puede utilizar una expresión lambda para registrar eventos, omitiendo por completo la
palabra clave delegate . Por ejemplo:
startActivityButton.Click += (sender, e) => {

Intent intent = new Intent (this, typeof (MyActivity));
StartActivity (intent);
};
En este ejemplo, el objeto startActivityButton tiene un evento que espera un delegado con una firma de método
determinada: uno que acepta argumentos de remitente y evento y devuelve un valor nulo. No obstante, como no
queremos ocasionar la molestia de definir de forma explícita dicho delegado o su método, declaramos la firma del
método con (sender, e) y usamos una expresión lambda para implementar el cuerpo del controlador de eventos.
Tenga en cuenta que tenemos que declarar esta lista de parámetros aunque usemos los parámetros sender y e .
Es importante recordar que se puede anular la suscripción de un delegado (con el operador -= ), pero no se puede
anular la suscripción de una expresión lambda; tratar de hacerlo puede causar fugas de memoria. Use la forma de
expresión lambda del registro de eventos solo si no se anula la suscripción del controlador al evento.
Normalmente, las expresiones lambda se usan para declarar controladores de eventos en el código de
Xamarin.Android. Esta forma abreviada de declarar controladores de eventos puede parecer críptica al principio,
pero ahorra una gran cantidad de tiempo al leer y escribir código. Cuando se familiarice más, se habituará a
reconocer este patrón, que ocurre con frecuencia en el código de Xamarin.Android, y podrá dedicar más tiempo a
pensar en la lógica de negocios de su aplicación y menos tiempo a repasar la sobrecarga sintáctica.
Programación asincrónica
La programación asincrónica es una manera de mejorar la capacidad de respuesta general de la aplicación. Las
características de la programación asincrónica permiten que el resto del código de la aplicación continúe
ejecutándose mientras que una operación larga bloquea alguna parte de la aplicación. El acceso a la Web, el
procesamiento de imágenes y la lectura y escritura de archivos son ejemplos de operaciones que pueden causar
que una aplicación parezca inmovilizada si no se escribe de forma asincrónica.
C# incluye compatibilidad a nivel de lenguaje con la programación asincrónica mediante las palabras clave async
y await . Estas características del lenguaje facilitan bastante la escritura de código que realiza tareas de ejecución
prolongada sin bloquear el subproceso principal de la aplicación. En resumen, use la palabra clave async en un
método para indicar que el código del método debe ejecutarse de forma asincrónica y no bloquear el subproceso
del autor de la llamada. Use la palabra clave await para llamar a métodos marcados como async . El compilador
interpreta await como el punto al que se va a mover la ejecución del método a un subproceso en segundo plano
(se devuelve una tarea al autor de la llamada). Una vez completada esta tarea, la ejecución del código se reanuda en
el subproceso del autor de la llamada en el punto await del punto, devolviendo los resultados de la llamada
async . Por convención, los métodos que se ejecutan de forma asincrónica llevan el sufijo Async en sus nombres.
En las aplicaciones de Xamarin.Android, async y await suelen usarse para liberar el subproceso de la interfaz de
usuario, para que pueda responder a la entrada del usuario (como pulsar un botón Cancelar ) mientras tiene lugar
una operación de ejecución prolongada en una tarea en segundo plano.
En el ejemplo siguiente, un controlador de eventos de clics de botón resulta en una operación asincrónica para
descargar una imagen de la Web:
downloadButton.Click += downloadAsync;
...
async void downloadAsync(object sender, System.EventArgs e)
{
webClient = new WebClient ();
var url = new Uri ("http://photojournal.jpl.nasa.gov/jpeg/PIA15416.jpg");
byte[] bytes = null;
bytes = await webClient.DownloadDataTaskAsync(url);
// display the downloaded image ...
En este ejemplo, cuando el usuario hace clic en el control downloadButton , el controlador de eventos downloadAsync
crea un objeto WebClient y un objeto Uri para capturar una imagen de la dirección URL especificada. A
continuación, llama al método DownloadDataTaskAsync del objeto WebClient con esta dirección URL para recuperar
la imagen.
Tenga en cuenta que la declaración del método downloadAsync va precedida de la palabra clave async para indicar
que se ejecutará de forma asincrónica y que devolverá una tarea. Tenga en cuenta también que la llamada a
DownloadDataTaskAsync va precedida de la palabra clave await . La aplicación mueve la ejecución del controlador de
eventos (a partir del punto en que await aparece) a un subproceso en segundo plano hasta que
DownloadDataTaskAsync se completa y realiza la devolución. Mientras tanto, el subproceso de la interfaz de usuario
de la aplicación puede responder aún a la entrada del usuario y activar los controladores de eventos para los otros
controles. Cuando DownloadDataTaskAsync se completa (que puede tardar varios segundos), la ejecución se reanuda
donde la variable bytes está establecida en el resultado de la llamada a DownloadDataTaskAsync , y el resto del
código del controlador de eventos muestra la imagen descargada en el subproceso del autor de la llamada (interfaz
de usuario).
Para obtener una introducción a async / await en C#, vea el tema Programación asincrónica con Async y Await.
Para más información sobre la compatibilidad de Xamarin con las características de la programación asincrónica,
vea Información general sobre la compatibilidad con Async.
Diferencias de palabras claves

Muchas de las palabras claves del lenguaje de Java también se usan en C#. También hay una serie de palabras clave
de Java que tienen un equivalente en C# pero con un nombre distinto, como se indica en esta tabla:
JAVA C# DESC RIP C IÓ N
boolean bool Se utiliza para declarar los valores

booleanos true y false.
extends : Precede a la clase e interfaces de las que

se hereda.
implements : Precede a la clase e interfaces de las que

se hereda.
import using Importa tipos de un espacio de

nombres, que también se usa para crear
un alias de espacio de nombres.
JAVA C# DESC RIP C IÓ N
final sealed Evita la derivación de clase; impide que

se invaliden los métodos y las
propiedades de la clase derivada.
instanceof is Evalúa si un objeto es compatible con

un tipo determinado.
native extern Declara un método que se implementa

externamente.
package namespace Declara un ámbito para un conjunto de

objetos relacionados.
T... params T Especifica un parámetro de método que

toma un número variable de
argumentos.
super base Se usa para acceder a los miembros de

la clase principal desde una clase
derivada.
synchronized lock Ajusta una sección crítica del código con

lanzamiento y adquisición de bloqueo.
Además, hay muchas palabras clave que son exclusivas de C# y que no tienen homólogo en el Java usado en
Android. El código de Xamarin.Android suele usar las siguientes palabras clave de C# (es útil hacer referencia a esta
tabla al leer código de ejemplo de Xamarin.Android):
C# DESC RIP C IÓ N
as Realiza conversiones entre tipos de referencia compatibles o

tipos que aceptan valores NULL.
async Especifica que un método o una expresión lambda son

asincrónicos.
await Suspende la ejecución de un método hasta que se completa

una tarea.
byte Tipo entero de 8 bits sin signo.
delegate Se utiliza para encapsular un método o un método anónimo.
enum Declara una enumeración, un conjunto de constantes con

nombre.
event Declara un evento en una clase de publicador.
fixed Impide la reubicación de una variable.
get Define un método de descriptor de acceso que recupera el

valor de una propiedad.
C# DESC RIP C IÓ N
in Permite que un parámetro acepte un tipo menos derivado en

una interfaz genérica.
object Un alias para el tipo Object en .NET Framework.
out Modificador de parámetros o declaración de parámetros de

tipo genérico.
override Amplía o modifica la implementación de un miembro

heredado.
partial Declara que una definición se va a dividir en varios archivos o

que se va a separar una definición de método de su
implementación.
readonly Declara que un miembro de clase puede asignarse solo en el

momento de la declaración o mediante el constructor de clase.
ref Hace que un argumento se pase por referencia en lugar de

por valor.
set Define un método de descriptor de acceso que establece el

valor de una propiedad.
string Alias para el tipo String en .NET Framework.
struct Un tipo de valor que encapsula un grupo de variables

relacionadas.
typeof Obtiene el tipo de un objeto.
var Declara una variable local con tipo implícito.
value Hace referencia al valor que el código de cliente desea asignar

a una propiedad.
virtual Permite la invalidación de un método en una clase derivada.
Interoperación con código de Java existente

Si dispone de una funcionalidad de Java existente que no desea convertir a C#, puede volver a usar las bibliotecas
de Java existentes en las aplicaciones de Xamarin.Android con estas dos técnicas:
Crear una biblioteca de enlaces de Java – Con este enfoque, se utilizan las herramientas de Xamarin
para generar contenedores de C# que incluyen tipos de Java. Estos contenedores se denominan enlaces.
Como resultado, la aplicación de Xamarin.Android puede usar el archivo .jar con una llamada a estos
contenedores.
Java Native Interface – Java Native Interface (JNI) es un marco que permite a las aplicaciones de C#
llamar al código de Java o recibir llamadas de este código.
Para obtener más información sobre estas técnicas, vea Java Integration Overview (Información general sobre la
integración de Java).
Información adicional
La guía de programación de C# es un recurso muy útil para iniciarse en el aprendizaje del lenguaje de
programación C#, y puede usar la referencia de C# para buscar características particulares del lenguaje C#.
De la misma forma que el conocimiento de Java tiene al menos tanto que ver con la familiaridad con las bibliotecas
de clases de Java como con el conocimiento del lenguaje Java, el conocimiento práctico de C# requiere alguna
familiaridad con .NET Framework. El paquete de aprendizaje Pasar a C# y .NET Framework, para desarrolladores de
Java de Microsoft es un buen recurso para aprender más sobre .NET Framework desde la perspectiva de Java (al
mismo tiempo que se adquiere un conocimiento más profundo de C#).
Cuando esté listo para abordar el primer proyecto de Xamarin.Android en C#, nuestra serie Hello, Android puede
facilitar la compilación de la primera aplicación de Xamarin.Android y ayudar a profundizar los conocimientos de
los aspectos fundamentales del desarrollo de aplicaciones de Android con Xamarin.
Resumen
Este artículo ofrece una introducción al entorno de programación de C# en Xamarin.Android desde la perspectiva
de los desarrolladores de Java. Se indican las similitudes entre C# y Java, además de explicar sus diferencias
prácticas. Aborda los ensamblados y los espacios de nombres, se explica cómo importar tipos externos y se ofrece
información general sobre las diferencias de los modificadores de acceso, los genéricos, la derivación de clases, la
llamada a métodos de clases base, la invalidación de métodos y el control de eventos. Se presentan características
de C# que no están disponibles en Java, como las propiedades, la programación asincrónica de async / await , las
expresiones lambda, los delegados de C# y el sistema de control de eventos de C#. Incluye tablas de palabras claves
importantes de C#, se explica cómo interoperar con bibliotecas de Java existentes y se ofrecen vínculos a
documentación relacionada realizar un estudio adicional.
Información general sobre la integración de Java
Guía de programación de C#
Referencia de C#
Pasar a C# y .NET Framework, para desarrolladores de Java
Xamarin para desarrolladores de Objective-C
Xamarin ofrece a los desarrolladores que tienen iOS como destino una ruta trasladar su código que no es de
interfaz de usuario a C# independiente de la plataforma, de manera que se pueda utilizar en cualquier lugar en que
C# esté disponible, como Android a través de Xamarin.Android y las diferentes versiones de Windows. Sin
embargo, el mero hecho de usar C# con Xamarin no implica que pueda aprovechar sus habilidades y el código de
Objective-C. De hecho, conocer Objective-C lo convierte en un mejor desarrollador de Xamarin.iOS porque
Xamarin expone todas las API de plataforma nativas de iOS y OS X que conoce y que le encantan, como UIKit, Core
Animation, Core Foundation y Core Graphics, por nombrar algunas. Al mismo tiempo, obtiene la eficacia del
lenguaje C#, incluidas características como LINQ y Generics, así como completas bibliotecas de clase base de .NET
para usar en sus aplicaciones nativas.
Además, Xamarin le permite aprovechar los recursos de Objective-C existentes mediante una tecnología que se
conoce como "enlaces". Basta con crear una biblioteca estática en Objective C y exponerla a C# a través de un
enlace, como se muestra en el diagrama siguiente:
Esto no tiene por qué limitarse al código que no es de interfaz de usuario. Los enlaces pueden exponer también el
código de interfaz de usuario desarrollado en Objective-C.
Transición desde Objective-C

Encontrará una gran cantidad de información en nuestro sitio de documentación que le ayudará a facilitar la
transición a Xamarin, donde se muestra cómo integrar código de C# con lo que ya conoce. Estos son algunos de los
principales materiales por los que puede comenzar:
Manual de C# para los desarrolladores Objective-C: un breve manual para los desarrolladores de Objective-C
que desean pasarse a Xamarin y el lenguaje C#.
Tutorial: Enlace de una biblioteca de Objective-C: un tutorial detallado para volver a usar código existente de
Objective-C en una aplicación de Xamarin.iOS.
Enlace de Objective-C
Cuando haya adquirido unas nociones generales sobre las diferencias y similitudes entre C# y Objective-C y haya
trabajando con el tutorial de enlace anterior, estará listo para la transición a la plataforma Xamarin. Si quiere
profundizar en la materia, puede encontrar más información detallada sobre las tecnologías de enlace de
Xamarin.iOS, incluida una exhaustiva referencia de enlace, en la sección Enlace de Objective-C.
Desarrollo multiplataforma
Finalmente, después de pasarse a Xamarin.iOS, seguramente querrá consultar la guía multiplataforma de que
disponemos, con estudios de caso de aplicaciones de referencia que hemos desarrollado y procedimientos
recomendados para crear código multiplataforma reutilizable, contenidos en la sección Building Cross Platform
Applications (Generación de aplicaciones multiplataforma).

Que Es Xamarin

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Que Es Xamarin

Cargado por

Copyright:

Formatos disponibles

Contents

A quién va destinado Xamarin

Instalación de Xamarin en Windows

Instrucciones paso a paso

Use las barras de progreso para supervisar la instalación:

Adición de Xamarin a Visual Studio 2019

Instalación de Xamarin en Windows

Instrucciones paso a paso

Agregar Xamarin a Visual Studio 2017

Instalación de Xamarin en macOS

Instrucciones paso a paso

Compruebe los requisitos del sistema antes de empezar.

Use las barras de progreso para supervisar la instalación:

Adición de Xamarin a Visual Studio 2019

Desinstalación de Visual Studio 2019 Preview

En esta guía se explica cómo quitar Xamarin de Visual Studio en Windows.

Visual Studio 2019 y Visual Studio 2017

4. Haga clic en el botón Modificar en la parte inferior derecha de la ventana.

Visual Studio 2015 y anterior

C:\Program Files*\Microsoft Visual Studio 1*.0\Common7\IDE\Extensions\Xamarin

Abra el editor del Registro (regedit) y busque la siguiente clave:

Busque y elimine las entradas que coincidan con este patrón:

C:\Program Files*\Microsoft Visual Studio 1*.0\Common7\IDE\Extensions\Xamarin

Busque esta clave:

"%ProgramFiles(x86)%\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe" /setup

Puntos de conexión permitidos

Xamarin Mac Agent

Compatibilidad con plataforma adicional

Compatibilidad con la plataforma Android

Instrucciones paso a paso para Windows

8. Al crear un emulador, se le devolverá a la ventana Administrador de dispositivos. Haga clic en el botón

<Button Text="Click Me" Clicked="Button_Clicked" />

2. Edite MainPage.xaml , agregando este código al final de la clase:

3. Depurar la aplicación en Android:

Compilación de una aplicación iOS en Visual Studio 2019

<Button Text="Click Me" Clicked="Button_Clicked" />

6. Edite MainPage.xaml , agregando este código al final de la clase:

7. Depurar la aplicación en Android:

Instrucciones paso a paso para Mac

3. Restaurar paquetes de NuGet, haciendo clic en el botón derecho en la solución:

<Button Text="Click Me" Clicked="Handle_Clicked" />

6. Edite MainPage.xaml , agregando este código al final de la clase:

7. Depurar la aplicación en Android:

9. Depurar la aplicación en iOS:

Creación de una aplicación Xamarin.Forms de página única

Navegación en una aplicación Xamarin.Forms de varias páginas

Almacenamiento de datos en una base de datos de SQLite.NET local

Estilo de una aplicación Xamarin.Forms multiplataforma

Análisis detallado de inicio rápido

Introducción a Visual Studio 2019

4. En el cuadro de diálogo Nueva aplicación multiplataforma , haga clic en Aplicación en blanco y

<?xml version="1.0" encoding="utf-8"?>

void OnSaveButtonClicked(object sender, EventArgs e)

void OnDeleteButtonClicked(object sender, EventArgs e)

Escriba una nota y pulse el botón Guardar .

Escriba una nota y pulse el botón Guardar .

Introducción a Visual Studio 2017

2. En el cuadro de diálogo Nuevo proyecto , haga clic en Multiplataforma , seleccione la plantilla

5. En MainPage.xaml , quite todo el código de plantilla y sustitúyalo por el siguiente código:

void OnSaveButtonClicked(object sender, EventArgs e)

void OnDeleteButtonClicked(object sender, EventArgs e)

Escriba una nota y pulse el botón Guardar .

Escriba una nota y pulse el botón Guardar .

C:\Program Files\Microsoft Visual Studio 1.0\Common7\IDE\Extensions\Xamarin

C:\Program Files\Microsoft Visual Studio 1.0\Common7\IDE\Extensions\Xamarin