Présentation de MonoTouch.Dialog pour Xamarin.iOS

Article
07/13/2023

MonoTouch.Dialog, appelé MT. D pour faire court, est une boîte à outils de développement rapide de l’interface utilisateur qui permet aux développeurs de créer des écrans d’application et de la navigation à l’aide d’informations, plutôt que de créer des contrôleurs de vue, des tables, etc. Par conséquent, il simplifie considérablement le développement de l’interface utilisateur et la réduction du code. Par exemple, considérez la capture d’écran suivante :

Le code suivant a été utilisé pour définir l’ensemble de cet écran :

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

Lorsque vous travaillez avec des tables dans iOS, il existe souvent une tonne de code répétitoire. Par exemple, chaque fois qu’une table est nécessaire, une source de données est nécessaire pour remplir cette table. Dans une application qui a deux écrans basés sur des tables qui sont connectés via un contrôleur de navigation, chaque écran partage une grande partie du même code.

MT. D simplifie cela en encapsulant tout ce code dans une API générique pour la création de tables. Il fournit ensuite une abstraction par-dessus cette API qui permet une syntaxe de liaison d’objet déclarative qui le rend encore plus facile. Par conséquent, deux API sont disponibles dans MT. D:

API d’éléments de bas niveau : l’API Elements est basée sur la création d’une arborescence hiérarchique d’éléments qui représentent les écrans et leurs composants. L’API Elements offre aux développeurs le plus de flexibilité et de contrôle lors de la création d’interfaces utilisateur. En outre, l’API Elements offre une prise en charge avancée de la définition déclarative via JSON, ce qui permet une déclaration incroyablement rapide, ainsi que la génération d’interface utilisateur dynamique à partir d’un serveur.
API de réflexion de haut niveau : également appelée APIde liaison , dans laquelle les classes sont annotées avec des indicateurs d’interface utilisateur, puis mt. D crée automatiquement des écrans en fonction des objets et fournit une liaison entre ce qui est affiché (et éventuellement modifié) à l’écran et le stockage de l’objet sous-jacent. L’exemple ci-dessus illustre l’utilisation de l’API Reflection. Cette API ne fournit pas le contrôle affiné que l’API d’éléments effectue, mais elle réduit la complexité encore plus en créant automatiquement la hiérarchie d’éléments en fonction des attributs de classe.

MT. D est fourni avec un grand ensemble d’éléments d’interface utilisateur intégrés pour la création d’écran, mais il reconnaît également la nécessité d’éléments personnalisés et de dispositions d’écran avancées. Par conséquent, l’extensibilité est une option de première classe intégrée à l’API. Les développeurs peuvent étendre les éléments existants ou en créer de nouveaux, puis les intégrer en toute transparence.

En outre, MT. D dispose d’un certain nombre de fonctionnalités d’expérience utilisateur iOS courantes intégrées, telles que la prise en charge de l’extraction pour actualiser, le chargement asynchrone d’images et la prise en charge de la recherche.

Cet article présente une vue d’ensemble de l’utilisation de MT. D, y compris :

MT. Composants D : il s’agit de comprendre les classes qui composent MT. D pour permettre une mise à jour rapide.
Référence d’éléments : liste complète des éléments intégrés de MT.D.
Utilisation avancée : elle couvre les fonctionnalités avancées telles que l’extraction pour actualiser, la recherche, le chargement d’images d’arrière-plan, l’utilisation de LINQ pour créer des hiérarchies d’éléments et la création d’éléments, de cellules et de contrôleurs personnalisés à utiliser avec MT.D.

Configuration de MT. D

MT. D est distribué avec Xamarin.iOS. Pour l’utiliser, cliquez avec le bouton droit sur le nœud Références d’un projet Xamarin.iOS dans Visual Studio 2017 ou Visual Studio pour Mac et ajoutez une référence à l’assembly MonoTouch.Dialog-1. using MonoTouch.Dialog Ajoutez ensuite des instructions dans votre code source si nécessaire.

