Introduzione a MonoTouch.Dialog per Xamarin.iOS

Articolo
11/25/2015

MonoTouch.Dialog, detto MT. D per brevità, è un toolkit di sviluppo rapido dell'interfaccia utente che consente agli sviluppatori di compilare schermate dell'applicazione e navigazione usando informazioni, anziché il tedium di creazione di controller di visualizzazione, tabelle e così via. Di conseguenza, offre una semplificazione significativa dello sviluppo e della riduzione del codice dell'interfaccia utente. Si consideri ad esempio lo screenshot seguente:

Per definire l'intera schermata è stato usato il codice seguente:

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;
}

Quando si usano tabelle in iOS, spesso è presente un tonno di codice ripetitivo. Ad esempio, ogni volta che è necessaria una tabella, è necessaria un'origine dati per popolare tale tabella. In un'applicazione con due schermate basate su tabella connesse tramite un controller di spostamento, ogni schermata condivide molto dello stesso codice.

MT. D semplifica questa operazione incapsulando tutto il codice in un'API generica per la creazione di tabelle. Fornisce quindi un'astrazione sopra l'API che consente una sintassi di associazione di oggetti dichiarativa che rende ancora più semplice. Di conseguenza, in MT sono disponibili due API. D:

API Elementi di basso livello: l'API Elements si basa sulla creazione di un albero gerarchico di elementi che rappresentano schermate e relativi componenti. L'API Elements offre agli sviluppatori la massima flessibilità e controllo nella creazione di interfacce utente. Inoltre, l'API Elements offre supporto avanzato per la definizione dichiarativa tramite JSON, che consente sia una dichiarazione incredibilmente veloce, sia la generazione dinamica dell'interfaccia utente da un server.
API Reflection di alto livello: nota anche come API di associazione, in cui le classi vengono annotate con hint dell'interfaccia utente e quindi MT. D crea automaticamente schermate basate sugli oggetti e fornisce un'associazione tra ciò che viene visualizzato (e facoltativamente modificato) sullo schermo e il backup dell'oggetto sottostante. L'esempio precedente illustra l'uso dell'API Reflection. Questa API non fornisce il controllo con granularità fine eseguito dall'API degli elementi, ma riduce ulteriormente la complessità creando automaticamente la gerarchia degli elementi in base agli attributi della classe.

MT. D è dotato di un ampio set di elementi dell'interfaccia utente predefiniti per la creazione dello schermo, ma riconosce anche la necessità di elementi personalizzati e layout dello schermo avanzati. Di conseguenza, l'estendibilità è una prima classe inserita nell'API. Gli sviluppatori possono estendere gli elementi esistenti o crearne di nuovi e quindi integrarsi senza problemi.

Inoltre, MT. D ha una serie di funzionalità comuni dell'esperienza utente iOS integrate, ad esempio il supporto "pull-to-refresh", il caricamento asincrono delle immagini e il supporto per la ricerca.

Questo articolo esaminerà in modo completo l'uso di MT. D, tra cui:

MT. Componenti D: questa operazione si concentrerà sulla comprensione delle classi che costituiscono MT. D per velocizzare la velocità.
Riferimento agli elementi: elenco completo degli elementi predefiniti di MT.D.
Utilizzo avanzato: vengono illustrate funzionalità avanzate, ad esempio l'aggiornamento pull-to-refresh, la ricerca, il caricamento di immagini in background, l'uso di LINQ per compilare gerarchie di elementi e la creazione di elementi, celle e controller personalizzati da usare con MT.D.

Configurazione di MT. D

MT. D viene distribuito con Xamarin.iOS. Per usarlo, fare clic con il pulsante destro del mouse sul nodo Riferimenti di un progetto Xamarin.iOS in Visual Studio 2017 o Visual Studio per Mac e aggiungere un riferimento all'assembly MonoTouch.Dialog-1. using MonoTouch.Dialog Aggiungere quindi istruzioni nel codice sorgente in base alle esigenze.

Informazioni sui pezzi di MT. D

Anche quando si usa l'API Reflection, MT. D crea una gerarchia di elementi sotto il cofano, come se fosse stata creata direttamente tramite l'API Elements. Inoltre, il supporto JSON indicato nella sezione precedente crea anche Elementi. Per questo motivo, è importante avere una conoscenza di base dei pezzi costitutivi di MT.D.

MT. D compila schermate usando le quattro parti seguenti:

DialogViewController
RootElement
Sezione
elemento

DialogViewController

DialogViewController, o DVC per brevità, eredita da UITableViewController e quindi rappresenta una schermata con una tabella. I DVD possono essere inseriti in un controller di spostamento proprio come un normale UITableViewController.

RootElement

RootElement è il contenitore di primo livello per gli elementi che vengono inseriti in un DVC. Contiene sezioni, che possono quindi contenere elementi. Il rendering di RootElements non viene eseguito; sono invece semplicemente contenitori per ciò che viene effettivamente sottoposto a rendering. Un Elemento RootElement viene assegnato a un DVC e quindi esegue il rendering dei relativi elementi figlio.

Sezione

Una sezione è un gruppo di celle in una tabella. Come per una sezione normale della tabella, può facoltativamente avere un'intestazione e un piè di pagina che possono essere di testo o persino visualizzazioni personalizzate, come nello screenshot seguente:

Elemento

Un elemento rappresenta una cella effettiva nella tabella. MT. D è dotato di un'ampia gamma di elementi che rappresentano tipi di dati diversi o input diversi. Ad esempio, gli screenshot seguenti illustrano alcuni degli elementi disponibili:

Altre informazioni su sezioni e RootElements

Verranno ora illustrati in modo più dettagliato RootElements e Sections.

RootElements

Almeno un Elemento RootElement è necessario per avviare il processo MonoTouch.Dialog.

Se un elemento RootElement viene inizializzato con un valore di sezione/elemento, questo valore viene usato per individuare un elemento figlio che fornirà un riepilogo della configurazione, di cui viene eseguito il rendering sul lato destro della visualizzazione. Ad esempio, lo screenshot seguente mostra una tabella a sinistra con una cella contenente il titolo della schermata dei dettagli a destra, "Dessert", insieme al valore del deserto selezionato.

Gli elementi radice possono essere usati anche all'interno di Sezioni per attivare il caricamento di una nuova pagina di configurazione annidata, come illustrato in precedenza. Se utilizzata in questa modalità, la didascalia specificata viene utilizzata durante il rendering all'interno di una sezione e viene usata anche come Titolo per la pagina secondaria. Ad esempio:

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")
            }
        }
    }
};

Nell'esempio precedente, quando l'utente tocca "Dessert", MonoTouch.Dialog creerà una nuova pagina e la passerà con la radice "Dessert" e con un gruppo di radio con tre valori.

In questo esempio particolare, il gruppo di radio selezionerà "Chocolate Cake" nella sezione "Dessert" perché è stato passato il valore "2" al RadioGroup. Ciò significa che selezionare il terzo elemento nell'elenco (indice zero).

La chiamata al metodo Add o l'uso della sintassi dell'inizializzatore C# 4 aggiunge sezioni. I metodi Insert vengono forniti per inserire sezioni con un'animazione.

Se si crea RootElement con un'istanza di Group (anziché un RadioGroup), il valore di riepilogo di RootElement quando visualizzato in una sezione sarà il conteggio cumulativo di tutti gli elementi BooleanElement e CheckboxElement che hanno la stessa chiave del valore Group.Key.

Sezioni

Le sezioni vengono usate per raggruppare gli elementi nella schermata e sono gli unici elementi figlio diretti validi di RootElement. Le sezioni possono contenere uno qualsiasi degli elementi standard, inclusi i nuovi Elementi RootElement.

Gli elementi RootElement incorporati in una sezione vengono usati per passare a un nuovo livello più profondo.

Le sezioni possono avere intestazioni e piè di pagina come stringhe o come uiView. In genere si useranno solo le stringhe, ma per creare interfacce utente personalizzate è possibile usare qualsiasi uiView come intestazione o piè di pagina. È possibile usare una stringa per crearle come segue:

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

Per usare le visualizzazioni, è sufficiente passare le visualizzazioni al costruttore:

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

Ricevere una notifica

Gestione di NSAction

MT. D espone un oggetto NSAction come delegato per la gestione dei callback. Si supponga, ad esempio, di voler gestire un evento di tocco per una cella di tabella creata da MT.D. Quando si crea un elemento con MT. D, specificare semplicemente una funzione di callback, come illustrato di seguito:

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

Recupero del valore dell'elemento

In combinazione con la Element.Value proprietà , il callback può recuperare il valore impostato in altri elementi. Si consideri il codice di esempio seguente:

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); })
    }
};

Questo codice crea un'interfaccia utente come illustrato di seguito. Per una procedura dettagliata completa di questo esempio, vedere l'esercitazione procedura dettagliata sull'API Elements.

Quando l'utente preme la cella della tabella inferiore, viene eseguito il codice nella funzione anonima, scrivendo il valore dall'istanza nel riquadro Output dell'applicazione element in Visual Studio per Mac.

Elementi predefiniti

MT. D viene fornito con una serie di elementi delle celle di tabella predefiniti noti come Elementi. Questi elementi vengono usati per visualizzare un'ampia gamma di tipi diversi nelle celle di tabella, ad esempio stringhe, float, date e persino immagini, per citarne solo alcuni. Ogni elemento si occupa della visualizzazione appropriata del tipo di dati. Ad esempio, un elemento booleano visualizzerà un interruttore per attivarne il valore. Analogamente, un elemento float visualizzerà un dispositivo di scorrimento per modificare il valore float.

Sono disponibili elementi ancora più complessi per supportare tipi di dati più avanzati, ad esempio immagini e html. Ad esempio, un elemento html, che aprirà un UIWebView per caricare una pagina Web quando selezionata, visualizza una didascalia nella cella della tabella.

Utilizzo dei valori degli elementi

Gli elementi utilizzati per acquisire l'input dell'utente espongono una proprietà pubblica Value che contiene il valore corrente dell'elemento in qualsiasi momento. Viene aggiornato automaticamente quando l'utente usa l'applicazione.

Questo è il comportamento per tutti gli elementi che fanno parte di MonoTouch.Dialog, ma non è necessario per gli elementi creati dall'utente.

Elemento String

Un StringElement oggetto mostra una didascalia sul lato sinistro di una cella della tabella e il valore stringa sul lato destro della cella.

Per usare un oggetto StringElement come pulsante, specificare un delegato.

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

Elemento String con stile

Un StyledStringElement consente di presentare stringhe utilizzando stili di cella di tabella predefiniti o con formattazione personalizzata.

La StyledStringElement classe deriva da StringElement, ma consente agli sviluppatori di personalizzare alcune proprietà, ad esempio Font, colore del testo, colore della cella di sfondo, modalità di interruzione della riga, numero di righe da visualizzare e se deve essere visualizzato un accessorio.

Elemento multilinea

Elemento Entry

, EntryElementcome suggerisce il nome, viene usato per ottenere l'input dell'utente. Supporta stringhe regolari o password, in cui i caratteri sono nascosti.

Viene inizializzato con tre valori:

Didascalia per la voce che verrà visualizzata all'utente.
Testo segnaposto (testo disattivato che fornisce un suggerimento all'utente).
Valore del testo.

Il segnaposto e il valore possono essere Null. Tuttavia, la didascalia è obbligatoria.

In qualsiasi momento, l'accesso alla relativa proprietà Value può recuperare il valore di EntryElement.

Inoltre, la KeyboardType proprietà può essere impostata in fase di creazione sullo stile del tipo di tastiera desiderato per la voce di dati. Può essere usato per configurare la tastiera usando i valori di UIKeyboardType come indicato di seguito:

Numerico
Telefono
Url
E-mail

Elemento booleano

Elemento Checkbox

Elemento Radio

Un RadioElement oggetto deve RadioGroup essere specificato in RootElement.

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

RootElements vengono usati anche per coordinare gli elementi radio. I RadioElement membri possono estendersi su più sezioni( ad esempio per implementare qualcosa di simile al selettore del tono dell'anello e separare i toni degli anelli personalizzati dalle suonerie di sistema). La visualizzazione riepilogo mostrerà l'elemento radio attualmente selezionato. Per usarlo, creare RootElement con il costruttore di gruppo, come illustrato di seguito:

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

Il nome del gruppo in RadioGroup viene usato per visualizzare il valore selezionato nella pagina contenitore (se presente) e il valore, che in questo caso è zero, è l'indice del primo elemento selezionato.

Elemento Badge

Elemento Float

Elemento Activity

Elemento Date

Quando viene selezionata la cella corrispondente a DateElement, viene visualizzata una selezione data, come illustrato di seguito:

Elemento Time

Quando viene selezionata la cella corrispondente a TimeElement, viene visualizzata una selezione ora, come illustrato di seguito:

Elemento DateTime

Quando viene selezionata la cella corrispondente a DateTimeElement, viene visualizzata una selezione datetime, come illustrato di seguito:

Elemento HTML

HTMLElement Visualizza il valore della relativa Caption proprietà nella cella della tabella. Whe selezionato, l'oggetto Url assegnato all'elemento viene caricato in un UIWebView controllo come illustrato di seguito:

Elemento messaggio

Carica altro elemento

Usare questo elemento per consentire agli utenti di caricare più elementi nell'elenco. È possibile personalizzare le didascalie normali e caricate, nonché il colore del carattere e del testo. L'indicatore UIActivity avvia l'animazione e la didascalia di caricamento viene visualizzata quando un utente tocca la cella e quindi viene eseguita l'istruzione NSAction passata al costruttore. Al termine del codice in , l'indicatore interrompe l'animazione NSAction UIActivity e la didascalia normale viene visualizzata di nuovo.

Elemento UIView

Inoltre, qualsiasi personalizzato UIView può essere visualizzato usando .UIViewElement

Elemento Owner-Drawn

Questo elemento deve essere sottoclassato perché è una classe astratta. È consigliabile eseguire l'override del Height(RectangleF bounds) metodo in cui restituire l'altezza dell'elemento, nonché Draw(RectangleF bounds, CGContext context, UIView view) in cui è necessario eseguire tutto il disegno personalizzato all'interno dei limiti specificati, usando il contesto e i parametri di visualizzazione. Questo elemento esegue l'aumento elevato della sottoclassazione di un UIViewoggetto e lo inserisce nella cella da restituire, lasciando solo necessario implementare due semplici override. È possibile visualizzare un'implementazione di esempio migliore nell'app di esempio nel DemoOwnerDrawnElement.cs file .

Ecco un esempio molto semplice di implementazione della classe :

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

JsonElement è una sottoclasse di RootElement che estende un RootElement oggetto per poter caricare il contenuto dell'elemento figlio annidato da un URL locale o remoto.

JsonElement è un oggetto RootElement di cui è possibile creare un'istanza in due forme. Una versione crea un oggetto RootElement che caricherà il contenuto su richiesta. Questi vengono creati usando i JsonElement costruttori che accettano un argomento aggiuntivo alla fine, l'URL da cui caricare il contenuto:

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

L'altro modulo crea i dati da un file locale o da un esistente System.Json.JsonObject già analizzato:

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

Per altre informazioni sull'uso di JSON con MT. D, vedere l'esercitazione dettagliata sull'elemento JSON.

Altre funzionalità

Supporto per l'aggiornamento tramite trascinamento verso il basso

Pull-to-Refresh è un effetto visivo originariamente trovato nell'app Tweetie2, che è diventato un effetto popolare tra molte applicazioni.

Per aggiungere il supporto automatico da pull a aggiornamento alle finestre di dialogo, è sufficiente eseguire due operazioni: associare un gestore eventi per ricevere una notifica quando l'utente esegue il pull dei dati e notifica DialogViewController quando i dati sono stati caricati per tornare allo stato predefinito.

L'associazione di una notifica è semplice; è sufficiente connettersi all'evento RefreshRequested in DialogViewController, come illustrato di seguito:

dvc.RefreshRequested += OnUserRequestedRefresh;

Quindi, nel metodo OnUserRequestedRefresh, si accoderebbe il caricamento di alcuni dati, si richiedevano alcuni dati dalla rete o si spin un thread per calcolare i dati. Dopo aver caricato i dati, è necessario notificare DialogViewController che i nuovi dati si trovano e ripristinare lo stato predefinito della visualizzazione, è necessario chiamare ReloadComplete:

dvc.ReloadComplete ();

Supporto per la ricerca

Per supportare la ricerca, impostare la EnableSearch proprietà su DialogViewController. È anche possibile impostare la SearchPlaceholder proprietà da utilizzare come testo della filigrana nella barra di ricerca.

La ricerca modificherà il contenuto della visualizzazione man mano che l'utente digita. Esegue una ricerca nei campi visibili e mostra quelli all'utente. DialogViewController espone tre metodi per avviare, terminare o attivare a livello di codice una nuova operazione di filtro sui risultati. Questi metodi sono elencati di seguito:

StartSearch
FinishSearch
PerformFilter

Il sistema è estendibile, quindi è possibile modificare questo comportamento, se necessario.

Caricamento di immagini di sfondo

MonoTouch.Dialog incorpora il caricatore di immagini dell'applicazione TweetStation . Questo caricatore di immagini può essere usato per caricare immagini in background, supporta la memorizzazione nella cache e può notificare al codice quando l'immagine è stata caricata.

Limiterà anche il numero di connessioni di rete in uscita.

Il caricatore di immagini viene implementato nella ImageLoader classe , tutto quello che devi fare è chiamare il DefaultRequestImage metodo , dovrai fornire l'URI per l'immagine che vuoi caricare, nonché un'istanza dell'interfaccia IImageUpdated che verrà richiamata quando l'immagine è stata caricata.

Ad esempio, il codice seguente carica un'immagine da un URL in :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 classe ImageLoader espone un metodo Purge che è possibile chiamare quando si desidera rilasciare tutte le immagini attualmente memorizzate nella cache. Il codice corrente ha una cache per 50 immagini. Se si vuole usare una dimensione della cache diversa ( ad esempio, se si prevede che le immagini siano troppo grandi che 50 immagini sarebbero troppo grandi), è sufficiente creare istanze di ImageLoader e passare il numero di immagini che si desidera mantenere nella cache.

Uso di LINQ to Create Element Hierarchy

Tramite l'uso intelligente della sintassi di inizializzazione di LINQ e C#, LINQ può essere usato per creare una gerarchia di elementi. Ad esempio, il codice seguente crea una schermata da alcune matrici di stringhe e gestisce la selezione delle celle tramite una funzione anonima passata a ogni 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"); })
    }
};

