Présentation de MonoTouch.Dialog pour Xamarin.iOS

Article
11/25/2015

MonoTouch.Dialog, appelé MT. D pour un court terme, est un kit de développement rapide de l’interface utilisateur qui permet aux développeurs de créer des écrans d’application et la navigation à l’aide d’informations, plutôt que de la tédium de la création de contrôleurs de vue, de tables, etc. Par conséquent, il offre une simplification significative du développement de l’interface utilisateur et de la réduction du code. Par exemple, considérez la capture d’écran suivante :

Le code suivant a été utilisé pour définir l’intégralité de l’é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 y a 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 une table connectés via un contrôleur de navigation, chaque écran partage beaucoup de code.

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

API É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 la plus grande flexibilité et le contrôle de la création d’interfaces utilisateur. En outre, l’API Elements a une prise en charge avancée de la définition déclarative via JSON, ce qui permet à la fois une déclaration incroyablement rapide, ainsi que la génération dynamique d’interface utilisateur à partir d’un serveur.
API de réflexion de haut niveau : également appelée API binding, dans laquelle les classes sont annotées avec des indicateurs d’interface utilisateur, puis MT. D crée automatiquement des écrans basés sur les objets et fournit une liaison entre ce qui est affiché (et éventuellement modifié) à l’écran et le stockage d’objets sous-jacents. L’exemple ci-dessus illustre l’utilisation de l’API Reflection. Cette API ne fournit pas le contrôle précis que l’API d’éléments effectue, mais elle réduit encore davantage la complexité 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 valeur 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 s’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 « pull-to-refresh », le chargement d’images asynchrones et la prise en charge de la recherche.

Cet article présente un aperçu complet de l’utilisation de MT. D, notamment :

MT. Composants D : cela se concentre sur la compréhension des classes qui composent MT. D pour permettre de monter en puissance rapidement.
Informations de référence sur les éléments : liste complète des éléments intégrés de MT.D.
Utilisation avancée : cela couvre les fonctionnalités avancées telles que l’extraction à actualisation, la recherche, le chargement d’images d’arrière-plan, l’utilisation de LINQ pour générer des hiérarchies d’éléments et créer des éléments personnalisés, des cellules et des contrôleurs à 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. Ensuite, ajoutez using MonoTouch.Dialog des instructions dans votre code source si nécessaire.

Comprendre les morceaux 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 s’il a été créé directement via l’API Elements. En outre, la prise en charge 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 parties constituantes de MT.D.

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

DialogViewController
RootElement
Section
Element

DialogViewController

Un DialogViewController, ou DVC pour un court terme, hérite UITableViewController et représente donc un écran avec une table. Les contrôleurs de domaine peuvent être envoyés (push) sur un contrôleur de navigation comme un UITableViewController standard.

RootElement

Un 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 rootElements ne sont pas rendus ; Au lieu de cela, ils sont simplement des 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 table normale, il peut éventuellement avoir un en-tête et un pied de page qui peuvent être du texte, voire 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 :

Plus d’informations sur les sections et rootElements

Examinons maintenant les éléments rootelements et les sections plus en détail.

RootElements

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

Si un RootElement est initialisé avec une valeur de section/élément, cette valeur est utilisée pour localiser un élément enfant qui fournit un résumé de la configuration, qui est rendu 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étail à droite, « Dessert », ainsi que la valeur du désert sélectionné.

Les éléments racines peuvent également être utilisés à l’intérieur des sections pour déclencher le chargement d’une nouvelle page de configuration imbriquée, comme indiqué ci-dessus. Lorsqu’elle est utilisée dans ce mode, la légende fournie est utilisée lors du rendu à l’intérieur d’une section et est également utilisée 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 accède à celle-ci avec la racine « Dessert » et dispose d’un groupe radio avec trois valeurs.

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

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 rootElement avec une instance de groupe (au lieu d’un Groupe RadioGroup), la valeur récapitulative de RootElement affichée dans une section est le nombre cumulé de tous les éléments BooleanElements et Cases à cocher 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 sont les seuls enfants directs valides du RootElement. Les sections peuvent contenir l’un des éléments standard, y compris les nouveaux RootElements.

Les rootElements incorporés dans une section sont utilisés pour accéder à un nouveau niveau plus approfondi.

Les sections peuvent avoir des en-têtes et des pieds de page sous forme de chaînes, ou en tant que UIViews. En règle générale, vous allez simplement utiliser 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, passez simplement les vues au constructeur :

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

Recevoir une notification

Gestion de NSAction

MT. D surface un NSAction délégué pour la gestion des rappels. Par exemple, supposons que vous souhaitez gérer un événement tactile pour une cellule de table créée par MT.D. Lors de la création d’un élément avec MT. D, il vous suffit de fournir une fonction de rappel, comme indiqué ci-dessous :

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

Récupération de la valeur de l’élément

Combiné à 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 de 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 dans le panneau Sortie de l’application element dans Visual Studio pour Mac.

Éléments intégrés

MT. D est fourni avec un certain nombre d’éléments de cellule de table intégrés appelés Éléments. Ces éléments sont utilisés pour afficher différents types dans des cellules de tableau telles que des chaînes, des floats, des dates et même des images, pour ne nommer que quelques-uns. Chaque élément s’occupe de l’affichage approprié du type de données. 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 encore des éléments 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 une légende dans la cellule de 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. Elle est automatiquement mise à jour lorsque 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 nécessaire pour les éléments créés par l’utilisateur.

String, élément

Une StringElement légende apparaît 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 bouton, fournissez un délégué.

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

Styled String, élément