Comprendre les pièces de mt. D

Même lors de l’utilisation de l’API Reflection, MT. D crée une hiérarchie d’éléments sous le capot, comme si elle était créée directement via l’API Elements. En outre, la prise en charge DE JSON mentionnée dans la section précédente crée également Des éléments. Pour cette raison, il est important d’avoir une compréhension de base des éléments constitutifs de MT.D.

MT. D génère des écrans à l’aide des quatre parties suivantes :

DialogViewController
RootElement
Section
Element

DialogViewController

Un Objet DialogViewController, ou DVC en abrégé, hérite de UITableViewController et représente donc un écran avec un tableau. Les DVM peuvent être poussés sur un contrôleur de navigation comme un UITableViewController standard.

RootElement

RootElement est le conteneur de niveau supérieur pour les éléments qui entrent dans un DVC. Il contient des sections, qui peuvent ensuite contenir des éléments. Les éléments RootElements ne sont pas affichés ; au lieu de cela, il s’agit simplement de conteneurs pour ce qui est réellement rendu. Un RootElement est affecté à un DVC, puis le DVC restitue ses enfants.

Section

Une section est un groupe de cellules d’un tableau. Comme avec une section de tableau normale, elle peut éventuellement avoir un en-tête et un pied de page qui peuvent être du texte, ou même des vues personnalisées, comme dans la capture d’écran suivante :

Élément

Un élément représente une cellule réelle dans le tableau. MT. D est fourni avec une grande variété d’éléments qui représentent différents types de données ou différentes entrées. Par exemple, les captures d’écran suivantes illustrent quelques-uns des éléments disponibles :

En savoir plus sur Sections et RootElements

Nous allons maintenant aborder plus en détail RootElements et Sections.

RootElements

Au moins un élément RootElement est requis pour démarrer le processus MonoTouch.Dialog.

Si un élément RootElement est initialisé avec une valeur section/élément, cette valeur est utilisée pour localiser un élément enfant qui fournira un résumé de la configuration, qui est affiché sur le côté droit de l’affichage. Par exemple, la capture d’écran ci-dessous montre un tableau à gauche avec une cellule contenant le titre de l’écran de détails à droite, « Dessert », ainsi que la valeur du désert sélectionné.

Les éléments racines peuvent également être utilisés dans Sections pour déclencher le chargement d’une nouvelle page de configuration imbriquée, comme indiqué ci-dessus. Lorsqu’il est utilisé dans ce mode, le légende fourni est utilisé lors du rendu à l’intérieur d’une section et est également utilisé comme titre pour la sous-page. Par exemple :

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

Dans l’exemple ci-dessus, lorsque l’utilisateur appuie sur « Dessert », MonoTouch.Dialog crée une page et y accède avec la racine « Dessert » et un groupe de radios avec trois valeurs.

Dans cet exemple particulier, le groupe radio sélectionnera « Chocolate Cake » dans la section « Dessert », car nous avons passé la valeur « 2 » au RadioGroup. Cela signifie que vous choisissez le 3e élément de la liste (index zéro).

L’appel de la méthode Add ou l’utilisation de la syntaxe d’initialiseur C# 4 ajoute des sections. Les méthodes Insert sont fournies pour insérer des sections avec une animation.

Si vous créez l’élément RootElement avec un groupe instance (au lieu d’un RadioGroup), la valeur récapitulative de RootElement lorsqu’elle est affichée dans une section correspond au nombre cumulé de tous les éléments BooleanElements et CheckboxElements qui ont la même clé que la valeur Group.Key.

Sections

Les sections sont utilisées pour regrouper des éléments dans l’écran et ce sont les seuls enfants directs valides de RootElement. Les sections peuvent contenir n’importe quel élément standard, y compris de nouveaux rootElements.

