Introducción a MonoTouch.Dialog para Xamarin.iOS

MonoTouch.Dialog, denominado MT. D en resumen, es un kit de herramientas de desarrollo de interfaz de usuario rápido que permite a los desarrolladores crear pantallas de aplicación y navegación mediante información, en lugar del tedio de crear controladores de vista, tablas, etc. Por lo tanto, proporciona una simplificación significativa del desarrollo de la interfaz de usuario y la reducción del código. Por ejemplo, considere la siguiente captura de pantalla:

Se usó el código siguiente para definir toda esta pantalla:

public enum Category
{
    Travel,
    Lodging,
    Books
}
        
public class Expense
{
    [Section("Expense Entry")]

    [Entry("Enter expense name")]
    public string Name;
    [Section("Expense Details")]
  
    [Caption("Description")]
    [Entry]
    public string Details;
        
    [Checkbox]
    public bool IsApproved = true;
    [Caption("Category")]
    public Category ExpenseCategory;
}

Al trabajar con tablas en iOS, a menudo hay una gran cantidad de código repetitivo. Por ejemplo, cada vez que se necesita una tabla, se necesita un origen de datos para rellenar esa tabla. En una aplicación que tiene dos pantallas basadas en tablas que están conectadas a través de un controlador de navegación, cada pantalla comparte gran parte del mismo código.

MT. D lo simplifica encapsulando todo ese código en una API genérica para la creación de tablas. A continuación, proporciona una abstracción sobre esa API que permite una sintaxis declarativa de enlace de objetos que facilita aún más. Por lo tanto, hay dos API disponibles en MT. D:

• ELEMENTS API de bajo nivel: Elements API se basa en la creación de un árbol jerárquicos de elementos que representan pantallas y sus componentes. Elements API proporciona a los desarrolladores la mayor flexibilidad y control a la hora de crear las IA. Además, Elements API tiene compatibilidad avanzada con la definición declarativa a través de JSON, lo que permite una declaración increíblemente rápida, así como la generación dinámica de la interfaz de usuario desde un servidor.
• API de reflexión de alto nivel: también conocida comoAPIdeenlace, en la que las clases se anotan con sugerencias de interfaz de usuario y, a continuación, mt. D crea automáticamente pantallas basadas en los objetos y proporciona un enlace entre lo que se muestra (y se edita opcionalmente) en pantalla y el respaldo de objetos subyacentes. En el ejemplo anterior se ilustra el uso de Reflection API. Esta API no proporciona el control específico que la API de elementos hace, pero reduce aún más la complejidad mediante la creación automática de la jerarquía de elementos basada en atributos de clase.

MT. D viene empaquetado con un gran conjunto de elementos de interfaz de usuario integrados para la creación de pantalla, pero también reconoce la necesidad de elementos personalizados y diseños de pantalla avanzados. Por lo tanto, la extensibilidad es una característica de primera clase que se integra en la API. Los desarrolladores pueden ampliar los elementos existentes o crear otros nuevos y, a continuación, integrarlos sin problemas.

Además, MT. D tiene una serie de características comunes de la experiencia de usuario de iOS integradas, como la compatibilidad con "extracción para actualizar", la carga asincrónica de imágenes y la compatibilidad con búsquedas.

En este artículo se va a echar un vistazo completo al trabajo con MT. D, incluidos:

• MT. Componentes D: esto se centrará en comprender las clases que lo convierten en MT. D para permitir que se puedan poner al día rápidamente.
• Referencia de elementos: una lista completa de los elementos integrados de MT.D.
• Uso avanzado: se tratan características avanzadas como la extracción para actualizar, la búsqueda, la carga de imágenes en segundo plano, el uso de LINQ para crear jerarquías de elementos y la creación de elementos personalizados, celdas y controladores para su uso con MT.D.

Configuración de MT. D

MT. D se distribuye con Xamarin.iOS. Para usarlo, haga clic con el botón derecho en el nodo Referencias de un proyecto de Xamarin.iOS en Visual Studio 2017 o Visual Studio para Mac y agregue una referencia al ensamblado MonoTouch.Dialog-1. A continuación, using MonoTouch.Dialog agregue instrucciones en el código fuente según sea necesario.

Descripción de los fragmentos de MT. D

Incluso cuando se usa Reflection API, MT. D crea una jerarquía de elementos en el centro, como si se hubiera creado directamente a través de Elements API. Además, la compatibilidad con JSON mencionada en la sección anterior también crea elementos. Por esta razón, es importante tener una comprensión básica de las partes constituyentes de MT.D.

