Share
Se hai seguito la prima parte di questo tutorial, probabilmente già sai che il processo di installazione di Xamarin non è eccessivamente complicato. Xamarin ha creato un programma di installazione molto bello che esegue la maggior parte della verifica dei requisiti per te e devi solo selezionare alcune caselle e fare clic Il prossimo. Mentre il processo di acquisizione di Xamarin.iOS è abbastanza simile, ci saranno alcune differenze a seconda della piattaforma su cui si sta sviluppando, OS X o Windows.
Scoprirai subito che il processo di creazione delle applicazioni iOS in C # è leggermente più impegnativo rispetto al processo Android. Non è perché l'SDK è più difficile da capire, ma ci sono alcune parti in movimento. Per completare questo tutorial ed essere in grado di creare con successo applicazioni iOS in C #, avrai bisogno di quanto segue:
Se vieni dal mondo Windows, potresti essere un po 'turbato dal fatto che hai bisogno di un Mac e Xcode. La realtà è che, non importa quali strumenti e linguaggi utilizzi per creare la tua applicazione iOS, solo Xcode ha le capacità per creare l'iOS finale distribuibile (.ipa) e Xcode funziona solo su un Mac. Credimi, prima lo accetti, prima ti godrai il resto del processo.
Se hai seguito la prima parte di questo tutorial, probabilmente avrai già una buona conoscenza del processo di installazione di Xamarin. I passaggi necessari per installare Xamarin.iOS sono simili a quelli di Xamarin.Android. Ma se non hai letto il tutorial precedente, la seguente sezione riguarderà tutti i passaggi coinvolti.
Indipendentemente dalla piattaforma su cui intendi sviluppare il tuo sviluppo, avrai bisogno dell'ultima versione di Xcode e dell'SDK iOS. Il motivo principale per cui avrai bisogno di Xcode è per il processo di compilazione.
Prima vai al Dev Center di iOS e crea un account se non ne hai già uno. Puoi ignorare questo passaggio e andare direttamente al Mac App Store per scaricare Xcode, ma se hai intenzione di eseguire la tua app su un dispositivo fisico, avrai comunque bisogno di un account sviluppatore, quindi potresti farlo anche adesso.
Una volta creato, accedi e vai alla pagina Download per ottenere l'ultima versione di Xcode. Ti porterà al Mac App Store per completare il processo di download e installazione. Questo ti porterà non solo l'ultima versione di Xcode, ma scaricherà e installerà anche l'ultima versione dell'SDK di iOS. Dolce.
Questo tutorial non entrerà nei dettagli sul processo di provisioning e sulla distribuzione dell'applicazione su un dispositivo. Ci sono altri articoli su Tuts + che trattano quell'argomento così come la documentazione sul sito Web Xamarin, se lo desideri.
Puoi uccidere due piccioni con una fava andando verso la pagina di download di Xamarin, creando un account se non ne hai già uno e facendo clic Scarica Xamarin. Questo scaricherà l'installer di Xamarin che si prenderà cura di tutti i prerequisiti per il controllo, il download e l'installazione. Fare doppio clic sul .dmg file per avviare l'installazione.
Una volta avviato il programma di installazione, puoi selezionare i pezzi che desideri installare. Avrai solo bisogno dell'opzione Xamarin.iOS per questo tutorial, ma sentiti libero di installare tanto o quel poco che vuoi.
Questa schermata potrebbe apparire un po 'diversa sulla tua macchina, a seconda del sistema operativo in esecuzione e dei prodotti che potresti aver installato o meno. Come accennato in precedenza, sarà comunque necessario completare questo processo su un Mac se si sta eseguendo lo sviluppo su un PC. Parte dell'installazione di Xamarin.iOS è il Xamarin Build Host che ti permette di connetterti al tuo Mac attraverso la rete da un PC e creare il .ipa pacchetto che viene eseguito su iOS Simulator o su un dispositivo fisico.
Una volta che tutti i pacchetti sono stati scaricati e installati, se stai facendo lo sviluppo su un Mac, puoi avviare Xamarin Studio. Se hai intenzione di fare il tuo sviluppo su PC, dovrai seguire lo stesso processo di installazione per ottenere tutti i bit Xamarin.iOS necessari e il plugin Xamarin per Visual Studio sulla tua macchina Windows.
Per fare questo però, è necessario avere almeno la Business Edition di Xamarin. Se non lo hai già, puoi ottenere tutto ciò che ti serve durante la prova gratuita di 30 giorni di Xamarin. Se non hai accesso alla versione di prova gratuita o al software completo, dovrai utilizzare Xamarin Studio sul tuo Mac.
Il modo migliore per imparare veramente una nuova tecnologia di qualsiasi tipo è scavare e creare qualcosa da zero. È possibile creare questa applicazione in IDE (Integrated Development Environment), tutto quello che devi fare è seguire il codice di esempio.
Nell'era moderna dello sviluppo iOS, hai tre opzioni per la creazione dell'interfaccia utente dell'applicazione.
Mentre la prima e la seconda opzione sono le opzioni più popolari, creeremo l'applicazione di esempio usando la terza opzione. È importante non solo capire come farlo, ma anche capire perché sono stati creati gli strumenti grafici.
Se stai utilizzando Visual Studio su un computer Windows per seguire questo tutorial, quando avvii il processo di creazione del progetto, esegui una finestra di dialogo che ti chiede di connetterti a un Xamarin Costruisci host. Questo è un processo abbastanza semplice in cui devi solo seguire le istruzioni sugli schermi. Assomiglierà a questo.
La prima finestra di dialogo che vedrai è una finestra di istruzioni che descrive come avviare il Xamarin Build Host sul tuo Mac usando Riflettore.
Sul tuo Mac, apri il Xamarin Build Host e fare clic su Paio pulsante. Questo ti fornirà un PIN.
Tornare a Visual Studio e fare clic su Continuapulsante. Se il tuo Mac è configurato correttamente, dovrebbe apparire nell'elenco come possibile Xamarin Costruisci host.
Clicca il tuo Xamarin Build Host sistema di scelta e scegliere Collegare.
Visual Studio chiederà quindi il PIN. Una volta che hai inserito il PIN e abbinato Visual Studio con il tuo Xamarin Build Host, sarai in grado di seguire il resto di questo tutorial, non solo di scrivere un'applicazione iOS in C #, ma anche di farlo utilizzando Visual Studio. Eccezionale.
Se hai mai bisogno di connettere questo particolare Xamarin Build Host su un altro sistema, è possibile fare clic su Disaccoppia pulsante. Dopo aver fatto ciò, dovrai ripetere la procedura per il nuovo sistema.
Fortunatamente, Visual Studio ricorderà il Xamarin Build Host hai precedentemente collegato con. Se disaccoppiaVisual Studio dal Xamarin Build Host, la prossima volta che proverai a scrivere un'applicazione iOS in Visual Studio, chiederà il PIN per lo stesso host di compilazione. Per cercare un altro host in Visual Studio, fare clic su Opzioni dal Utensili menu e scegliere Xamarin> Impostazioni iOS. Lì troverai un pulsante che dice Trova l'host di compilazione per Mac. Questo mostrerà la finestra di dialogo per selezionare un diverso Xamarin Build Host.
Inizia aprendo il tuo IDE di scelta e selezionando File> Nuovo> Soluzione o Progetto a seconda dell'IDE che stai utilizzando. Dal Nuova soluzione finestra di dialogo, scegliere C #> iOS> iPhone dalla visualizzazione ad albero e selezionare Progetto vuoto come il modello. Questo ti darà la struttura di base per la tua applicazione senza tutte le campane e i fischietti che ti ostacolano. Questo è come apparirà in Xamarin Studio 5.0.
Puoi dare alla tua soluzione il nome che vuoi, ma se sei interessato a seguirmi, chiamalo Alimentatore. Una volta creata la struttura della soluzione / progetto, vedrai un numero di file che vale la pena di ingrandire:
Nel mondo di iOS, il AppDelegate è il conduttore della tua applicazione dal dispositivo. È usato per gestire tutti gli eventi di sistema che sono necessari. Il delegato dell'applicazione mantiene anche un riferimento a finestra oggetto. Ogni applicazione iOS ha una finestra, un'istanza di UIWindow classe, che viene utilizzato per disegnare l'interfaccia utente dell'applicazione. Il AppDelegate è responsabile della sottoscrizione a qualsiasi evento di sistema relativo alla propria applicazione, ad esempio, quando l'applicazione termina l'avvio o quando viene interrotta dal sistema operativo.
Questo file è simile alla sezione delle autorizzazioni di AndroidManifest. Specifica le autorizzazioni che l'applicazione ha e le tecnologie che è consentito utilizzare. Alcune delle tecnologie più comuni includono iCloud, PassKit, Notifiche Push, ecc. Si può pensare a plist o elenco di proprietà file come un dizionario di coppie chiave-valore che memorizzano le proprietà utilizzate dall'applicazione.
Simile al file Entitlements.plist, il file Info.plist memorizza le coppie chiave-valore. La differenza è che questo file memorizza informazioni sull'applicazione come nome dell'applicazione, icone, immagini di avvio e altro.
Questo file contiene il punto di ingresso principale per la tua applicazione. Il Principale metodo crea una nuova applicazione Xamarin.iOS e specifica il file AppDelegate che gestirà gli eventi inviati dal sistema operativo.
Il primo passaggio nella creazione dell'applicazione di esempio consiste in un oggetto che memorizza le informazioni che si desidera visualizzare all'utente. In questo caso, vuoi memorizzare informazioni sugli articoli che appaiono sul feed del blog RSS di Xamarin. Puoi archiviare più dati dell'esempio, ma questo ti aiuterà a iniziare. Per prima cosa, crea una nuova classe e nominala RSSItem. La definizione della classe dovrebbe assomigliare a questa:
public class RssItem public string Titolo get; impostato; public string Creator get; impostato; public DateTime PubDate get; impostato; public string Link get; impostato;
La classe è abbastanza semplice:
Accentsconagua
Titolo, una stringa che rappresenta il titolo dell'articoloCreatore, una stringa che rappresenta l'autore dell'articolopubDate, un Appuntamento che rappresenta la data di pubblicazione dell'articolocollegamento, una stringa che rappresenta il collegamento diretto all'articoloCon questo semplice set di modelli, ora possiamo concentrare l'attenzione sull'interfaccia utente dell'applicazione e sull'implementazione principale.
Quando crei applicazioni iOS, non hai altra scelta che seguire il Model-View-Controller paradigma. Anche se non capisci cosa sia, alla fine del processo sarai un soldato MVC che si collega alle applicazioni iOS senza nemmeno pensarci. Ad un livello elevato, il pattern MVC è composto da tre parti: hai indovinato:
Puoi pensare al Modello nel modello MVC come componenti principali (o classi) nell'applicazione che contengono dati / logica aziendali importanti. Nel tuo caso, il modello è il RSSItem classe che hai appena creato.
Il vista nella tua applicazione è l'effettiva rappresentazione visiva dei dati (o del tuo modello) sul dispositivo. Questo può presentarsi sotto forma di un elenco di dati o di alcuni componenti personalizzati che rappresentano i dati trovati nel tuo Modello.
In questo esempio, il livello vista sarà costituito da un elenco di RSSItem oggetti che sono stati scaricati dal feed di cui sopra. Idealmente, il Modello e il vista non sono consapevoli l'uno dell'altro e non dovrebbero interagire direttamente. I due pezzi del puzzle devono essere tenuti insieme con una sorta di colla.
La colla che lega il Modello e vista insieme, è il controllore. Nel mondo dello sviluppo di iOS vedrai generalmente un controller sotto forma di a ViewController classe o sottoclasse. Questa classe ha il compito di controllare l'interazione tra il Modello e vista. L'interazione può venire nella forma di un utente che tocca un pezzo del vista e aggiornando il Modello basato su quell'interazione o qualche parte del Modello essendo aggiornato da un altro processo dietro le quinte e aggiornando il vista basato su questo cambiamento.
Per implementare il pattern MVC nell'applicazione, è necessario creare un vista e a controllore. Aggiungi un nuovo elemento al tuo progetto facendo clic con il tasto destro sul tuo progetto e selezionando Aggiungi> Nuovo file (o Articolo a seconda del tuo IDE). Nel Nuova finestra di dialogo dei file, dovrai selezionare il iOS gruppo e il iPhone View Controller come il tipo e dargli un nome FeedItem.
Questo processo aggiungerà nuovi file al tuo progetto. Tutti questi file hanno scopi diversi, ma, insieme, costruiranno la visualizzazione elenco che presenterà gli articoli del blog Xamarin all'utente.
Il FeedItemCell è una classe che descrive le singole celle (o righe) all'interno della visualizzazione elenco. Questa classe ti permetterà di modificare l'aspetto e il layout, nonché la funzionalità di tutte le celle nell'elenco per dargli un aspetto personalizzato.
La fonte di dati che viene visualizzata nel tuo elenco di FeedItemCell gli oggetti si presentano sotto forma di FeedItemSource classe. Questa classe di origine non contiene solo i dati che verranno visualizzati nel tuo elenco, ma contiene anche informazioni sull'elenco, inclusi i suoi raggruppamenti, intestazioni, piè di pagina e conteggi delle voci. Gestisce anche le interazioni con gli oggetti quando un utente tocca uno di essi.
Ancora una volta, il vero controller è la colla che lega tutte le cose insieme. Il FeedItemController class è la classe contenitore che creerà la vista elenco per l'utente alla visualizzazione effettiva sullo schermo. All'interno di questa classe è necessario ottenere i dati appropriati da mostrare sullo schermo, inizializzarne uno nuovo FeedItemSource con quei dati e passare la fonte al controller.
Ora che hai preparato tutti i pezzi del puzzle, è ora di metterli insieme. Iniziamo a lavorare sui tre file che hai appena creato e preparali per i nostri dati. Innanzitutto, dai un'occhiata al FeedItemCell classe e modificarlo per assomigliare a questo.
namespace Feeder public class FeedItemCell: UITableViewCell public static readonly NSString Key = new NSString ("FeedItemCell"); public FeedItemCell (): base (UITableViewCellStyle.Subtitle, Key) // TODO: aggiungi subviews a ContentView, imposta vari colori, ecc. TextLabel.Text = "TextLabel"; Non c'è molto da fare in questa classe e c'è solo un piccolo cambiamento che farai. Da questa classe verrà ereditata UITableViewCell. Tutto ciò che contiene questa classe è un costruttore che chiama il costruttore di base che passa in due parti di dati.
Sottotitolo stile. Questo stile consente due campi di testo nella cella, uno sopra l'altro.FeedItemCell chiave.Il prossimo pezzo del puzzle è il FeedItemSource classe. Sostituisci il contenuto dell'implementazione predefinita con quanto segue:
namespace Feeder public class FeedItemSource: UITableViewSource Lista privata_elementi; FeedItemSource pubblica (Elenco articoli) _items = articoli; public override int NumberOfSections (UITableView tableView) // TODO: restituisce il numero effettivo di sezioni restituisce 1; public override int RowsInSection (UitableView tableview, int section) // TODO: restituisce il numero effettivo di elementi nella sezione return _items.Count; public override UITableViewCell GetCell (UITableView tableView, NSIndexPath indexPath) var cell = tableView.DequeueReusableCell (FeedItemCell.Key) come FeedItemCell; if (cell == null) cell = new FeedItemCell (); // TODO: popola la cella con i dati appropriati in base alla cella indexPath.TextLabel.Text = _items [indexPath.Row] .Title; cell.DetailTextLabel.Text = string.Format ("0 su 1", _items [indexPath.Row] .Creator, _items [indexPath.Row] .PubDate); cella di ritorno; public override void RowSelected (UITableView tableView, NSIndexPath indexPath) var item = _items [indexPath.Row]; var url = new NSUrl (item.Link); UIApplication.SharedApplication.OpenUrl (url);
Scopriamolo per capire meglio cosa sta succedendo. L'origine ha bisogno dei dati che verranno visualizzati nell'elenco e che tipicamente viene gestita nel costruttore.
Elenco privato_elementi; FeedItemSource pubblica (Elenco articoli) _items = articoli;
I dati di origine nel tuo elenco verranno forniti da un elenco delle classi del tuo modello, RSSItem. Questo elenco di elementi è passato al costruttore del FeedItemSource classe e tenuta in una variabile privata _elementi.
public override int NumberOfSections (UITableView tableView) // TODO: restituisce il numero effettivo di sezioni restituisce 1;
Quando si utilizzano elenchi in un'applicazione iOS, è possibile raggruppare celle in sezioni. Il NumberOfSections metodo restituisce quante sezioni o gruppi si trovano all'interno dell'elenco. In questa particolare applicazione, c'è un singolo gruppo che contiene tutti gli elementi, il che significa che il metodo restituisce 1.
public override int RowsInSection (UitableView tableview, int section) // TODO: restituisce il numero effettivo di elementi nella sezione return _items.Count;
Con il numero di sezioni dell'elenco definito, la vista tabella deve sapere quanti oggetti sono stati trovati in ogni sezione. Hai già superato l'elenco di RSSItem oggetti che verranno visualizzati nell'elenco nel costruttore e salvati nella variabile privata _elementi, quindi tutto ciò che devi fare è tornare _items.Count.
public override UITableViewCell GetCell (UITableView tableView, NSIndexPath indexPath) var cell = tableView.DequeueReusableCell (FeedItemCell.Key) come FeedItemCell; if (cell == null) cell = new FeedItemCell (); // TODO: popola la cella con i dati appropriati in base alla cella indexPath.TextLabel.Text = _items [indexPath.Row] .Title; cell.DetailTextLabel.Text = string.Format ("0 su 1", _items [indexPath.Row] .Creator, _items [indexPath.Row] .PubDate); cella di ritorno; Il prossimo, e probabilmente il più importante, parte dell'implementazione sorgente è il GetCell metodo. Lo scopo di questo metodo è di produrre e riutilizzare le celle che sono presenti nella lista.
var cell = tableView.DequeueReusableCell (FeedItemCell.Key) come FeedItemCell; if (cell == null) cell = new FeedItemCell ();
La prima linea chiama il DequeueReusableCell metodo che passa in un argomento del Chiave di una cella che sta cercando. Una delle idee alla base di un elenco è che se i dati di origine contengono più elementi di quanti possano rientrare nella sezione visualizzabile dello schermo, non c'è motivo di creare continuamente tali celle e di utilizzare le risorse di sistema.
Invece, quando una cella va fuori campo, non viene semplicemente scartata. Viene inserito in un pool di altre celle per un uso successivo. Successivamente, quando è necessaria una cella con una particolare chiave, il sistema prima controlla il pool di celle riutilizzabili per le celle con quella chiave. Se non è possibile trovare alcuna cella riutilizzabile, la variabile di cella è nullo, e un nuovo FeedItemCell è creato.
cell.TextLabel.Text = _items [indexPath.Row] .Title; cell.DetailTextLabel.Text = string.Format ("0 su 1", _items [indexPath.Row] .Creator, _items [indexPath.Row] .PubDate); cella di ritorno;Se una cella è pronta per essere utilizzata, deve essere popolata con i dati. Come lo fai dipende completamente da te. Nel nostro esempio, abbiamo specificato che ogni cella è del Sottotitolo tipo, il che significa che ha due etichette. La cima Etichetta è indicato come il TextLabel. Nel nostro esempio, è popolato con il Titolo proprietà di un RSSItem oggetto. Per recuperare il corretto RSSItem oggetto, facciamo uso del indexPath.Row proprietà. Il fondo Etichetta è indicato come il DetailTextLabel ed è popolato con una concatenazione del Creatore e pubDate proprietà del corrispondente RSSItem oggetto.
public override void RowSelected (UITableView tableView, NSIndexPath indexPath) var item = _items [indexPath.Row]; var url = new NSUrl (item.Link); UIApplication.SharedApplication.OpenUrl (url);
Il finale oltrepassare metodo all'interno del FeedItemSource la classe è RowSelected. Questo metodo viene chiamato ogni volta che una cella all'interno dell'elenco viene toccata dall'utente. In questo caso, quando un utente tocca una cella, recupera il corrispondente RSSItem istanza usando il indexPath.Row proprietà. Quindi crei un nuovo NSUrl oggetto con il collegamento proprietà del RSSItem oggetto e passa quello NSUrl al UIApplication.SharedApplication.OpenUrl metodo. Questo metodo determinerà quale applicazione sul dispositivo o emulatore è più adatta a gestire l'url. Nel nostro esempio, poiché l'url rappresenta un indirizzo web, il browser integrato del dispositivo o del simulatore gestirà la richiesta.
È tempo di rivolgere la nostra attenzione al FeedItemController classe.
namespace Feeder public class FeedItemController: UITableViewController Lista privata_elementi; public FeedItemController (): base () using (var client = new HttpClient ()) var xmlFeed = client.GetStringAsync ("http://blog.xamarin.com/feed").Result; var doc = XDocument.Parse (xmlFeed); XNamespace dc = "http://purl.org/dc/elements/1.1/"; _items = (dall'elemento in doc.Descendants ("item") seleziona new RssItem Title = item.Element ("title"). Value, PubDate = DateTime.Parse (item.Element ("pubDate"). Value), Creator = item.Element (dc + "creatore"). Value, Link = item.Element ("link"). Value). ToList (); public override void DidReceiveMemoryWarning () // Rilascia la vista se non ha una superview. base.DidReceiveMemoryWarning (); // Rilascia qualsiasi dato memorizzato nella cache, immagini, ecc. Che non sono in uso. public async override void ViewDidLoad () base.ViewDidLoad (); // Registra l'origine dati di TableView TableView.Source = new FeedItemSource (_items);
Prima di poter compilare correttamente questo codice, è necessario aggiungere un riferimento a System.Xml.Linq montaggio. Puoi farlo cliccando col tasto destro su Riferimenti nel tuo progetto e selezionando entrambi Aggiungi riferimento o Modifica riferimenti, a seconda dell'IDE che stai utilizzando. Sarà inoltre necessario aggiungere il utilizzando System.Xml.Linq; dichiarazione all'inizio del file di classe.
Elenco privato_elementi; public FeedItemController (): base () using (var client = new HttpClient ()) var xmlFeed = client.GetStringAsync ("http://blog.xamarin.com/feed").Result; var doc = XDocument.Parse (xmlFeed); XNamespace dc = "http://purl.org/dc/elements/1.1/"; _items = (dall'elemento in doc.Descendants ("item") seleziona new RssItem Title = item.Element ("title"). Value, PubDate = DateTime.Parse (item.Element ("pubDate"). Value), Creator = item.Element (dc + "creatore"). Value, Link = item.Element ("link"). Value). ToList ();
Qui è dove vive tutta la logica per recuperare i dati dal feed del blog RSS di Xamarin. Se hai seguito la versione Android del tutorial Introduzione a Xamarin, probabilmente questo sembra familiare. Questo perché è lo stesso codice esatto.
Inizi creando creando un HttpClient e usando il GetStringAsync metodo per scaricare i dati trovati nell'url fornito e utilizzare il analizzare metodo sul XDocument classe per preparare i dati per alcune magie Linq-to-Xml. Una volta che hai il XDocument oggetto, è possibile eseguire una query per ottenere i valori di tutti gli elementi elemento figlio trovati nel feed RSS e inizializzare le istanze di RSSItem classe e salvarli nel privato _elementi variabile.
Dopo il costruttore, ci sono solo due metodi presenti nell'implementazione. Quei metodi sono DidReceiveMemoryWarning e viewDidLoad. Non devi fare nulla con il primo metodo, ma come la maggior parte delle cose paga sapere almeno a cosa serve.
Il DidReceiveMemoryWarning il metodo viene chiamato in qualsiasi momento all'interno dell'esecuzione di questa classe quando il dispositivo o il simulatore ha determinato che l'applicazione potrebbe occupare troppa memoria e potrebbe essere eventualmente terminata. Questa è la tua opportunità di rilasciare alcune risorse ad alta intensità di memoria per evitare che ciò accada. Come suggerisce il nome, il viewDidLoad il metodo viene richiamato quando la vista viene caricata e prima che sia presentata all'utente.
public async override void ViewDidLoad () base.ViewDidLoad (); // Registra l'origine dati di TableView TableView.Source = new FeedItemSource (_items);
In questo metodo, chiamiamo il metodo base di viewDidLoad e creare una nuova istanza di FeedItemSource classe, assegnandola al TableView.Source proprietà. Una volta fatto, l'utente sarà in grado di vedere i dati che hai recuperato dal feed RSS e inseriti nella visualizzazione elenco. Se sei confuso dove il TableView la proprietà proviene, è ereditata dal FeedItemControllerLa classe base, UITableViewController. Questa classe base fornisce un riferimento alla vista tabella effettiva che si trova nella vista del controller della vista.
Ora hai tutti i pezzi necessari per presentare un elenco di articoli all'utente. L'unico problema è che nessuno di questi è ancora visibile. Il motivo è che alla tua applicazione non è stato detto di usare il FeedItemController per mostrare i dati all'utente. Per fare questo, è necessario apportare una piccola modifica al tuo AppDelegate classe.
Il AppDelegate la classe contiene attualmente un metodo, FinishedLaunching. Questo metodo viene chiamato dal delegato dell'applicazione dal sistema operativo. Per far funzionare tutto, dobbiamo apportare una leggera modifica alla sua implementazione.
public override bool FinishedLaunching (app UIApplication, opzioni NSDictionary) // crea una nuova istanza finestra in base alla finestra dimensione schermo = nuova UIWindow (UIScreen.MainScreen.Bounds); var controller = new FeedItemController (); controller.View.BackgroundColor = UIColor.White; controller.Title = "Xamarin Feeds"; var navController = new UINavigationController (controller); window.RootViewController = navController; // rende la finestra visibile window.MakeKeyAndVisible (); ritorna vero;
Le prime quattro linee sono piuttosto standard. Si crea una nuova istanza di UIWindow classe, che conterrà l'interfaccia utente dell'applicazione. Quindi si crea una nuova istanza di FeedItemController classe e impostare è Colore di sfondo proprietà a UIColor.White e dargli un Titolo.
Le prossime due linee possono sembrare un po 'confuse. Si crea una nuova istanza di a UINavigationController, passare ad esso il FeedItemController istanza nel costruttore, impostare il RootViewController proprietà del finestra oggetto al UINavigationController, e chiama MakeKeyAndVisible. Perché dobbiamo affrontare questa seccatura? Perché non possiamo impostare il RootViewController al FeedItemController e chiamarlo un giorno? Puoi farlo e la tua applicazione funzionerà ancora. Tuttavia, se lo fai, la barra di stato nella parte superiore dello schermo comparirà in cima al tuo elenco e avrà un aspetto negativo. Aggiungere il controller a a UINavigationController è un piccolo trucco che realizza due cose:
Titolo proprietà del controller visibileÈ ora di creare ed eseguire la tua applicazione in iOS Simulator. Il risultato dovrebbe essere simile allo screenshot qui sotto.
E il gioco è fatto. Hai appena creato con successo un'applicazione iOS completamente funzionale utilizzando nient'altro che C # e Xamarin. Questo è un risultato piuttosto impressionante se ci pensi.
Spero che questo ti dia fiducia e guidi per immergerti più a fondo nel regno di Xamarin e le porte che apre per te. Da qui puoi imparare a creare applicazioni Android in C # usando Xamarin se non lo hai già fatto. In tal caso, è possibile esplorare come è possibile creare applicazioni multipiattaforma in grado di riutilizzare la maggior parte di una singola base di codice ed eseguire su dispositivi iOS e Android. Questo è quello che ti mostrerò nel prossimo tutorial.
Se desideri ulteriori informazioni su Xamarin, consulta il nostro corso Creazione di app multipiattaforma con C # in Xamarin.
Nel corso, imparerai come creare un'applicazione multipiattaforma da un singolo codice base che verrà eseguito