Les éléments RootElements incorporés dans une section sont utilisés pour accéder à un nouveau niveau plus profond.

Les sections peuvent avoir des en-têtes et des pieds de page sous forme de chaînes ou d’UIViews. En règle générale, vous utilisez simplement les chaînes, mais pour créer des interfaces utilisateur personnalisées, vous pouvez utiliser n’importe quel UIView comme en-tête ou pied de page. Vous pouvez utiliser une chaîne pour les créer comme suit :

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

Pour utiliser des vues, il suffit de passer les vues au constructeur :

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

Notification

Gestion de NSAction

MT. D expose un NSAction en tant que délégué pour la gestion des rappels. Par exemple, supposons que vous souhaitiez gérer un événement tactile pour une cellule de tableau créée par MT.D. Lors de la création d’un élément avec MT. D, fournissez simplement une fonction de rappel, comme indiqué ci-dessous :

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

Récupération d’une valeur d’élément

Combiné avec la Element.Value propriété , le rappel peut récupérer la valeur définie dans d’autres éléments. Considérons par exemple le code suivant :

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

Ce code crée une interface utilisateur comme indiqué ci-dessous. Pour obtenir une procédure pas à pas complète de cet exemple, consultez le didacticiel sur la procédure pas à pas de l’API Elements .

Lorsque l’utilisateur appuie sur la cellule du tableau inférieur, le code de la fonction anonyme s’exécute, en écrivant la valeur de l’instance element dans le panneau Sortie de l’application dans Visual Studio pour Mac.

éléments Built-In

MT. D est fourni avec un certain nombre d’éléments de cellule de tableau intégrés appelés Éléments. Ces éléments sont utilisés pour afficher différents types dans des cellules de tableau, comme des chaînes, des floats, des dates et même des images, pour n’en citer que quelques-uns. Chaque élément s’occupe d’afficher le type de données de manière appropriée. Par exemple, un élément booléen affiche un commutateur pour activer/désactiver sa valeur. De même, un élément float affiche un curseur pour modifier la valeur float.

Il existe des éléments encore plus complexes pour prendre en charge des types de données plus riches, tels que des images et du code html. Par exemple, un élément html, qui ouvre un UIWebView pour charger une page web lorsqu’il est sélectionné, affiche un légende dans la cellule du tableau.

Utilisation des valeurs d’élément

Les éléments utilisés pour capturer l’entrée utilisateur exposent une propriété publique Value qui contient la valeur actuelle de l’élément à tout moment. Il est automatiquement mis à jour à mesure que l’utilisateur utilise l’application.

Il s’agit du comportement de tous les éléments qui font partie de MonoTouch.Dialog, mais il n’est pas requis pour les éléments créés par l’utilisateur.

String, élément

Un StringElement affiche un légende sur le côté gauche d’une cellule de tableau et la valeur de chaîne sur le côté droit de la cellule.

Pour utiliser un StringElement en tant que bouton, fournissez un délégué.

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

Élément String styled

Un StyledStringElement permet de présenter des chaînes à l’aide de styles de cellules de tableau intégrés ou avec une mise en forme personnalisée.

La StyledStringElement classe dérive de StringElement, mais permet aux développeurs de personnaliser une poignée de propriétés telles que la police, la couleur du texte, la couleur de cellule d’arrière-plan, le mode de saut de ligne, le nombre de lignes à afficher et si un accessoire doit être affiché.

Élément multiligne

Élément d'entrée

, EntryElementcomme son nom l’indique, est utilisé pour obtenir l’entrée utilisateur. Il prend en charge les chaînes régulières ou les mots de passe, où les caractères sont masqués.

Il est initialisé avec trois valeurs :

Le légende de l’entrée qui sera présentée à l’utilisateur.
Texte d’espace réservé (il s’agit du texte grisé qui fournit un indicateur à l’utilisateur).
Valeur de texte.