MT. D compila pantallas con las cuatro partes siguientes:

• DialogViewController
• RootElement
• Sección
• Element

DialogViewController

DialogViewController, o DVC para abrevisor, hereda de y, por tanto, representa una pantalla con una tabla. Los DVC se pueden insertar en un controlador de navegación igual que un UITableViewController normal.

RootElement

RootElement es el contenedor de nivel superior para los elementos que van a un DVC. Contiene secciones, que pueden contener elementos. RootElements no se representa; en su lugar, son simplemente contenedores para lo que realmente se representa. Un elemento RootElement se asigna a una DVC y, a continuación, el DVC representa sus elementos secundarios.

Sección

Una sección es un grupo de celdas de una tabla. Al igual que con una sección de tabla normal, opcionalmente puede tener un encabezado y un pie de página que pueden ser texto o incluso vistas personalizadas, como en la captura de pantalla siguiente:

Elemento

Un elemento representa una celda real de la tabla. MT. D viene empaquetado con una amplia variedad de elementos que representan diferentes tipos de datos o entradas diferentes. Por ejemplo, las capturas de pantalla siguientes muestran algunos de los elementos disponibles:

Más información sobre secciones y rootelements

Ahora se analizarán rootelements y secciones con más detalle.

RootElements

Se necesita al menos un elemento RootElement para iniciar el proceso MonoTouch.Dialog.

Si se inicializa rootElement con un valor de sección o elemento, este valor se usa para buscar un elemento secundario que proporcionará un resumen de la configuración, que se representa en el lado derecho de la pantalla. Por ejemplo, en la captura de pantalla siguiente se muestra una tabla a la izquierda con una celda que contiene el título de la pantalla de detalles a la derecha, "Sedán", junto con el valor del área seleccionada.

En esta captura de pantalla se muestra una tabla a la izquierda con una celda que contiene el título de la pantalla de detalles a la junto con el valor del cuadro seleccionado Esta captura de pantalla muestra una tabla a la izquierda con una celda que contiene el título de la pantalla de detalles a la junto con el valor del tema seleccionado.

Los elementos raíz también se pueden usar dentro de Secciones para desencadenar la carga de una nueva página de configuración anidada, como se mostró anteriormente. Cuando se usa en este modo, el título proporcionado se usa mientras se representa dentro de una sección y también se usa como título para la subpágina. Por ejemplo:

var root = new RootElement ("Meals") {
    new Section ("Dinner") {
        new RootElement ("Dessert", new RadioGroup ("dessert", 2)) {
            new Section () {
                new RadioElement ("Ice Cream", "dessert"),
                new RadioElement ("Milkshake", "dessert"),
                new RadioElement ("Chocolate Cake", "dessert")
            }
        }
    }
};

En el ejemplo anterior, cuando el usuario pulsa "Secuesto", MonoTouch.Dialog creará una nueva página y navegará a ella con la raíz "Sedán" y tendrá un grupo de radio con tres valores.

En este ejemplo concreto, el grupo de radio seleccionará "Chocolate Cake" (Chocolate Cake) en la sección "Reancho" porque hemos pasado el valor "2" al radioGroup. Esto significa elegir el tercer elemento de la lista (índice cero).

Llamar al método Add o usar la sintaxis del inicializador de C# 4 agrega secciones. Los métodos Insert se proporcionan para insertar secciones con una animación.

Si crea rootElement con una instancia de Group (en lugar de un elemento RadioGroup), el valor de resumen de RootElement cuando se muestra en una sección será el recuento acumulativo de todos los BooleanElements y CheckboxElements que tienen la misma clave que el valor Group.Key.

Secciones

Las secciones se usan para agrupar elementos en la pantalla y son los únicos elementos secundarios directos válidos de RootElement. Las secciones pueden contener cualquiera de los elementos estándar, incluidos los nuevos elementos RootElement.

Los elementos RootElement insertados en una sección se usan para navegar a un nuevo nivel más profundo.

Las secciones pueden tener encabezados y pies de página como cadenas o como UIViews. Normalmente solo usará las cadenas, pero para crear uiu personalizados, puede usar cualquier UIView como encabezado o pie de página. Puede usar una cadena para crearlas de la siguiente forma:

var section = new Section ("Header", "Footer");

Para usar vistas, simplemente pase las vistas al constructor:

var header = new UIImageView (Image.FromFile ("sample.png"));
var section = new Section (header);

Recibir notificaciones

Control de NSAction

MT. D muestra un como NSAction delegado para controlar las devoluciones de llamada. Por ejemplo, digamos que desea controlar un evento táctil para una celda de tabla creada por MT.D. Al crear un elemento con MT. D, simplemente proporcione una función de devolución de llamada, como se muestra a continuación:

new Section () {
    new StringElement ("Demo Callback", delegate { Console.WriteLine ("Handled"); })
}

Recuperar el valor del elemento

En combinación con Element.Value la propiedad , la devolución de llamada puede recuperar el valor establecido en otros elementos. Por ejemplo, considere el siguiente código:

var element = new EntryElement (task.Name, "Enter task description", task.Description);
                
var taskElement = new RootElement (task.Name) {
    new Section () { element },
    new Section () { new DateElement ("Due Date", task.DueDate) },
    new Section ("Demo Retrieving Element Value") {
        new StringElement ("Output Task Description", delegate { Console.WriteLine (element.Value); })
    }
};

Este código crea una interfaz de usuario como se muestra a continuación. Para ver un tutorial completo de este ejemplo, consulte el tutorial de Elements API Tutorial.

Cuando el usuario presiona la celda de la tabla inferior, se ejecuta el código de la función anónima, escribiendo el valor de la instancia en el panel De salida de la element aplicación Visual Studio para Mac. element

Built-In elementos

MT. D incluye una serie de elementos de celda de tabla integrados conocidos como Elementos. Estos elementos se usan para mostrar una variedad de tipos diferentes en celdas de tabla, como cadenas, flotantes, fechas e incluso imágenes, por nombrar solo algunos. Cada elemento se encarga de mostrar el tipo de datos correctamente. Por ejemplo, un elemento booleano mostrará un modificador para alternar su valor. Del mismo modo, un elemento float mostrará un control deslizante para cambiar el valor float.

Hay elementos incluso más complejos para admitir tipos de datos más completos, como imágenes y html. Por ejemplo, un elemento html, que abrirá uiWebView para cargar una página web cuando se selecciona, muestra un título en la celda de la tabla.

Trabajar con valores de elemento

Los elementos que se usan para capturar la entrada del usuario exponen una propiedad pública que contiene el Value valor actual del elemento en cualquier momento. Se actualiza automáticamente a medida que el usuario usa la aplicación.

Este es el comportamiento de todos los elementos que forman parte de MonoTouch.Dialog, pero no es necesario para los elementos creados por el usuario.

Elemento String

Muestra un título en el lado izquierdo de una celda de tabla y el valor de cadena StringElement en el lado derecho de la celda.

Para usar un StringElement como botón, proporcione un delegado.

new StringElement ("Click me", () => { 
    new UIAlertView("Tapped", "String Element Tapped", null, "ok", null).Show();
});

Elemento String con estilo

Permite que las cadenas se presenten mediante estilos de celda de StyledStringElement tabla integrados o con formato personalizado.

La clase se deriva de , pero permite a los desarrolladores personalizar una serie de propiedades, como fuente, color de texto, color de celda de fondo, modo de separación de líneas, número de líneas que se mostrarán y si se debe mostrar un StyledStringElementStringElement accesorio.

Elemento multilínea

Elemento de entrada

, EntryElement como su nombre indica, se usa para obtener la entrada del usuario. Admite cadenas normales o contraseñas, donde los caracteres están ocultos.

Se inicializa con tres valores:

• Título de la entrada que se mostrará al usuario.
• Texto de marcador de posición (este es el texto de color gris que proporciona una sugerencia al usuario).
• Valor del texto.

El marcador de posición y el valor pueden ser NULL. Sin embargo, el título es obligatorio.

En cualquier momento, el acceso a su propiedad Value puede recuperar el valor de EntryElement .

Además, la propiedad se puede establecer en el momento de la creación KeyboardType en el estilo de tipo de teclado deseado para la entrada de datos. Se puede usar para configurar el teclado con los valores de como UIKeyboardType se muestra a continuación:

• Numérica
• Teléfono
• Url
• Correo electrónico

Elemento booleano

Elemento Checkbox

Elemento Radio

Un RadioElement requiere que se especifique en RadioGroupRootElement .

mtRoot = new RootElement ("Demos", new RadioGroup("MyGroup", 0));

RootElements también se usan para coordinar elementos de radio. Los miembros pueden abarcar varias secciones (por ejemplo, para implementar algo similar al selector de tono de anillo y separar los tonos de anillo RadioElement personalizados de los sonidos del sistema). La vista de resumen mostrará el elemento de radio que está seleccionado actualmente. Para usarlo, cree con RootElement el constructor de grupo, de la siguiente forma:

var root = new RootElement ("Meals", new RadioGroup ("myGroup", 0));

El nombre del grupo de se usa para mostrar el valor seleccionado en la página que lo contiene (si existe) y el valor, que es cero en este caso, es el índice del primer elemento RadioGroup seleccionado.

Elemento Badge

Elemento Float

Elemento Activity

Elemento Date

Cuando se selecciona la celda correspondiente a DateElement, se presenta un selector de fechas como se muestra a continuación:

Elemento Time

Cuando se selecciona la celda correspondiente a TimeElement, se presenta un selector de hora como se muestra a continuación:

Elemento DateTime

Cuando se selecciona la celda correspondiente a DateTimeElement, se presenta un selector datetime como se muestra a continuación:

Elemento HTML

muestra HTMLElement el valor de su propiedad en la celda de la Caption tabla. Al seleccionar , el Url asignado al elemento se carga en un control como se muestra a UIWebView continuación:

Elemento Message

Cargar más elemento

Use este elemento para permitir que los usuarios carguen más elementos en la lista. Puede personalizar los títulos normales y de carga, así como la fuente y el color del texto. El indicador empieza a animarse y el título de carga se muestra cuando un usuario pulsa la celda y, a continuación, se ejecuta el pasado UIActivityNSAction al constructor. Una vez finalizado el código en , el indicador deja de animarse y se vuelve NSAction a mostrar el título UIActivity normal.

Elemento UIView

Además, cualquier personalizado UIView se puede mostrar mediante UIViewElement .

Owner-Drawn elemento

Este elemento debe tener subclases, ya que es una clase abstracta. Debe invalidar el método en el que debe devolver el alto del elemento, así como en el que debe realizar todo el dibujo personalizado dentro de los Height(RectangleF bounds) límites especificados, utilizando los parámetros de contexto y Draw(RectangleF bounds, CGContext context, UIView view) vista. Este elemento realiza el trabajo pesado de crear subclases de y colocarlo en la celda que se va a devolver, lo que deja que solo necesite implementar UIView dos invalidaciones simples. Puede ver una mejor implementación de ejemplo en la aplicación de ejemplo en el DemoOwnerDrawnElement.cs archivo .

Este es un ejemplo muy sencillo de implementación de la clase :

public class SampleOwnerDrawnElement : OwnerDrawnElement
{
    public SampleOwnerDrawnElement (string text) : base(UITableViewCellStyle.Default, "sampleOwnerDrawnElement")
    {
        this.Text = text;
    }

    public string Text { get; set; }

    public override void Draw (RectangleF bounds, CGContext context, UIView view)
    {
        UIColor.White.SetFill();
        context.FillRect(bounds);

        UIColor.Black.SetColor();   
        view.DrawString(this.Text, new RectangleF(10, 15, bounds.Width - 20, bounds.Height - 30), UIFont.BoldSystemFontOfSize(14.0f), UILineBreakMode.TailTruncation);
    }

    public override float Height (RectangleF bounds)
    {
        return 44.0f;
    }
}

Elemento JSON

es una subclase de que extiende para poder cargar el contenido del elemento secundario anidado JsonElement desde una dirección URL local o RootElementRootElement remota.

es JsonElement un que se puede crear una instancia de en dos RootElement formas. Una versión crea un RootElement que cargará el contenido a petición. Estos se crean mediante los constructores que toman un argumento adicional al final, la dirección URL desde la JsonElement que se carga el contenido:

var je = new JsonElement ("Dynamic Data", "https://tirania.org/tmp/demo.json");

El otro formulario crea los datos a partir de un archivo local o de un existente System.Json.JsonObject que ya se ha analizando:

var je = JsonElement.FromFile ("json.sample");
using (var reader = File.OpenRead ("json.sample"))
    return JsonElement.FromJson (JsonObject.Load (reader) as JsonObject, arg);

Para obtener más información sobre el uso de JSON con MT. D, consulte el tutorial del elemento JSON.

Otras características

Compatibilidad con extracción y actualización

