Share
Da quando Xamarin è salito sul palco diversi anni fa, gli sviluppatori di C # sono stati lieti di poter creare applicazioni mobili rivolte a piattaforme non Microsoft. È con un po 'di eccitazione che ora possiamo scrivere app in un linguaggio che ci è molto familiare, ed essere in grado di distribuirle ai grandi giocatori nello spazio mobile, iOS e Android.
Dato che queste app possono essere scritte in una sola lingua, ha senso solo voler scrivere una singola base di codice che possa essere compilata in app separate per le diverse piattaforme e in definitiva ci consenta di raggiungere il mondo di Scrivi una volta, corri dappertutto / ovunque. Suona bene sulla carta, ma non era proprio il caso.
Il concetto di scrivere un'applicazione una volta sola ed essere in grado di eseguirlo su più piattaforme non è nuovo. Gli sviluppatori hanno tentato di farlo per molti anni con applicazioni desktop e server scritte in Java o C / C ++ e compilate su piattaforme specifiche. Perché le app mobili dovrebbero essere diverse? La risposta semplice è che non lo sono. In qualità di sviluppatori di app per dispositivi mobili, ci imbattiamo negli stessi principali problemi multipiattaforma che gli altri fanno, l'interfaccia utente.
Quando si tratta di scrivere qualsiasi tipo di software che si desidera essere in grado di eseguire su piattaforme diverse, il facile parte è la logica. Di facile, Intendo la parte dell'applicazione che non cambia a prescindere dalla piattaforma di destinazione. Indipendentemente dalla piattaforma a cui ti rivolgi, avrai comunque bisogno di ottenere dati da servizi, database, file, ecc. Le probabilità sono che molto raramente cambieranno. La parte che cambia è l'interfaccia utente. Ciò è dovuto principalmente alle differenze intrinseche delle varie piattaforme. Ogni piattaforma avrà il proprio SDK, definendo le funzionalità della piattaforma, nonché le loro componenti e caratteristiche visive.
Osservando il panorama mobile di oggi, scoprirai subito che ci sono tre grandi giocatori, iOS, androide, e Windows Phone. Questi tre sono in costante competizione per cercare di raggiungere gli altri per guadagnare più quote di mercato. Ma, per il prossimo futuro, queste sono le piattaforme su cui vorrete puntare. La ragione per cui lo sviluppo multipiattaforma su dispositivi mobili può essere difficile è dovuto alle differenze fondamentali in termini di interfaccia utente. Un pulsante non è più solo un pulsante. Un pulsante è a UIButton con XML su iOS, a Pulsante con AXML su Android e a Pulsante con XAML su Windows Phone.
Come per la maggior parte dei framework multipiattaforma, Xamarin ha in genere una strategia simile quando si tratta di limitare il mal di testa causato dall'interfaccia utente, suddividendo la logica dell'interfaccia utente.
Nel mondo di C #, questa strategia in genere ti lascerà almeno N + 1 progetti nella tua soluzione. Avrai almeno un progetto per ciascuno dei N piattaforme si sta prendendo di mira e sarà inoltre necessario disporre di almeno un progetto che conterrà tutto il codice condiviso su cui si basa l'applicazione. In questo modo, puoi fare in modo che i progetti specifici della piattaforma facciano semplicemente riferimento al progetto di codice condiviso e devono solo preoccuparsi di come visualizzare i dati. Grazie ad alcune nuove funzionalità nei framework .NET e Mono, hai un paio di opzioni.
Le librerie di classi portatili o PCL sono apparse per prime. È più facile pensare ai PCL come normali librerie di classi, solo con funzionalità limitate. È più facile capire questo concetto con un esempio. Inizia creando una nuova soluzione / progetto e nominalo PCLDemo e selezionare Libreria di classi (portatile) come modello di progetto.
Quando si fa clic ok in Visual Studio vedrai apparire un'altra finestra simile a questa:
A seconda degli strumenti che hai installato, potrebbe apparire leggermente diverso. In questa schermata, hai la possibilità di scegliere quante più o meno piattaforme come desideri. La regola generale qui è di scegliere solo le piattaforme che è assolutamente necessario target. La ragione di questo è che più piattaforme vuoi indirizzare, meno funzionalità saranno incluse in questa libreria. Per un elenco aggiornato delle funzionalità supportate dalle diverse piattaforme, consultare lo sviluppo multipiattaforma con la pagina Libreria di classi portatile su MSDN.
Se non selezioni le piattaforme appropriate in questa finestra di dialogo, potresti incorrere in problemi di incompatibilità in seguito. Per vedere questo in azione, deseleziona le tre opzioni in basso:
Ora crea un nuovo progetto di uno dei tipi di supporto rimosso da PCL. Ad esempio, è possibile creare un nuovo progetto Xamarin.Android utilizzando uno dei modelli forniti. Una volta creato il progetto, fai clic con il tasto destro del mouse su Riferimenti e selezionare Aggiungi riferimento. Nel Manager di riferimento finestra di dialogo, selezionare Soluzione> Progetti dal filtro a sinistra e seleziona la casella accanto a PCLDemo progetto.
Quando si fa clic ok, vedrai un errore simile al seguente:
Questo errore ti consente di sapere che il progetto in cui ti trovi attualmente non è compatibile con le destinazioni disponibili nel PCL selezionato. È possibile aggirare questo andando nelle proprietà del progetto PCL e cambiando gli obiettivi. Ma ricorda, più obiettivi, meno funzionalità supportate.
Anche se ci sono alcune cose che devi fare attenzione quando usi PCL, ci sono alcuni vantaggi molto interessanti.
Quando si sceglie una nuova tecnologia o piattaforma da utilizzare, si paga anche per capire gli svantaggi che devono essere affrontati.
Se i PCL sembrano troppo limitanti per te come scelta per il codice condiviso, c'è un'altra opzione.
Nella recente versione di Visual Studio 2013 Update 2, Microsoft ha aggiunto il supporto per i progetti condivisi. I progetti condivisi sono un altro modo per condividere il codice tra piattaforme diverse, in qualche modo simili ai PCL e in altri modi drasticamente differenti. Iniziamo creando un semplice esempio.
Inizia creando un'altra soluzione / progetto in Visual Studio e assegnandogli un nome SharedDemo e selezionando Progetto condiviso (vuoto) come modello.
Se non vedi Progetto condiviso (vuoto) come opzione, assicurarsi di disporre della versione più recente di Visual Studio 2013 Update 2. Se si sta utilizzando la versione più recente e ancora non la si vede, potrebbe essere necessario installare l'estensione Manager di riferimento di progetto condivisa.
Una volta che fai clic ok, Visual Studio creerà un nuovo progetto per te in Esploratore di soluzioni, ma sembrerà un po 'diverso da quello a cui sei abituato.
Sembra un po 'solo, eh? Non c'è Proprietà cartella e no Riferimenti cartella. Cosa sta succedendo? Questa è la bellezza e spesso la fonte di confusione per la maggior parte degli sviluppatori. Per impostazione predefinita, un progetto condiviso non contiene affatto l'accesso a nessuna funzionalità. C'è qualcosa di magico dietro le quinte in Visual Studio / Xamarin Studio, ma lo vedrai presto.
Un'altra caratteristica strana di un progetto condiviso è che non puoi effettivamente crearlo. Se dovessi fare clic con il tasto destro del mouse la soluzione o il progetto, non vedresti nessuna opzione per la costruzione, l'esecuzione o il debug di questo progetto. Per capire perché è così, devi fare un passo indietro per un momento.
Qual è lo scopo della costruzione di un progetto? Lo scopo è quello di trasformare il tuo codice da testo in un file reale che può essere utilizzato dal sistema su cui stai eseguendo o da un'altra applicazione. Questo è il motivo per cui non puoi realmente costruire un progetto condiviso, non viene generato alcun file di output. Questo progetto specializzato ha uno scopo completamente diverso.
Quando crei un progetto condiviso e scrivi del codice, puoi aggiungere riferimenti ad esso da altri progetti quanto vuoi. Non ci sono piattaforme da indirizzare o regole da seguire. Questo è il primo elemento di differenziazione da PCL. Continuiamo con un esempio. Crea un nuovo Xamarin.Android e / o Xamarin.iOS progetto nella soluzione e nominarli in modo appropriato, SharedDemo.Android e / o SharedDemo.iOS.
Ora che hai un nuovo progetto, fai clic con il tasto destro del mouse su Riferimenti cartella e selezionare Aggiungi riferimento a progetti condivisi. Se questa opzione non viene visualizzata, potrebbe essere necessario rivedere l'aggiunta dell'estensione di Gestione riferimento di progetto condivisa.
Da qui, clicca ok e dovresti vedere qualcosa di simile a questo:
È qui che entra in gioco la magia. Il codice contenuto con un progetto condiviso sarà compilato in qualsiasi progetto che lo faccia riferimento. Questo è il motivo per cui non puoi costruirli direttamente, hanno bisogno di qualcosa che li faccia riferimento prima che possano essere compilati e compilati. Il fatto che possano essere aggiunti a qualsiasi progetto come riferimento è parte della ragione per cui sono candidati così validi per lo sviluppo multipiattaforma.
L'altro motivo per cui sono buoni candidati per lo sviluppo multipiattaforma è il loro supporto per le direttive del compilatore. È possibile inserire controlli per direttive speciali all'interno dei progetti condivisi in modo che solo determinate piattaforme ottengano determinate funzionalità o che le cose vengano gestite in modo diverso su piattaforme diverse. Le seguenti direttive possono essere trovate nei progetti di piattaforma:
Accentsconagua
__MOBILE__ Xamarin.Android e Xamarin.iOS progetti__IOS__ Progetti Xamarin.iOS__ANDROID__ Xamarin.Progetti Android__ANDROID_xx__ Xamarin.Progetti Android dove xx è sostituito dalla versione dell'API Android mirataWINDOWS PHONE Progetti di Windows PhoneSILVERLIGHT Progetti di Windows PhonePuoi usare queste direttive all'interno #ifdef blocchi per verificare su quale piattaforma si sta lavorando e utilizzare la compilazione condizionale per includere solo ciò che è necessario in ogni progetto. Questo è tutto fatto per te dal compilatore. Vediamo un esempio.
Nel tuo SharedDemo progetto, aggiungi una nuova classe chiamata Ricetta e sostituire l'implementazione predefinita con quanto segue:
public class Recipe public string ShortName get; impostato; #if __iOS__ stringa pubblica LongName get; impostato; #endif Elenco pubblicoIngredienti get; impostato; Elenco pubblico Indicazioni get; impostato;
Questo è un esempio un po 'forzato, ma serve per illustrare un punto semplice. Poiché faccio riferimento a questo codice da un progetto Xamarin.Android, la classe Recipe conterrà solo 3 proprietà, Nome corto, ingredienti, e Indicazioni. Se questo codice è stato referenziato da un progetto Xamarin.iOS, conterrebbe anche il LongName proprietà.
È più probabile che tu usi queste direttive in situazioni in cui ti imbatti in divergenze tra piattaforme. Le aree comuni di divergenza su queste piattaforme mobili hanno a che fare con l'accesso all'hardware, al file system, ecc. Ora è possibile inserire il codice della piattaforma nel Progetto condiviso diviso le direttive e Visual Studio gestirà la compilazione specifica della piattaforma nei progetti corretti. Molto bella.
I progetti condivisi contengono alcune funzionalità molto utili che aiutano nella creazione di progetti multipiattaforma.
Mentre i progetti condivisi hanno delle caratteristiche interessanti, ci sono alcune caratteristiche non così desiderabili.
Ora sei a conoscenza delle strategie di base per la condivisione della logica dell'app. È tempo di iniziare a guardare l'interfaccia utente della tua app. Nella versione più recente della versione 3 di Xamarin, una delle funzionalità più interessanti è l'introduzione di Xamarin.Forms. Xamarin.Forms è una libreria che contiene le astrazioni dei controlli tipici dell'interfaccia utente che comprendono l'interfaccia utente della tua app. Quando questi controlli vengono utilizzati su piattaforme specifiche, vengono mappati per rendere i controlli dell'interfaccia utente nativa in modo da ottenere l'aspetto di componenti nativi.
La struttura di base della tua applicazione multipiattaforma non cambia. Continuerai a seguire la regola N + 1 per quanto riguarda i progetti, ma ora trasferirai il codice dell'interfaccia utente specifico della piattaforma dai progetti specifici della piattaforma ai Progetti condivisi. Prima di arrivare troppo avanti a noi stessi, dobbiamo comprendere le esigenze e le esigenze non solo di correre, ma di sviluppare app Xamarin.Forms.
Ci sono un paio di requisiti se vuoi sfruttare appieno Xamarin.Forms. Per utilizzare Xamarin.Forms, la tua app deve avere come target le seguenti piattaforme:
Ciò significa che se hai intenzione di scegliere come target alcune delle versioni precedenti di queste piattaforme, non sarai in grado di utilizzare Xamarin.Forms. Oltre alle restrizioni della piattaforma di destinazione, ci sono anche alcuni requisiti di sistema di sviluppo.
Una volta scaricato e configurato tutto, sei pronto per iniziare.
L'idea alla base di Xamarin.Forms è semplice, ti riferisci ai controlli dell'interfaccia utente comune allo stesso modo, indipendentemente dalle piattaforme che hai scelto come target. Un pulsante è un pulsante è un pulsante. Creerai questi controlli e fornirai loro caratteristiche e funzionalità visive. Quindi utilizzerai a disposizione posizionare i controlli sullo schermo e visualizzare tutto su a Pagina. Se sei abituato a utilizzare una terminologia specifica della piattaforma per descrivere i componenti dell'interfaccia utente delle tue app, l'uso dei nuovi termini potrebbe richiedere del tempo. Fortunatamente, ci sono solo alcuni concetti da capire.
In Xamarin.Forms, Pages rappresenta gli schermi reali della tua applicazione. Per quanto riguarda le altre piattaforme, a Pagina è un Attività su Android, a UIViewController su iOS e a Pagina su Windows Phone. Il Pagina è l'oggetto principale con cui avrai a che fare quando lavori con le transizioni e la navigazione. Anche un Pagina contiene solo un singolo figlio, che nella maggior parte delle situazioni è un tipo di disposizione.
I layout sono controlli utilizzati per organizzare i componenti dell'interfaccia utente sul tuo Pagina in modo logico. All'interno di a disposizione, puoi impostare le caratteristiche dei controlli dell'interfaccia utente, come posizione e dimensioni. È possibile aggiungere qualsiasi numero di componenti dell'interfaccia utente a un layout, inclusi i controlli e altro disposizione oggetti.
In Xamarin.Forms, le viste sono quelle che normalmente chiamerebbero i controlli. Comune vista oggetti in Xamarin.Forms sono Pulsante, Etichetta, e Visualizzazione elenco, per dirne alcuni. Il disposizione la classe in realtà eredita dal vista classe, il che significa che possono essere trattati allo stesso modo e aggiunti disposizione oggetti.
Le celle sono componenti dell'interfaccia utente specializzati utilizzati per personalizzare ciò che in genere viene definito come righe all'interno Visualizzazione elenco e UITableView oggetti. Ci sono pre-costruiti Cellula tipi per aggiungere un numero di diverse personalizzazioni al tuo vista oggetti.
Per creare un'applicazione di base Xamarin.Forms, apri Visual Studio, seleziona File> Nuovo progetto, seleziona il App per dispositivi mobili categoria e scegliere il modello appropriato. Ho scelto il App vuota (Xamarin.Forms condivisa) modello. Questo creerà un'applicazione Xamarin.Form usando il Progetto condiviso modello.
dopo aver fatto clic ok, la tua soluzione verrà creata con quattro progetti. Come discusso in precedenza, avrai tre progetti specifici per piattaforma e un progetto condiviso. Il progetto condiviso contiene la logica dell'applicazione e tutto il codice Xamarin.Forms che sarà responsabile della creazione delle schermate (Pagina oggetti) della tua applicazione.
Se apri il SampleFormsApp progetto, vedrai una singola classe chiamata App.cs. Questo è il file principale del progetto che contiene il Pagina definizioni che appariranno alla fine sulle piattaforme di destinazione. È una classe semplice che contiene solo quanto segue:
public class App public static Page GetMainPage () return new ContentPage Content = new Label Text = "Hello, Forms!", VerticalOptions = LayoutOptions.CenterAndExpand, HorizontalOptions = LayoutOptions.CenterAndExpand,,;
La classe App è abbastanza semplice in quanto contiene solo un singolo metodo statico che restituisce a Pagina dei contenuti oggetto. UN Pagina dei contenuti l'oggetto è il più semplice, senza fronzoli Pagina che puoi creare. È più facile pensare a a Pagina dei contenuti come una tela bianca che puoi fare tutto ciò che vuoi. C'è pochissima funzionalità integrata in esso.
Solitamente lo troverai di più Pagina gli oggetti hanno un Soddisfare proprietà che ti permette di assegnare vista obiettare ad esso. In questo caso, è un semplice Etichetta guarda che stampa "Hello, Forms!" sullo schermo dandogli alcune formattazioni di base per centrarlo.
Per ottenere questo Pagina dei contenuti per caricare su tutte le piattaforme a cui ci rivolgiamo, esiste un codice personalizzato specifico per piattaforma che deve essere incluso in ciascuno dei progetti della piattaforma. Diamo prima un'occhiata al progetto iOS. Apri il SampleFormsApp.iOS progetto e dare un'occhiata al AppDelegate.cs file. Questo è il file che contiene il cablaggio nel mondo Xamarin.Forms.
public override bool FinishedLaunching (app UIApplication, opzioni NSDictionary) Forms.Init (); window = new UIWindow (UIScreen.MainScreen.Bounds); window.RootViewController = App.GetMainPage (). CreateViewController (); window.MakeKeyAndVisible (); ritorna vero;
Per prima cosa inizializziamo la libreria Xamarin.Forms invocando Forms.Init (). Successivamente, l'unico codice personalizzato sta impostando il window.RootViewController proprietà al risultato del App.GetMainPage (). CreateViewController () chiamata. Quella linea verrà lanciata nel mondo Xamarin.Forms e tutto da quel punto continua a utilizzare Xamarin.Forms.
Il processo per inizializzare Xamarin.Forms in Android e Windows Phone è molto simile. Chiamerai il Dentro metodo e impostare l'iniziale Pagina essere il risultato del App.GetMainPage () metodo. Questo è quello che sembra nel SampleFormsApp.Android progetto nel MainActivity.OnCreate metodo.
protetto override void OnCreate (Bundle bundle) base.OnCreate (bundle); Xamarin.Forms.Forms.Init (questo, pacchetto); SetPage (App.GetMainPage ());
E nel SampleFormsApp.WinPhone progetto nel Pagina principale costruttore della classe parziale Pagina principale:
public MainPage () InitializeComponent (); Forms.Init (); Content = SampleFormsApp.App.GetMainPage (). ConvertPageToUIElement (this);
Ora dovresti avere una conoscenza di base di Xamarin.Forms e di ciò che puoi ottenere usando. Il viaggio in questa incredibile tecnologia non si ferma qui. Avrai un'altra scelta davanti a te quando usi Xamarin.Forms, che ha a che fare con il layout. E questo è esattamente ciò che verrà trattato 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 su tre piattaforme distinte: iOS, Android e Windows Phone 8. Pensa che non può essere fatto? Tra poco lo farai tu stesso. Andiamo a lavorare.
Puoi prendere subito il completamente gratis Prova di 14 giorni di un abbonamento a Tuts +. Dai un'occhiata alle nostre opzioni di abbonamento per iniziare o, se sei interessato a questo corso, puoi acquistarlo singolarmente per $ 15! Ecco un'anteprima per iniziare:
