Share
È incredibile pensare che quasi dieci anni fa, quando Mono fu ufficialmente rilasciato, gli sviluppatori di C # avrebbero a portata di mano la maggior parte del panorama mobile. Ricordo esattamente dove ero. Era l'estate del 2004 e stavo dando il tocco finale a un'applicazione desktop fat-client che utilizza .NET Framework 2.0.
Stavo creando un'applicazione per visualizzare i data center aziendali in Visio e generare automaticamente piani di migrazione e checkpoint per la virtualizzazione dei loro ambienti. E 'stata una cosa rivoluzionaria al momento, se me lo chiedi.
Stavo cercando di rimanere su .NET come meglio potevo, così quando ho sentito che ci sarebbe stata una versione aperta, ho pensato, "pulito". Forse potrei eseguire la mia applicazione su una macchina Linux. Ma stavo lavorando in un negozio Microsoft e non ci ho visto molto, quindi l'ho liquidato per un po '.
Circa un anno prima che Mono fosse pubblicato, la società che lo ha creato, Ximian, è stata acquistata da Novell e ha continuato a lavorare sui suoi prodotti. Tra questi prodotti c'era Mono. A suo tempo sotto l'ombrello di Novell, Mono ha continuato a essere migliorato da vicino seguendo la crescita e la funzionalità di .NET Framework attraverso Microsoft.
Durante questo periodo, sono arrivati due grandi progressi nello spazio mobile per quanto riguarda Mono, MonoTouch e Mono per Android sono stati rilasciati rispettivamente nel 2009 e nel 2011. Con grande stupore della comunità .NET, ora potremmo scrivere app per dispositivi mobili che hanno come target le piattaforme iOS e Android in una lingua che ci è familiare. Sfortunatamente, questo non è stato immediatamente raggiunto a braccia aperte.
Mentre la piattaforma Android non sembra avere molti problemi con questo, Apple, d'altra parte, non era altrettanto ricettiva. A metà del 2010, Apple ha aggiornato i termini del suo iOS Developer Program che vietava agli sviluppatori di scrivere app in lingue diverse da C, C ++ e Objective-C, e limitato qualsiasi tipo di livello tra la piattaforma iOS e le applicazioni iOS.
Questo potrebbe certamente aver causato il disastro per MonoTouch in futuro. Fortunatamente, alla fine del 2010, Apple ha allentato le restrizioni linguistiche e il futuro di MonoTouch sembrava di nuovo brillante, anche se solo brevemente.
Dato che le prospettive per gli utenti di MonoTouch hanno iniziato a sembrare brillanti, c'è stato un altro inconveniente. All'inizio del 2011, Attachmate ha acquisito Novell e annunciato centinaia di licenziamenti della forza lavoro Novell. Tra questi licenziamenti c'erano molti dei fondatori del framework Mono originale, nonché gli architetti e sviluppatori di MonoTouch e Mono per Android. Ancora una volta, ci siamo preoccupati del futuro della nostra capacità di creare app C # in esecuzione su queste nuove piattaforme.
Appena un mese dopo essere stato licenziato, Miguel de Icaza ha creato una nuova società di nome Xamarin e ha promesso di continuare lo sviluppo e il supporto di Mono. Novell e Xamarin hanno annunciato che sarebbe stata concessa una licenza perpetua di Mono, MonoTouch e Mono per Android e che Xamarin avrebbe assunto ufficialmente il progetto. Abbiamo ancora una volta avuto le chiavi del regno.
Circa tre anni dopo la creazione di Xamarin, ci rimangono alcuni strumenti davvero notevoli. Questi strumenti non sono solo notevoli per il fatto che ci permettono di scrivere applicazioni C # che girano su piattaforme non Microsoft, ma sono anche estremamente facili da installare e utilizzare.
Per iniziare, vai semplicemente sul sito Web Xamarin, registrati per un account se non ne hai già uno e visita la pagina di download. Con ogni account, ottieni una prova gratuita di 30 giorni della Business Edition di Xamarin, che ti offre tutto ciò di cui hai bisogno.
Negli ultimi anni, il processo di installazione di Xamarin è notevolmente migliorato rispetto ai giorni di MonoTouch e Mono per Android. È un'installazione completamente autonoma in grado di rilevare il software richiesto e le relative versioni per iniziare, inclusa la versione appropriata dell'SDK di Android.
Nella mia mente, la caratteristica più importante dell'edizione Business (e Enterprise) è il suo supporto per Visual Studio. Ciò significa che puoi scrivere tutte le tue applicazioni iOS e Android utilizzando non solo un IDE con cui ti trovi a tuo agio, ma ottieni anche il vantaggio di altri plug-in o estensioni per Visual Studio che potresti utilizzare, per esempio con Resharper.
Non so voi, ma di sicuro provo un brivido di eccitazione quando apro Visual Studio, selezionare File> Nuovo progetto e guarda dritto in faccia alle opzioni per creare un'applicazione iOS o Android.
Se la tua prova gratuita di 30 giorni della Business Edition è scaduta quando leggi questo, puoi semplicemente eseguire il downgrade alla Versione principianti e continuare a giocare con Xamarin. Tuttavia, ci sono un paio di inconvenienti per la Starter Edition.
Se stai semplicemente usando la Versione principianti per giocare con Xamarin, queste restrizioni non sono un grosso problema. Se stai lavorando alla prossima grande app, però, dovrai fare un pony per Business o Enterprise Edition. Ogni edizione ha anche un IDE gratuito, Xamarin Studio.
Xamarin Studio è un IDE completo che include molte funzionalità che si trovano anche in Visual Studio, quindi non è necessario sentirsi in alcun modo in cortocircuito se si sceglie di utilizzare Xamarin Studio. Mi sento molto a mio agio ed è davvero una gioia lavorare con.
La cosa bella è che la soluzione e le strutture del progetto sono intercambiabili con quelle di Visual Studio. Ciò significa che se si dispone di una licenza per un'edizione di Xamarin che consente di utilizzare Visual Studio, è possibile lavorare sulla stessa soluzione in IDE. Ciò consente lo sviluppo cross-team tra gli sviluppatori che utilizzano un sistema basato su Windows o Mac. Non c'è bisogno di software di virtualizzazione, perché Xamarin Studio è disponibile sia per Windows che per OS X.
Quando inizi con Xamarin, è importante essere a conoscenza delle opzioni di configurazione. Per entrare nella configurazione di base, selezionare Strumenti> Opzioni da Visual Studio o Xamarin Studio.
Al momento ho solo Xamarin.Android installato. Se hai anche installato Xamarin.iOS, vedrai più opzioni di configurazione. Dal lato destro della finestra di dialogo delle opzioni vedrai le seguenti opzioni in Visual Studio.
In Xamarin Studio, le opzioni simili sono suddivise in Posizioni SDK, Debugger, e androide elementi di visualizzazione ad albero in progetti sezione. Lascia che ti guidi attraverso le varie opzioni di configurazione.
Come avrai intuito, queste impostazioni vengono utilizzate per impostare la posizione dei bit Android sulla tua macchina. Generalmente non ritengo necessario modificarli e molto spesso una semplice installazione di Xamarin, a volte con un aggiornamento o due, scaricherà e installerà tutte le versioni appropriate nelle posizioni corrette. Se sei uno sviluppatore Android più esperto che ha bisogno di avere accesso a più versioni ed essere in grado di passare avanti e indietro, hai questa capacità.
Questa è probabilmente l'opzione di configurazione che uso di più. Quando scrivo un'applicazione che funziona con i dati sandbox locali su un dispositivo o nell'emulatore, come i file o un database, alla fine controllerò questa casella.
Durante la distribuzione di un'applicazione su un dispositivo o sull'emulatore, tutti i dati esistenti, inclusi i file di database, vengono rimossi e devono essere nuovamente creati. Nelle prime fasi di sviluppo, quando voglio assicurarmi che il database sia stato creato con successo, va bene. Dopo quel punto, tuttavia, desidero lavorare con un database popolato e non dover impostare tali dati ogni volta che viene distribuita l'applicazione.
Durante il ciclo di sviluppo, stai distribuendo il tuo debug build su un dispositivo o sull'emulatore. Per impostazione predefinita, in bundle con l'applicazione sono i simboli di debug che consentono di eseguire il debug, impostare i breakpoint nel proprio codice e scorrere le righe mentre l'applicazione è in esecuzione. Questa opzione ti consente anche di accedere ai simboli di debug nel runtime Mono condiviso e alle librerie delle classi di base per fornirti ulteriori informazioni su ciò che accade in quelle aree e sul tuo codice personale.
Questo è usato solo per scopi di debug. Un'opzione simile si trova in Xamarin Studio. Puoi trovarlo sotto il Debugger opzione come Esegui il debug solo del codice del progetto; non entrare nel codice quadro. Dovrai deselezionare questa casella per entrare nel framework Mono.
Se hai la necessità di modificare l'emulatore Android con impostazioni aggiuntive che potresti in genere impostare manualmente durante l'esecuzione, questa opzione ti consente di passare tali argomenti direttamente all'emulatore tramite Visual Studio o Xamarin Studio.
Il software Xamarin è in continua evoluzione e viene aggiornato. Vale veramente la pena di essere aggiornato su eventuali modifiche alla versione che stai utilizzando attualmente e su ciò che accadrà. Qui è dove è possibile impostare quali tipi di aggiornamenti si desidera ricevere una notifica. Ti verrà chiesto di scaricare e installare nuove versioni se selezioni questa casella di controllo.
In genere mantengo le versioni stabili per le applicazioni pianificate per il rilascio, ma mi piace avere un alfa o una beta con cui giocare. C'è un'opzione simile in Xamarin Studio, ma in una posizione diversa. Può essere trovato sotto Guida> Controlla aggiornamenti. Qui puoi scegliere il Aggiorna canale come Stabile, Beta, o Alfa, proprio come in Visual Studio.
Questa opzione abilita la registrazione della distribuzione del dispositivo. Quando questa opzione è abilitata, Visual Studio indirizza l'output dal log di distribuzione a monodroid.log file trovato sul desktop. Questa opzione non è disponibile in Xamarin Studio, almeno non come configurazione.
Xamarin Studio scrive sempre i log di implementazione del dispositivo, ma sono un po 'più difficili da trovare. Su Windows, puoi trovarli in \ LOCALAPPDATA \ XamarinStudio- version \ Logs cartella dove VERSIONEè la versione di Xamarin Studio che stai utilizzando. I file vengono creati in quella cartella con la convenzione di denominazione di AndroidTools- DATA __ TIME dove DATAè la data corrente della distribuzione e TEMPOè l'ora effettiva della distribuzione.
Prima di affrontare la bellezza di questo codice, e il ragazzo è bellissimo, è importante per te capire che solo perché puoi scrivere applicazioni iOS e Android in C #, non significa che puoi semplicemente scrivere applicazioni iOS e Android in C #. Il team di Xamarin ha fatto un lavoro fantastico consentendo agli sviluppatori con uno sfondo in C # di avere il capacitàper creare applicazioni iOS e Android. Il problema sta nella conoscenza. Lasciatemi spiegare questo in modo più dettagliato.
Potresti avere la conoscenza C # di cui hai bisogno, ma a meno che tu non abbia dilettato lo sviluppo di iOS o Android in passato, non hai la conoscenza della piattaforma. Al fine di rendere Xamarin utilizzabile a tutti i livelli di sviluppatori iOS e Android, il team di Xamarin ha mappato i costrutti del linguaggio e le strutture di classe da Objective-C per iOS e Java per Android in C #.
Che cosa vuol dire? Significa che devi almeno avere una conoscenza di base del modello di programmazione iOS e Android e degli SDK per poter sfruttare Xamarin. Ciò significa che il AVFoundation la classe in Objective-C è la MonoTouch.AVFoundation classe in C #. Il Attività classe in Java è il Android.App.Activity classe in C #.
Se non hai esperienza con iOS o Android, non lasciare che la tua mancanza di conoscenza scoraggi l'utilizzo di Xamarin. Non devi trascorrere mesi, giorni o addirittura ore su iOS Dev Center o sul sito web degli sviluppatori Android. Il punto è che acquisire familiarità con la piattaforma che stai sviluppando vale più del tuo tempo se la tua ambizione è creare un prodotto di alta qualità.
Il mio suggerimento è quello di andare direttamente al Centro per sviluppatori Xamarin e iniziare subito a lavorare. Troverai documentazione, esempi di applicazioni, esercitazioni, video e riferimenti API. Tutto dopo aver iniziato è semplicemente la ricerca su come eseguire determinati compiti. Una volta ottenuto un buon controllo sulle API e sul flusso di sviluppo, puoi tornare alle risorse iOS e Android per ottenere una conoscenza più approfondita delle piattaforme.
Ora che hai scaricato e installato gli strumenti necessari, portali a fare un giro. Per seguire, puoi usare Visual Studio o Xamarin Studio, perché mi concentrerò sul codice, non sull'IDE. Per questo tutorial, utilizzerò Visual Studio 2013 in esecuzione su Windows, ma sei libero di utilizzare IDE su Windows o Xamarin Studio su OS X. Creeremo una semplice applicazione Android che leggerà il feed di notizie corrente da Xamarin e lo chiameremo XamFeed.
Inizia come faresti con qualsiasi altra applicazione C # creando un nuovo progetto / soluzione e nominandolo XamFeed. Tipiche convenzioni di denominazione per un'applicazione come questa si aggiungerebbero .androide alla fine del nome. Questo per differenziare il nome di questa applicazione da qualsiasi altra versione specifica della piattaforma che potresti creare in seguito (come .iOS, .Mac, .Windows Phone, eccetera).
Questa sarà un'applicazione molto semplice, quindi terremo anche il nome semplice. Puoi scegliere uno qualsiasi dei modelli Android che desideri, Applicazione Android, Applicazione Honeycomb Android o Applicazione Android Ice Cream Sandwich. Questi hanno appena impostato la versione base di Android che la nostra applicazione avrà come target. Userò la base Applicazione Android modello.
Nel Esploratore di soluzioni, apri il Attività principale classe, che sarà il principale punto di accesso della nostra applicazione. Mi piace rinominare questo Attività per rappresentare meglio lo scopo che servirà, quindi andare avanti e rinominarlo FeedActivity.
Se non conosci le attività, pensa a Attività come schermo o vista all'interno della tua applicazione Android. Ogni schermata di cui hai bisogno nella tua applicazione avrà una classe corrispondente che eredita dal Attività classe base.
Nel FeedActivity classe, hai la possibilità di sovrascrivere un numero di metodi che ti vengono forniti immediatamente. L'unico di cui siamo preoccupati al momento è il OnCreate metodo che verrà chiamato quando il nostro schermo è creato e accessibile all'utente.
La prima cosa che faremo è creare una nuova classe che rappresenti il feed. Ovviamente puoi ampliare questo, ma tutto ciò di cui abbiamo bisogno per ora è il Titolo, pubDate, Creatore, e collegamento al contenuto dell'articolo.
public class RssItem public string Titolo get; impostato; public string PubDate get; impostato; public string Creator get; impostato; public string Link get; impostato;
Ora possiamo cambiare l'implementazione di OnCreate metodo all'interno del nostro Attività principale classe per ottenere i dati dal feed Xamarin. Sostituisci il OnCreate implementazione con il seguente:
Accentsconagua
[Attività (Etichetta = "XamFeed", MainLauncher = true, Icona = "@ drawable / icona")] public class FeedActivity: ListActivity private RssItem [] _items; protected async override void OnCreate (Bundle bundle) base.OnCreate (bundle); using (var client = new HttpClient ()) var xmlFeed = attende client.GetStringAsync ("http://blog.xamarin.com/feed/"); 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 = item.Element ("pubDate"). Value, Creator = item.Element ( dc + "creatore"). Valore, Link = item.Element ("link"). Value). ToArray (); ListAdapter = new FeedAdapter (this, _items); override protetto void OnListItemClick (ListView l, View v, int position, long id) base.OnListItemClick (l, v, position, id); var secondo = new Intent (this, typeof (WebActivity)); second.PutExtra ("link", _items [position] .Link); StartActivity (secondo); Passiamo attraverso questo snippet di codice riga per riga per vedere cosa sta succedendo.
[Attività (Etichetta = "XamFeed", MainLauncher = true, Icona = "@ drawable / icona")]
Il ActivityAttribute che decora il FeedActivity la classe è il meccanismo che Xamarin.Android utilizza per consentire al dispositivo di destinazione o all'emulatore di sapere che questo è un Attività (o schermo) accessibile all'interno dell'applicazione. Questo è richiesto a tutti Attività classi all'interno della tua applicazione.
private RssItem [] _items;
Stiamo andando a salvare tutti gli elementi del feed che tiriamo dal sito Web Xamarin in una variabile per impedirci di eseguire costantemente richieste HTTP. Si consiglia di gestirlo in modo diverso a seconda che si desideri aggiornare o meno questa schermata in un secondo momento con nuovi contenuti. Nella nostra semplice applicazione, non lo faremo.
protected async override void OnCreate (Bundle bundle)
Successivamente, ignoriamo il OnCreate metodo che è esposto attraverso il Attività classe base nel nostro FeedActivity classe. Questo metodo è chiamato ogni volta questo Attività è istanziato dal. Come puoi vedere, possiamo anche usare il nuovo C # 5.0 async / await funzione per rendere questo metodo asincrono.
base.OnCreate (fascio);
Assicurati di chiamare il base.OnCreate metodo sulla base Attività classe. Ciò garantirà che qualsiasi elaborazione della classe base faccia durante OnCreate il metodo continuerà a funzionare.
utilizzando (var client = new HttpClient ())
Per recuperare i dati RSS dal sito Web Xamarin, useremo il HttpClient classe in quanto fornisce un certo numero di metodi asincroni convenienti per recuperare i dati su HTTP.
var xmlFeed = attende client.GetStringAsync ("http://blog.xamarin.com/feed/"); var doc = XDocument.Parse (xmlFeed);Quindi invochiamo il GetStringAsync metodo sul HttpClient classe per recuperare i dati del feed e analizzare in un XDocument oggetto di fare un po ' Linq2XML Magia.
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 = item.Element ("pubDate"). Value, Creator = item.Element ( dc + "creatore"). Valore, Link = item.Element ("link"). Value). ToArray ();Per recuperare correttamente gli elementi dal risultante XDocument oggetto, abbiamo bisogno di creare un'istanza del XNamespace classe che rappresenta parte della formattazione personalizzata utilizzata nel feed RSS di Xamarin. Possiamo quindi eseguire una query LINQ contro il XDocument estrarre tutti gli elementi e creare nuove istanze di RSSItem classe basata sulle proprietà dell'oggetto.
ListAdapter = new FeedAdapter (this, _items);
Infine, usiamo un adattatore personalizzato per popolare il Visualizzazione elenco del FeedActivity, che è definito nel Main.axml documento nel Risorse / layout cartella. Pensa agli adattatori di Android come a un meccanismo per fornire una formattazione personalizzata di elementi o widget nell'interfaccia utente. Tutti i componenti dell'interfaccia utente che utilizzano adattatori, come a Visualizzazione elenco, usa gli adattatori predefiniti se non ne specifichi uno esplicitamente, ma puoi sempre sostituirli con i tuoi.
L'ultimo pezzo del puzzle per il FeedActivity la classe è sovrascrivere il OnListItemClick metodo in modo che possiamo aprire un nuovo Attività questo ci mostra il contenuto reale dei singoli articoli del feed che tocchiamo.
base.OnListItemClick (l, v, position, id);
Ancora una volta, chiamiamo il metodo della classe base per essere sicuri che venga eseguita tutta l'elaborazione normale.
var secondo = new Intent (this, typeof (WebActivity)); second.PutExtra ("link", _items [position] .Link); StartActivity (secondo);Ora seguiamo il modello di progettazione Android per il trasferimento dei dati a un nuovo Attività. Questo ti diventerà molto familiare mentre crei più applicazioni che coinvolgono più schermi. Creiamo un nuovo Intento oggetto, che è il modo Android di passare i dati a un nuovo Attività. Gli passiamo due oggetti che rappresentano il contesto di provenienza della chiamata, Questo, e il genere obiettare a dove sta andando.
Una volta che abbiamo il nuovo Intento oggetto, noi mettere cose, in genere stringhe, dentro e trasmetterle. In questo caso, usiamo il PutExtra metodo per aggiungere a chiave / valore coppia al Intento, e avviare il processo di transizione verso il WebActivity schermo con il startActivity metodo.
Basato sul codice coinvolto nella creazione di FeedActivity schermo, ora dobbiamo creare un FeedAdapter classe che popola e formatta il RSSItem dati nel nostro Visualizzazione elenco e a WebActivity classe per rappresentare la schermata successiva. Iniziamo con FeedAdapter classe.
FeedAdapter di classe pubblica: BaseAdapterprivate RssItem [] _items; Attività privata _context; FeedAdapter pubblico (contesto attività, oggetti RssItem []): base () _context = contesto; _items = articoli; public override RssItem this [int position] get return _items [position]; public override int Count get return _items.Count (); public override long GetItemId (int position) return position; public override Visualizza GetView (int position, Visualizza convertView, ViewGroup parent) var view = convertView; if (view == null) view = _context.LayoutInflater.Inflate (Android.Resource.Layout.SimpleListItem2, null); view.FindViewById (Android.Resource.Id.Text1) .Text = _items [posizione] .Title; view.FindViewById (Android.Resource.Id.Text2) .Text = string.Format ("0 su 1", _items [posizione] .Creatore, _items [posizione] .PubDate); vista di ritorno;
Yikes. Questo è un sacco di codice. In realtà è abbastanza semplice però. Abbiamo bisogno di sovrascrivere quattro metodi / proprietà sulla classe base, BaseAdapter. Nel nostro caso, il parametro generico sarà il nostro RSSItem classe. I primi tre sono abbastanza auto-esplicativi.
questa [int position] restituisce un RSSItem nella posizione data nell'array.Contare restituisce il numero di RSSItem oggetti nella matrice.GetItemId restituisce il Id di un RSSItem in una data posizione, la posizione nel nostro esempio.L'ultimo, e leggermente più complicato, override è il GetView metodo. Questo metodo ottiene un'istanza di Visualizzazione elenco dentro il nostro Attività e Gonfiare come a SimpleListItem2, che è un tipo di ListItem visualizzare all'interno di Android che consente due righe di testo in un singolo elemento. Quindi impostiamo la prima riga di testo su RssItem.Title proprietà e la seconda riga di testo a una concatenazione del RssItem.Creator proprietà e il RssItem.PubDate proprietà.
Con il set di adattatori, possiamo concentrarci sulla seconda schermata della nostra applicazione, WebActivity.
[Activity (Label = "WebActivity")] public class WebActivity: Activity protected override void OnCreate (Bundle bundle) base.OnCreate (bundle); SetContentView (Resource.Layout.WebActivity); Vista WebView = FindViewById(Resource.Id.DetailView); view.LoadUrl (Intent.GetStringExtra ( "link"));
La struttura è simile a quella del FeedActivity classe. Stiamo ancora usando il ActivityAttribute decorare il WebActivity classe. Ci sono solo tre linee leggermente diverse in questo metodo che non abbiamo incontrato prima.
SetContentView (Resource.Layout.WebActivity);
Il setContentView metodo è un bel metodo di supporto che mapperà il nostro C # Attività classe al file di layout specificato. In questo esempio, stiamo facendo riferimento al WebActivity.axml file.
Vista WebView = FindViewById(Resource.Id.DetailView); view.LoadUrl (Intent.GetStringExtra ( "link"));
Le ultime due righe sono specifiche per WebView controllo all'interno del nostro layout. Noi usiamo il findViewById metodo per ottenere un riferimento al specificato WebView controlla e chiama il loadURL metodo e passare i dati che è stato inviato a questo Attività, via un Intento, dal FeedActivity classe.
Gli ultimi pezzi del puzzle sono i file di layout che definiscono il posizionamento e la denominazione dei controlli sui singoli schermi. Il primo è il Main.axml file nel Risorse / layout cartella nella tua soluzione. Basta sostituire il suo contenuto con il seguente:
Successivamente, crea un nuovo file di layout Android in Risorse / layout cartella, chiamala WebActivity.axml, e sostituire il suo contenuto con il seguente:
Una volta che hai completato la creazione di tutti i pezzi di questa applicazione, dovresti riuscire a creare l'applicazione e distribuirla sull'emulatore Android. Il processo di compilazione è come qualsiasi altra applicazione che hai creato in Visual Studio. È possibile eseguire il debug dell'applicazione premendo F5 o eseguire l'applicazione utilizzando Control-F5. L'unica differenza è che hai un numero di opzioni di implementazione che puoi configurare. Per questo tutorial, siamo interessati a eseguire l'applicazione nell'emulatore Android, ma se si dispone di un dispositivo fisico è possibile eseguire l'applicazione anche lì.
Nella barra degli strumenti di Xamarin.Android, hai diverse opzioni. Hai un menu a discesa che ti consente di specificare la versione di Android che l'emulatore dovrebbe eseguire. Per questa applicazione, ho scelto di eseguire l'ultima versione di Android, Android_API_19 o KitKat al momento della scrittura.
Se non hai l'ultima versione dell'SDK come faccio qui, puoi aprire Android SDK Manager e scaricare la versione su cui desideri eseguire l'applicazione. Se apri il gestore di Android SDK, puoi scegliere tra una vasta gamma di versioni di Android SDK diverse e alcuni strumenti aggiuntivi.
Hai anche la possibilità di configurare gli emulatori disponibili o crearne di tuoi. Ciò avviene tramite il gestore di emulatore di Android in cui è possibile creare, modificare, copiare ed eliminare gli emulatori.
Cliccando sul Nuovo o modificare pulsante sulla destra, ti viene presentata una finestra di dialogo attraverso la quale puoi configurare l'emulatore.
Una volta che tutto è configurato nel modo che preferisci, è il momento per il momento della verità, eseguendo la tua applicazione Android. Premi F5 e attendi che l'emulatore si avvii, il che può richiedere del tempo. È quindi consigliabile lasciare l'emulatore aperto, in modo da non dover attendere che si avvii ogni volta che si distribuisce l'applicazione. Una volta che la tua applicazione è in esecuzione nell'emulatore, dovresti vedere qualcosa di simile.
La tua vista potrebbe differire leggermente, a seconda di come hai configurato l'emulatore. Toccando o facendo clic su uno dei titoli dovrebbe portarti a una visualizzazione web all'interno dell'applicazione simile a quella qui sotto.
Ecco qua. Hai creato con successo un'applicazione Android utilizzando Visual Studio, C # e un piccolo aiuto dai tuoi amici su Xamarin.
Da qui, puoi prendere una serie di passaggi. Puoi personalizzare questa applicazione per renderla completamente tua o lasciarla così com'è e impressionare i tuoi amici. In ogni caso, hai fatto un grande passo avanti nel mondo dello sviluppo mobile non Microsoft utilizzando gli strumenti Microsoft. È carino di per sé, se me lo chiedi.
La prossima volta affronteremo il mondo dello sviluppo di iOS utilizzando Xamarin.iOS, che è un processo molto simile con solo poche differenze. Eccitato? So di esserlo. Alla prossima e felice codifica.
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.