La actualización de extracciónaes un efecto visual que se encuentra originalmente en la aplicación Tweetie2, que se convirtió en un efecto popular entre muchas aplicaciones.

Para agregar compatibilidad automática de extracción y actualización a los diálogos, solo tiene que hacer dos cosas: enlazar un controlador de eventos para recibir una notificación cuando el usuario extraiga los datos y notificarle cuando los datos se hayan cargado para volver a su estado DialogViewController predeterminado.

El enlace de una notificación es sencillo; simplemente conéctese al RefreshRequested evento en , de la siguiente DialogViewController forma:

dvc.RefreshRequested += OnUserRequestedRefresh;

A continuación, en el método , ponería en cola algunos datos de carga, solicitaría algunos datos de la red o giraría un subproceso OnUserRequestedRefresh para calcular los datos. Una vez cargados los datos, debe notificar a que los nuevos datos están en y, para restaurar la vista a su estado predeterminado, debe llamar DialogViewController a ReloadComplete :

dvc.ReloadComplete ();

Compatibilidad con búsquedas

Para admitir la búsqueda, establezca la EnableSearch propiedad en DialogViewController . También puede establecer la propiedad que SearchPlaceholder se usará como texto de marca de agua en la barra de búsqueda.

La búsqueda cambiará el contenido de la vista a medida que el usuario los tipos. Busca en los campos visibles y los muestra al usuario. expone tres métodos para iniciar, finalizar o desencadenar mediante programación una DialogViewController nueva operación de filtro en los resultados. Estos métodos se enumeran a continuación:

• StartSearch
• FinishSearch
• PerformFilter

El sistema es extensible, por lo que puede modificar este comportamiento si lo desea.

Carga de imágenes de fondo

MonoTouch.Dialog incorpora el cargador de imágenes de la aplicación TweetStation. Este cargador de imágenes se puede usar para cargar imágenes en segundo plano, admite el almacenamiento en caché y puede notificar al código cuando se ha cargado la imagen.

También limitará el número de conexiones de red salientes.

El cargador de imágenes se implementa en la clase , todo lo que necesita hacer es llamar al método , deberá proporcionar el URI para la imagen que desea cargar, así como una instancia de la interfaz que se invocará cuando se haya cargado la ImageLoaderDefaultRequestImageIImageUpdated imagen.

Por ejemplo, el código siguiente carga una imagen de una dirección URL en BadgeElement :

string uriString = "http://some-server.com/some image url";

var rootElement = new RootElement("Image Loader") {
    new Section() {
        new BadgeElement( ImageLoader.DefaultRequestImage( new Uri(uriString), this), "Xamarin")
    }
};

La clase ImageLoader expone un método Purge al que puede llamar cuando desee liberar todas las imágenes que están almacenadas actualmente en caché en memoria. El código actual tiene una memoria caché para 50 imágenes. Si desea usar un tamaño de caché diferente (por ejemplo, si espera que las imágenes sean demasiado grandes que 50 imágenes serían demasiado), puede crear instancias de ImageLoader y pasar el número de imágenes que desea mantener en la memoria caché.

Usar LINQ to Create Element Hierarchy

Mediante el uso inteligente de LINQ y la sintaxis de inicialización de C#, LINQ se puede usar para crear una jerarquía de elementos. Por ejemplo, el código siguiente crea una pantalla a partir de algunas matrices de cadenas y controla la selección de celdas a través de una función anónima que se pasa a cada StringElement :

var rootElement = new RootElement ("LINQ root element") {
    from x in new string [] { "one", "two", "three" }
    select new Section (x) {
        from y in "Hello:World".Split (':')
        select (Element) new StringElement (y, delegate { Debug.WriteLine("cell tapped"); })
    }
};

Esto se podría combinar fácilmente con un almacén de datos XML o datos de una base de datos para crear aplicaciones complejas casi por completo a partir de datos.

Extensión de MT. D

Crear elementos personalizados

Puede crear su propio elemento heredando de un elemento existente o derivando de la clase raíz Element.

Para crear su propio elemento, querrá invalidar los métodos siguientes:

// To release any heavy resources that you might have
void Dispose (bool disposing);

// To retrieve the UITableViewCell for your element
// you would need to prepare the cell to be reused, in the
// same way that UITableView expects reusable cells to work
UITableViewCell GetCell (UITableView tv);

// To retrieve a "summary" that can be used with
// a root element to render a summary one level up.  
string Summary ();