Questa operazione può essere facilmente combinata con un archivio dati o dati XML da un database per creare applicazioni complesse quasi interamente dai dati.

Estensione di MT. D

Creazione di elementi personalizzati

È possibile creare un elemento personalizzato ereditando da un elemento esistente o derivando dall'elemento della classe radice.

Per creare un elemento personalizzato, è necessario eseguire l'override dei metodi seguenti:

// 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);

Se l'elemento può avere una dimensione variabile, è necessario implementare l'interfaccia IElementSizing , che contiene un metodo:

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

Se si prevede di implementare il GetCell metodo chiamando base.GetCell(tv) e personalizzando la cella restituita, è necessario eseguire anche l'override della CellKey proprietà per restituire una chiave che sarà univoca per l'elemento, come illustrato di seguito:

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

Questo comportamento funziona per la StringElement maggior parte degli elementi, ma non per e StyledStringElement , poiché questi usano il proprio set di chiavi per vari scenari di rendering. È necessario replicare il codice in tali classi.

DialogViewControllers (DVCs)

Sia la reflection che l'API Elements usano lo stesso DialogViewController. A volte si vuole personalizzare l'aspetto della visualizzazione o si potrebbe voler usare alcune funzionalità di UITableViewController che vanno oltre la creazione di interfacce utente di base.

DialogViewController è semplicemente una sottoclasse di UITableViewController e è possibile personalizzarla nello stesso modo in cui si personalizza un oggetto UITableViewController.

Ad esempio, se si desidera modificare lo stile dell'elenco in modo che sia Grouped o Plain, è possibile impostare questo valore modificando la proprietà quando si crea il controller, come illustrato di seguito:

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

Per personalizzazioni più avanzate di , ad esempio l'impostazione DialogViewControllerdello sfondo, è necessario sottoclassarla ed eseguire l'override dei metodi appropriati, come illustrato nell'esempio seguente:

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;
    }
}

Un altro punto di personalizzazione è costituito dai metodi virtuali seguenti in DialogViewController:

public override Source CreateSizingSource (bool unevenRows)

Questo metodo deve restituire una sottoclasse di DialogViewController.Source per i casi in cui le celle vengono ridimensionate uniformemente o una sottoclasse di DialogViewController.SizingSource se le celle non sono uniformi.

È possibile usare questa override per acquisire uno dei UITableViewSource metodi. Ad esempio, TweetStation usa questa opzione per tenere traccia di quando l'utente ha eseguito lo scorrimento verso l'alto e aggiornare di conseguenza il numero di tweet non letti.

Convalida

Gli elementi non forniscono la convalida stessa perché i modelli adatti per le pagine Web e le applicazioni desktop non eseguono il mapping diretto al modello di interazione iPhone.

Se si vuole eseguire la convalida dei dati, è necessario eseguire questa operazione quando l'utente attiva un'azione con i dati immessi. Ad esempio, un pulsante Fine o Avanti sulla barra degli strumenti superiore o alcuni StringElement usati come pulsante per passare alla fase successiva.

In questo caso è possibile eseguire la convalida di input di base e, ad esempio, una convalida più complessa, ad esempio la verifica della validità di una combinazione di utente/password con un server.

La modalità di notifica all'utente di un errore è specifica dell'applicazione. È possibile visualizzare un UIAlertView suggerimento o visualizzare un suggerimento.

Riepilogo

Questo articolo ha illustrato molte informazioni su MonoTouch.Dialog. Ha discusso i concetti fondamentali del modo in cui mt. D funziona e ha trattato i vari componenti che comprendono MT.D. Ha inoltre mostrato l'ampia gamma di elementi e personalizzazioni delle tabelle supportate da MT. D e ha discusso come MT. D può essere esteso con elementi personalizzati. È stato illustrato anche il supporto JSON in MT. D che consente di creare elementi in modo dinamico da JSON.

Condividi tramite