L’espace réservé et la valeur peuvent être null. Toutefois, le légende est obligatoire.

À tout moment, l’accès à sa propriété Value peut récupérer la valeur de .EntryElement

En outre, la KeyboardType propriété peut être définie au moment de la création sur le style de type de clavier souhaité pour l’entrée de données. Vous pouvez l’utiliser pour configurer le clavier à l’aide des valeurs de UIKeyboardType comme indiqué ci-dessous :

Numérique
Téléphone
Url
E-mail

Boolean, élément

Élément De case à cocher

Élément Radio

Un RadioElement nécessite qu’un RadioGroup soit spécifié dans le RootElement.

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

RootElements sont également utilisés pour coordonner des éléments radio. Les RadioElement membres peuvent s’étendre sur plusieurs sections (par exemple pour implémenter un élément similaire au sélecteur de tonalités d’anneau et séparer les sonneries personnalisées des sonneries système). La vue Résumé affiche l’élément radio actuellement sélectionné. Pour l’utiliser, créez avec RootElement le constructeur de groupe, comme suit :

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

Le nom du groupe dans RadioGroup est utilisé pour afficher la valeur sélectionnée dans la page contenante (le cas échéant) et la valeur, qui est zéro dans ce cas, est l’index du premier élément sélectionné.

Badge, élément

Float, élément

Élément Activity

Élément Date

Lorsque la cellule correspondant à l’élément DateElement est sélectionnée, un sélecteur de dates est présenté comme indiqué ci-dessous :

Élément Time

Lorsque la cellule correspondant à l’élément TimeElement est sélectionnée, un sélecteur d’heure est présenté comme indiqué ci-dessous :

DateTime, élément

Lorsque la cellule correspondant à l’élément DateTimeElement est sélectionnée, un sélecteur datetime est présenté comme indiqué ci-dessous :

Élément HTML

affiche HTMLElement la valeur de sa Caption propriété dans la cellule de tableau. Whe sélectionné, le Url affecté à l’élément est chargé dans un UIWebView contrôle comme indiqué ci-dessous :

Élément Message

Load More, élément

Utilisez cet élément pour permettre aux utilisateurs de charger davantage d’éléments dans votre liste. Vous pouvez personnaliser les légendes normales et de chargement, ainsi que la police et la couleur du texte. L’indicateur UIActivity démarre l’animation et le légende de chargement s’affiche lorsqu’un utilisateur appuie sur la cellule, puis que le NSAction transmis au constructeur est exécuté. Une fois votre code dans le NSAction est terminé, l’indicateur UIActivity cesse d’animer et le légende normal s’affiche à nouveau.

UIView, élément

En outre, n’importe quel personnalisé UIView peut être affiché à l’aide de UIViewElement.

Owner-Drawn, élément

Cet élément doit être sous-classé, car il s’agit d’une classe abstraite. Vous devez remplacer la Height(RectangleF bounds) méthode dans laquelle vous devez retourner la hauteur de l’élément, ainsi que Draw(RectangleF bounds, CGContext context, UIView view) dans laquelle vous devez effectuer tout votre dessin personnalisé dans les limites données, à l’aide des paramètres de contexte et d’affichage. Cet élément effectue la lourde opération consistant à sous-classer un UIViewet à le placer dans la cellule à retourner, ce qui vous laisse seulement besoin d’implémenter deux remplacements simples. Vous pouvez voir un meilleur exemple d’implémentation dans l’exemple d’application dans le DemoOwnerDrawnElement.cs fichier .

Voici un exemple très simple d’implémentation de la 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;
    }
}

JSON, élément

est JsonElement une sous-classe de RootElement qui étend un RootElement pour pouvoir charger le contenu d’un enfant imbriqué à partir d’une URL locale ou distante.

est JsonElement un RootElement qui peut être instancié sous deux formes. Une version crée un RootElement qui charge le contenu à la demande. Ceux-ci sont créés à l’aide JsonElement des constructeurs qui prennent un argument supplémentaire à la fin, l’URL à partir de laquelle charger le contenu :

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