Une StyledStringElement chaîne permet de présenter des chaînes à l’aide de styles de cellule 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 police, couleur de texte, couleur de cellule d’arrière-plan, mode saut de ligne, nombre de lignes à afficher et si un accessoire doit être affiché.

Élément multiligne

Élément Entry

Le EntryElementnom, comme l’indique le nom, est utilisé pour obtenir une entrée utilisateur. Il prend en charge les chaînes ou mots de passe standard, où les caractères sont masqués.

Il est initialisé avec trois valeurs :

Légende de l’entrée qui sera affiché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, la légende est requise.

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

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

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

Élément booléen

Case à cocher, élément

Élément Radio

Un RadioElement doit RadioGroup être spécifié dans le RootElement.

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

RootElements sont également utilisés pour coordonner les éléments radio. Les RadioElement membres peuvent s’étendre sur plusieurs sections (par exemple, pour implémenter quelque chose similaire au sélecteur de tonalité de sonnerie et séparer les tonalités de sonneries personnalisées à partir de sonneries système). La vue récapitulative affiche l’élément radio actuellement sélectionné. Pour l’utiliser, créez le RootElement 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 égale à zéro dans ce cas, est l’index du premier élément sélectionné.

Badge, élément

Float, élément

Élément Activity

Date, élément

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

Time, élément

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

DateTime, élément

Lorsque la cellule correspondant à 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. Le whe sélectionné, l’élément Url affecté 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 chargées, ainsi que la police et la couleur du texte. L’indicateur UIActivity démarre l’animation et la légende de chargement s’affiche lorsqu’un utilisateur appuie sur la cellule, puis le NSAction constructeur passé est exécuté. Une fois votre code terminé NSAction , l’indicateur UIActivity cesse d’animer et la légende normale s’affiche à nouveau.

UiView, élément

En outre, n’importe quelle personnalisée UIView peut être affichée à l’aide du UIViewElement.

Élément Owner-Drawn

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 le gros travail de sous-classe d’un UIView, et le place dans la cellule à retourner, ce qui vous laisse uniquement 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;
    }
}

Élément JSON

Il JsonElement s’agit d’une sous-classe qui RootElement étend une RootElement capacité à charger le contenu de l’enfant imbriqué à partir d’une URL locale ou distante.

C’est JsonElement un RootElement qui peut être instancié sous deux formes. Une version crée un RootElement qui charge le contenu à la demande. Celles-ci sont créées à l’aide des JsonElement 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 didacticiel de procédure pas à pas de l’élément JSON.

Autres fonctionnalités

Prise en charge de l’extraction vers l’actualisation

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 de l’extraction à actualisation automatique à vos boîtes de dialogue, vous devez uniquement effectuer deux opérations : connecter un gestionnaire d’événements pour être averti lorsque l’utilisateur extrait les données et avertit le DialogViewController moment où les données ont été chargées pour revenir à son état par défaut.

Le raccordement à une notification est simple ; connectez-vous simplement à l’événement sur l’événement RefreshRequested 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 net ou faire tourner un thread pour calculer les données. Une fois que les données ont été chargées, vous devez avertir que DialogViewController les nouvelles données se trouvent et restaurer l’affichage dans son état par défaut, vous devez le faire en appelant ReloadComplete:

dvc.ReloadComplete ();

Prise en charge de la 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 de filigrane dans la barre de recherche.

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

StartSearch
FinishSearch
PerformFilter

Le système est extensible. Vous pouvez donc modifier ce comportement si vous le souhaitez.

Chargement de l’image 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.

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

Le chargeur d’images est implémenté dans la ImageLoader classe, tout ce que vous devez faire est 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 lorsque l’image a été 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 (par exemple, si vous attendez que les images soient trop volumineuses que 50 images seraient trop volumineuses), 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 quelques tableaux de chaînes et gère la sélection de cellules par le biais d’une fonction anonyme qui est passée dans chacun d’eux 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 l’élément de classe racine.

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é 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 les StringElement éléments et StyledStringElement comme ceux-ci utilisent leur propre ensemble de clés pour différents scénarios de rendu. Vous devrez répliquer le code dans ces classes.

DialogViewControllers (DVCs)

La réflexion et l’API Elements utilisent les mêmes DialogViewController. Parfois, vous souhaiterez personnaliser l’apparence de la vue ou vous pouvez utiliser certaines fonctionnalités de celles UITableViewController qui vont au-delà de la création de base d’interfaces utilisateur.

Il DialogViewController s’agit simplement d’une sous-classe du UITableViewController et vous pouvez le personnaliser de la même façon que vous le personnaliseriez UITableViewController.

Par exemple, si vous souhaitez modifier le style de liste à l’une Grouped ou l’autre, Plainvous 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 l’élément DialogViewController, comme la définition de son arrière-plan, vous devez la sous-classer et remplacer les méthodes appropriées, comme illustré 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 :DialogViewController

public override Source CreateSizingSource (bool unevenRows)

Cette méthode doit retourner une sous-classe des DialogViewController.Source 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 utilise cette option pour effectuer le suivi lorsque l’utilisateur a fait défiler vers le haut et mis à jour en conséquence le nombre de tweets non lus.

Validation

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

Si vous souhaitez effectuer la validation des données, vous devez le faire 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 une validation plus complexe, 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 spécifique à l’application. Vous pouvez afficher un UIAlertView indicateur ou afficher un indicateur.

Résumé

Cet article a abordé beaucoup d’informations sur MonoTouch.Dialog. Il a abordé les principes fondamentaux de la façon dont 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 pris 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