// To detect when the user has tapped on the cell
void Selected (DialogViewController dvc, UITableView tableView, NSIndexPath path);

// If you support search, to probe if the cell matches the user input
bool Matches (string text);

Si el elemento puede tener un tamaño variable, debe implementar la IElementSizing interfaz , que contiene un método:

// Returns the height for the cell at indexPath.Section, indexPath.Row
float GetHeight (UITableView tableView, NSIndexPath indexPath);

Si planea implementar el método llamando a y personalizando la celda devuelta, también debe invalidar la propiedad para devolver una clave que será única para el elemento, de la GetCellbase.GetCell(tv) siguiente CellKey manera:

static NSString MyKey = new NSString ("MyKey");
protected override NSString CellKey {
    get {
        return MyKey;
    }
}

Esto funciona para la mayoría de los elementos, pero no para y , ya que usan su propio StringElement conjunto de claves para varios StyledStringElement escenarios de representación. Tendría que replicar el código en esas clases.

DialogViewControllers (DVC)

Tanto Reflection como Elements API usan el mismo DialogViewController . A veces querrá personalizar el aspecto de la vista o puede que quiera usar algunas características de que van más allá de la creación UITableViewController básica de las IA.

es simplemente una subclase de y puede personalizarla de la misma manera DialogViewControllerUITableViewController que personalizaría un UITableViewController .

Por ejemplo, si desea cambiar el estilo de lista para que sea o , podría establecer este valor cambiando la propiedad al crear el controlador, como Grouped se muestra a Plain continuación:

var myController = new DialogViewController (root, true) {
    Style = UITableViewStyle.Grouped;
}

Para personalizaciones más avanzadas de , como establecer su fondo, lo subclasificaría e invalidaría los métodos adecuados, como se muestra DialogViewController en el ejemplo siguiente:

class SpiffyDialogViewController : DialogViewController {
    UIImage image;

    public SpiffyDialogViewController (RootElement root, bool pushing, UIImage image) 
        : base (root, pushing) 
    {
        this.image = image;
    }

    public override LoadView ()
    {
        base.LoadView ();
        var color = UIColor.FromPatternImage(image);
        TableView.BackgroundColor = UIColor.Clear;
        ParentViewController.View.BackgroundColor = color;
    }
}

Otro punto de personalización son los siguientes métodos virtuales en DialogViewController :

public override Source CreateSizingSource (bool unevenRows)

Este método debe devolver una subclase de para los casos en los que las celdas tienen un tamaño uniforme o una subclase de si las celdas DialogViewController.SourceDialogViewController.SizingSource son desiguales.

Puede usar esta invalidación para capturar cualquiera de los UITableViewSource métodos. Por ejemplo, TweetStation usa esto para realizar un seguimiento de cuándo el usuario se ha desplazado a la parte superior y actualizar en consecuencia el número de tweets no leídos.

Validación

Los elementos no proporcionan validación ellos mismos, ya que los modelos que son adecuados para las páginas web y las aplicaciones de escritorio no se asignan directamente al modelo iPhone interacción.

Si desea realizar la validación de datos, debe hacerlo cuando el usuario descadene una acción con los datos especificados. Por ejemplo, un botón Listo o Siguiente en la barra de herramientas superior, o algunos usados como botón para ir a la fase siguiente.

Aquí es donde realizaría la validación de entrada básica y quizás una validación más complicada, como comprobar la validez de una combinación de usuario y contraseña con un servidor.

La forma en que se notifica al usuario de un error es específica de la aplicación. Puede mostrar o mostrar UIAlertView una sugerencia.

Resumen

En este artículo se ha abordado una gran cantidad de información sobre MonoTouch.Dialog. Se han analizado los aspectos básicos de la forma en que mt. D funciona y abarca los distintos componentes que componen MT.D. También mostró la amplia matriz de elementos y personalizaciones de tabla compatibles con MT. D y se ha analizado cómo mt. D se puede extender con elementos personalizados. Además, ha explicado la compatibilidad con JSON en MT. D que permite crear elementos dinámicamente a partir de JSON.

Vínculos relacionados

• Tutorial: creación de una aplicación con Elements API
• Tutorial: creación de una aplicación con Reflection API
• Tutorial: uso de un elemento JSON para crear una interfaz de usuario
• Marcado JSON MonoTouch.Dialog
• Cuadro de diálogo MonoTouch en GitHub
• Referencia de la clase UITableViewController
• Referencia de la clase UINavigationController