L’autre formulaire crée les données à partir d’un fichier local ou d’un fichier existant System.Json.JsonObject que vous avez déjà analysé :

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

Pour plus d’informations sur l’utilisation de JSON avec MT. D, consultez le tutoriel de procédure pas à pas sur les éléments JSON .

Autres fonctionnalités

Prise en charge de l’extraction pour actualiser

Pull-to-Refresh est un effet visuel trouvé à l’origine dans l’application Tweetie2, qui est devenu un effet populaire parmi de nombreuses applications.

Pour ajouter la prise en charge automatique de l’extraction pour actualiser à vos boîtes de dialogue, vous devez uniquement effectuer deux opérations : raccorder un gestionnaire d’événements pour être averti lorsque l’utilisateur extrait les données et notifier le DialogViewController quand les données ont été chargées pour revenir à leur état par défaut.

Le branchement d’une notification est simple ; connectez-vous simplement à l’événement RefreshRequested sur le DialogViewController, comme suit :

dvc.RefreshRequested += OnUserRequestedRefresh;

Ensuite, sur votre méthode OnUserRequestedRefresh, vous devez mettre en file d’attente certains chargements de données, demander des données à partir du réseau ou faire tourner un thread pour calculer les données. Une fois les données chargées, vous devez informer le DialogViewController que les nouvelles données sont dans, et pour restaurer la vue à son état par défaut, vous devez le faire en appelant ReloadComplete:

dvc.ReloadComplete ();

Support de recherche

Pour prendre en charge la recherche, définissez la EnableSearch propriété sur votre DialogViewController. Vous pouvez également définir la SearchPlaceholder propriété à utiliser comme texte en filigrane dans la barre de recherche.

La recherche modifie le contenu de l’affichage en fonction des types d’utilisateur. Il recherche les champs visibles et les affiche à l’utilisateur. Le DialogViewController expose trois méthodes pour lancer, arrêter ou déclencher par programmation une nouvelle opération de filtre sur les résultats. Ces méthodes sont répertoriées ci-dessous :

StartSearch
FinishSearch
PerformFilter

Le système étant extensible, vous pouvez modifier ce comportement si vous le souhaitez.

Chargement d’images d’arrière-plan

MonoTouch.Dialog intègre le chargeur d’images de l’application TweetStation . Ce chargeur d’images peut être utilisé pour charger des images en arrière-plan, prend en charge la mise en cache et peut notifier votre code lorsque l’image a été chargée.

Il limite également le nombre de connexions réseau sortantes.

Le chargeur d’images est implémenté dans la ImageLoader classe. Il vous suffit d’appeler la DefaultRequestImage méthode. Vous devez fournir l’URI de l’image que vous souhaitez charger, ainsi qu’une instance de l’interface IImageUpdated qui sera appelée une fois l’image chargée.

Par exemple, le code suivant charge une image d’une URL dans un 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 expose une méthode Purge que vous pouvez appeler lorsque vous souhaitez libérer toutes les images actuellement mises en cache en mémoire. Le code actuel a un cache pour 50 images. Si vous souhaitez utiliser une autre taille de cache (pour instance, si vous vous attendez à ce que les images soient trop volumineuses pour que 50 images soient trop importantes), vous pouvez simplement créer des instances d’ImageLoader et passer le nombre d’images que vous souhaitez conserver dans le cache.

Utilisation de LINQ pour créer une hiérarchie d’éléments

Grâce à l’utilisation intelligente de la syntaxe d’initialisation de LINQ et C#, LINQ peut être utilisé pour créer une hiérarchie d’éléments. Par exemple, le code suivant crée un écran à partir de certains tableaux de chaînes et gère la sélection des cellules via une fonction anonyme qui est passée dans chaque 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"); })
    }
};

Cela peut facilement être combiné avec un magasin de données XML ou des données d’une base de données pour créer des applications complexes presque entièrement à partir de données.

Extension de mt. D

Création d’éléments personnalisés

Vous pouvez créer votre propre élément en hériter d’un élément existant ou en dérivant de la classe racine Element.

Pour créer votre propre élément, vous devez remplacer les méthodes suivantes :

// 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 votre élément peut avoir une taille variable, vous devez implémenter l’interface IElementSizing , qui contient une méthode :

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

Si vous envisagez d’implémenter votre GetCell méthode en appelant base.GetCell(tv) et en personnalisant la cellule retournée, vous devez également remplacer la CellKey propriété pour renvoyer une clé qui sera unique à votre élément, comme suit :

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

Cela fonctionne pour la plupart des éléments, mais pas pour et StringElementStyledStringElement , car ceux-ci utilisent leur propre ensemble de clés pour différents scénarios de rendu. Vous devez répliquer le code dans ces classes.

DialogViewControllers (DCS)

L’API Reflection et Elements utilisent le même DialogViewController. Parfois, vous voudrez personnaliser l’apparence de la vue ou vous pouvez utiliser certaines fonctionnalités du qui vont au-delà de UITableViewController la création de base des interfaces utilisateur.

le DialogViewController est simplement une sous-classe de et UITableViewController vous pouvez le personnaliser de la même manière que vous le feriez pour personnaliser un UITableViewController.

Par exemple, si vous souhaitez modifier le style de liste pour qu’il soit Grouped ou Plain, vous pouvez définir cette valeur en modifiant la propriété lorsque vous créez le contrôleur, comme suit :

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

Pour des personnalisations plus avancées de , telles que la DialogViewControllerdéfinition de son arrière-plan, vous devez le sous-classer et remplacer les méthodes appropriées, comme indiqué dans l’exemple ci-dessous :

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 autre point de personnalisation est les méthodes virtuelles suivantes dans le DialogViewController:

public override Source CreateSizingSource (bool unevenRows)

Cette méthode doit retourner une sous-classe de DialogViewController.Source pour les cas où vos cellules sont uniformément dimensionnées, ou une sous-classe de DialogViewController.SizingSource si vos cellules sont inégales.

Vous pouvez utiliser ce remplacement pour capturer l’une UITableViewSource des méthodes. Par exemple, TweetStation l’utilise pour suivre quand l’utilisateur a fait défiler vers le haut et mettre à jour en conséquence le nombre de tweets non lus.

Validation

Les éléments ne fournissent pas de validation eux-mêmes, car les modèles bien adaptés aux pages web et aux applications de bureau ne sont pas mappés directement au modèle d’interaction iPhone.

Si vous souhaitez effectuer la validation des données, vous devez effectuer cette opération lorsque l’utilisateur déclenche une action avec les données entrées. Par exemple, un bouton Terminé ou Suivant dans la barre d’outils supérieure, ou un StringElement bouton utilisé comme bouton pour passer à l’étape suivante.

C’est là que vous effectuez une validation d’entrée de base, et peut-être plus compliquée, comme la vérification de la validité d’une combinaison utilisateur/mot de passe avec un serveur.

La façon dont vous informez l’utilisateur d’une erreur est propre à l’application. Vous pouvez afficher un UIAlertView indicateur ou afficher un indicateur.

Résumé

Cet article a couvert de nombreuses informations sur MonoTouch.Dialog. Il a abordé les principes fondamentaux de la méthode mt. D fonctionne et couvre les différents composants qui composent MT.D. Il a également montré le large éventail d’éléments et de personnalisations de table prises en charge par MT. D et discuté de la façon dont mt. D peut être étendu avec des éléments personnalisés. En outre, il a expliqué la prise en charge JSON dans MT. D qui permet de créer des éléments dynamiquement à partir de JSON.

Partager via