Share
Seit Xamarin vor einigen Jahren auf die Bühne kam, freuen sich C # -Entwickler darauf, mobile Anwendungen für Nicht-Microsoft-Plattformen erstellen zu können. Mit einiger Spannung können wir jetzt Apps in einer für uns sehr vertrauten Sprache schreiben und an die großen Player im mobilen Bereich, iOS und Android, verteilen.
Da diese Apps in einer einzigen Sprache geschrieben werden können, ist es nur sinnvoll, eine einzige Codebasis schreiben zu wollen, die sich in separate Apps für die verschiedenen Plattformen kompilieren lässt und letztendlich die Welt von Einmal schreiben, überall ausführen. Das hört sich auf dem Papier gut an, war aber nicht ganz der Fall.
Das Konzept, eine Anwendung einmal zu schreiben und auf mehreren Plattformen ausführen zu können, ist nicht neu. Entwickler versuchen dies seit vielen Jahren mit Desktop- und Serveranwendungen, die in Java oder C / C ++ geschrieben und für die jeweiligen Plattformen kompiliert wurden. Warum sollten mobile Apps anders sein? Die einfache Antwort lautet: Sie sind es nicht. Als mobile App-Entwickler stoßen wir auf die gleichen plattformübergreifenden Probleme wie andere Benutzer, die Benutzeroberfläche.
Wenn es darum geht, jegliche Art von Software zu schreiben, die auf verschiedenen Plattformen ausgeführt werden soll, können Sie die einfach Teil ist die Logik. Durch einfach, Ich meine den Teil der Anwendung, der sich unabhängig von der Plattform, auf die Sie abzielen, nicht ändert. Unabhängig von der Plattform, auf die Sie abzielen, müssen Sie immer noch Daten von Diensten, Datenbanken, Dateien usw. abrufen. Wahrscheinlich ändert sich dies sehr selten. Der Teil, der sich ändert, ist die Benutzeroberfläche. Dies ist vor allem auf die inhärenten Unterschiede der verschiedenen Plattformen zurückzuführen. Jede Plattform verfügt über ein eigenes SDK, das die Funktionen der Plattform sowie ihre visuellen Komponenten und Merkmale definiert.
Wenn Sie die heutige mobile Landschaft betrachten, werden Sie schnell feststellen, dass es drei große Spieler gibt, iOS, Android, und Windows Phone. Diese drei stehen in ständigem Wettbewerb um die anderen, um mehr Marktanteile zu gewinnen. Auf absehbare Zeit sind dies jedoch die Plattformen, auf die Sie abzielen möchten. Der Grund dafür, dass die plattformübergreifende Entwicklung auf mobilen Geräten schwierig sein kann, liegt in den grundlegenden Unterschieden hinsichtlich der Benutzeroberfläche. Ein Button ist nicht mehr nur ein Button. Ein Button ist ein UIButton mit XML auf iOS, a Taste mit AXML unter Android und a Taste mit XAML unter Windows Phone.
Wie bei den meisten plattformübergreifenden Frameworks verfolgt Xamarin in der Regel eine ähnliche Strategie, um die durch die Benutzeroberfläche verursachten Kopfschmerzen zu begrenzen, indem sie die Logik von der Benutzeroberfläche aus aufteilen.
In der Welt von C # wird diese Strategie Sie normalerweise mindestens verlassen N + 1 Projekte innerhalb Ihrer Lösung. Sie werden mindestens haben ein Projekt für jeden der N Plattformen Sie zielen darauf ab und benötigen außerdem mindestens ein Projekt, das den gesamten gemeinsam genutzten Code enthält, auf den sich die Anwendung verlässt. Auf diese Weise können Sie die plattformspezifischen Projekte einfach auf das Shared-Code-Projekt verweisen lassen und sich nur um die Visualisierung der Daten kümmern. Dank einiger neuer Funktionen in den .NET- und Mono-Frameworks stehen Ihnen mehrere Optionen zur Verfügung.
Portable Class Libraries oder PCLs standen an erster Stelle. Es ist am einfachsten, PCLs als normale Klassenbibliotheken zu betrachten, nur mit eingeschränkter Funktionalität. Es ist einfacher, dieses Konzept anhand eines Beispiels zu verstehen. Erstellen Sie zunächst eine neue Lösung / ein neues Projekt und benennen Sie sie PCLDemo und wählen Sie Klassenbibliothek (Portable) als Projektvorlage.
Wenn Sie auf klicken OK In Visual Studio wird ein weiteres Fenster angezeigt, das dem folgenden ähnelt:
Abhängig von den installierten Tools kann es etwas anders aussehen. In diesem Bildschirm können Sie beliebig viele oder so wenige Plattformen auswählen, wie Sie möchten. Als Faustregel gilt, nur die Plattformen auszuwählen, auf die Sie unbedingt zielen müssen. Der Grund dafür ist, dass je mehr Plattformen Sie als Zielgruppe verwenden möchten, desto weniger Funktionen werden in diese Bibliothek aufgenommen. Eine aktuelle Liste der von den verschiedenen Plattformen unterstützten Funktionen finden Sie auf der Seite "Plattformübergreifende Entwicklung mit der Portable Class Library" in MSDN.
Wenn Sie in diesem Dialogfeld nicht die richtigen Plattformen auswählen, können Sie später auf Inkompatibilitätsprobleme stoßen. Um dies in Aktion zu sehen, deaktivieren Sie die unteren drei Optionen:
Erstellen Sie nun ein neues Projekt eines Typs, von dem Sie die Unterstützung in der PCL entfernt haben. Sie können beispielsweise ein neues Xamarin.Android-Projekt mit einer der mitgelieferten Vorlagen erstellen. Sobald das Projekt erstellt wurde, klicken Sie mit der rechten Maustaste auf Verweise und wählen Sie Füge Referenz hinzu. In dem Referenzmanager wählen Sie aus Lösung> Projekte aus dem Filter auf der linken Seite und aktivieren Sie das Kontrollkästchen neben PCLDemo Projekt.
Wenn Sie auf klicken OK, Sie werden einen Fehler wie den folgenden sehen:
Dieser Fehler informiert Sie darüber, dass das aktuelle Projekt, in dem Sie sich gerade befinden, nicht mit den in der ausgewählten PCL verfügbaren Zielen kompatibel ist. Sie können dies umgehen, indem Sie in die PCL-Projekteigenschaften gehen und die Ziele ändern. Denken Sie jedoch daran, dass je mehr Ziele verwendet werden, desto weniger unterstützte Funktionen.
Auch wenn Sie bei der Verwendung von PCLs ein paar Dinge beachten müssen, gibt es einige sehr gute Vorteile.
Bei der Wahl einer neuen Technologie oder Plattform lohnt es sich auch, die Nachteile zu verstehen, die angegangen werden müssen.
Wenn PCLs für Sie als Wahlmöglichkeit für gemeinsam genutzten Code zu limitierend erscheinen, gibt es eine andere Option.
In der aktuellen Version von Visual Studio 2013 Update 2 hat Microsoft Unterstützung für gemeinsam genutzte Projekte hinzugefügt. Freigegebene Projekte sind eine weitere Möglichkeit, Code zwischen verschiedenen Plattformen zu teilen, ähnlich wie PCLs und auf andere Weise drastisch unterschiedlich. Beginnen wir mit einem einfachen Beispiel.
Beginnen Sie mit dem Erstellen einer anderen Lösung / eines anderen Projekts in Visual Studio und geben Sie ihm einen Namen SharedDemo und auswählen Freigegebenes Projekt (leer) als Vorlage.
Wenn du nicht siehst Freigegebenes Projekt (leer) Stellen Sie als Option sicher, dass Sie über die neueste Version von Visual Studio 2013 Update 2 verfügen. Wenn Sie die aktuelle Version verwenden und immer noch nicht angezeigt werden, müssen Sie möglicherweise die Erweiterung des Shared Project Reference Manager installieren.
Sobald Sie klicken OK, Visual Studio erstellt ein neues Projekt für Sie im Lösungsforscher, aber es wird ein bisschen anders aussehen, als Sie es gewohnt sind.
Es wirkt ein bisschen einsam, oder? Da ist kein Eigenschaften Ordner und Nr Verweise Mappe. Was ist los? Das ist die Schönheit und oft die Quelle der Verwirrung für die meisten Entwickler. Standardmäßig enthält ein freigegebenes Projekt überhaupt keinen Zugriff auf Funktionen. In Visual Studio / Xamarin Studio ist hinter den Kulissen etwas Magisches los, aber das werden Sie in Kürze sehen.
Ein weiteres merkwürdiges Merkmal eines freigegebenen Projekts ist, dass Sie es nicht wirklich erstellen können. Wenn Sie mit der rechten Maustaste klicken würden Für die Lösung oder das Projekt werden keine Optionen zum Erstellen, Ausführen oder Debuggen dieses Projekts angezeigt. Um zu verstehen, warum das so ist, müssen Sie einen Moment zurücktreten.
Was ist der Zweck eines Projektes? Der Zweck besteht darin, Ihren Code aus Text in eine tatsächliche Datei umzuwandeln, die von dem System, auf dem Sie ausgeführt werden, oder einer anderen Anwendung verwendet werden kann. Aus diesem Grund können Sie ein freigegebenes Projekt nicht wirklich erstellen, es wird keine Ausgabedatei generiert. Dieses spezialisierte Projekt hat einen ganz anderen Zweck.
Wenn Sie ein freigegebenes Projekt erstellen und darin Code schreiben, können Sie ihm beliebig viele Referenzen aus anderen Projekten hinzufügen. Es gibt keine Plattformen zum Anzielen oder Regeln, die zu befolgen sind. Dies ist das erste Unterscheidungsmerkmal von PCLs. Lassen Sie uns mit einem Beispiel fortfahren. Erstelle eine neue Xamarin.Android und / oder Xamarin.iOS Projekt in Ihrer Lösung und benennen Sie sie entsprechend, SharedDemo.Android und / oder SharedDemo.iOS.
Nachdem Sie ein neues Projekt erstellt haben, klicken Sie mit der rechten Maustaste auf Verweise Ordner und wählen Sie Freigegebene Projektreferenz hinzufügen. Wenn Sie dies nicht als Option sehen, müssen Sie möglicherweise das Hinzufügen der Erweiterung "Shared Project Reference Manager" hinzufügen.
Klicken Sie hier OK und du solltest etwas ähnliches sehen:
Hier kommt die Magie ins Spiel. Der in einem Shared Project enthaltene Code wird sein kompiliert in alle Projekte, die darauf verweisen. Aus diesem Grund können Sie sie nicht direkt erstellen. Sie benötigen etwas, um sie zu referenzieren, bevor sie erstellt und kompiliert werden können. Die Tatsache, dass sie zu jedem Projekt als Referenz hinzugefügt werden können, ist ein Grund dafür, dass sie so gute Kandidaten für eine plattformübergreifende Entwicklung sind.
Der andere Grund, warum sie gute Kandidaten für die plattformübergreifende Entwicklung sind, ist die Unterstützung von Compiler-Direktiven. Sie können Überprüfungen für spezielle Anweisungen in Ihren freigegebenen Projekten vornehmen, sodass nur bestimmte Plattformen bestimmte Funktionen erhalten oder dass die Dinge auf verschiedenen Plattformen unterschiedlich behandelt werden. Folgende Richtlinien können in Plattformprojekten gefunden werden:
Accentsconagua
__HANDY, MOBILTELEFON__ Xamarin.Android- und Xamarin.iOS-Projekte__IOS__ Xamarin.iOS-Projekte__ANDROID__ Xamarin.Android-Projekte__ANDROID_xx__ Xamarin.Android Projekte wo xx wird durch die anvisierte Android-API-Version ersetztWINDOWS PHONE Windows Phone-ProjekteSILVERLIGHT Windows Phone-ProjekteSie können diese Anweisungen im Inneren verwenden #ifdef Blöcke, um zu überprüfen, auf welcher Plattform Sie ausgeführt werden, und verwenden Sie die bedingte Kompilierung, um nur die erforderlichen Elemente für jedes Projekt aufzunehmen. Dies alles erledigt der Compiler für Sie. Lassen Sie uns ein Beispiel sehen.
In deiner SharedDemo Projekt, fügen Sie eine neue Klasse mit dem Namen Rezept und ersetzen Sie die Standardimplementierung durch Folgendes:
öffentliche Klasse Recipe öffentliche Zeichenfolge ShortName get; einstellen; #if __iOS__ public string LongName get; einstellen; #endif öffentliche ListeZutaten erhalten; einstellen; öffentliche Liste Wegbeschreibung get; einstellen;
Dies ist ein kleines Beispiel, aber es dient zur Veranschaulichung eines einfachen Punktes. Da ich auf diesen Code von einem Xamarin.Android-Projekt aus verweise, enthält die Recipe-Klasse nur 3 Eigenschaften, Kurzer Name, Zutaten, und Richtungen. Wenn dieser Code von einem Xamarin.iOS-Projekt referenziert wurde, würde er auch das enthalten Langer Name Eigentum.
Sie verwenden diese Anweisungen eher in Situationen, in denen Sie auf Plattformdivergenz stoßen. Häufige Divergenzbereiche auf diesen mobilen Plattformen beziehen sich auf den Zugriff auf Hardware, das Dateisystem usw. Sie können jetzt Plattformcode im gemeinsam genutzten Projekt geteilt durch die Anweisungen platzieren, und Visual Studio übernimmt die plattformspezifische Kompilierung für die richtigen Projekte. Sehr schön.
Freigegebene Projekte enthalten einige sehr nützliche Funktionen, die bei der Erstellung von plattformübergreifenden Projekten hilfreich sind.
Während Shared Projects über nette Funktionen verfügen, gibt es einige weniger wünschenswerte Eigenschaften.
Sie kennen jetzt die grundlegenden Strategien zum Freigeben Ihrer App-Logik. Es ist an der Zeit, sich die Benutzeroberfläche Ihrer App anzusehen. In der neuesten Version von Version 3 von Xamarin ist die Einführung von Xamarin.Forms. Xamarin.Forms ist eine Bibliothek, die Abstraktionen typischer UI-Steuerelemente enthält, die die UI Ihrer App bilden. Wenn diese Steuerelemente auf bestimmten Plattformen verwendet werden, werden sie zugeordnet, um native Steuerelemente der Benutzeroberfläche wiederzugeben, sodass Sie das Erscheinungsbild nativer Komponenten erhalten.
Die grundlegende Struktur Ihrer plattformübergreifenden Anwendung ändert sich nicht. Sie werden weiterhin die N + 1-Regel in Bezug auf Projekte befolgen, verschieben jetzt jedoch Ihren plattformspezifischen UI-Code aus den plattformspezifischen Projekten in die freigegebenen Projekte. Bevor wir uns zu weit voraus sind, müssen wir die Anforderungen und Anforderungen verstehen, die nicht nur beim Ausführen, sondern auch beim Entwickeln von Xamarin.Forms-Apps bestehen.
Es gibt einige Anforderungen, wenn Sie Xamarin.Forms voll ausnutzen möchten. Um Xamarin.Forms verwenden zu können, muss Ihre App auf die folgenden Plattformen ausgerichtet sein:
Dies bedeutet, dass Sie Xamarin.Forms nicht verwenden können, wenn Sie auf ältere Versionen dieser Plattformen abzielen. Neben Einschränkungen für Zielplattformen gibt es auch einige Anforderungen an das Entwicklungssystem.
Nachdem Sie alles heruntergeladen und konfiguriert haben, können Sie loslegen.
Die Grundidee von Xamarin.Forms ist einfach: Sie beziehen sich auf die üblichen Steuerelemente der Benutzeroberfläche, unabhängig von den Plattformen, auf die Sie abzielen. Eine Schaltfläche ist eine Schaltfläche ist eine Schaltfläche. Sie erstellen diese Steuerelemente und geben ihnen visuelle Merkmale und Funktionen. Sie verwenden dann eine Layout um die Steuerelemente auf dem Bildschirm zu positionieren und alles auf einem Bildschirm anzuzeigen Seite. Wenn Sie es gewohnt sind, plattformspezifische Terminologie zur Beschreibung der UI-Komponenten Ihrer Apps zu verwenden, kann es einige Zeit dauern, sich an die neuen Begriffe zu gewöhnen. Zum Glück gibt es nur wenige Konzepte zu verstehen.
In Xamarin.Forms stellen Pages die tatsächlichen Bildschirme Ihrer Anwendung dar. In Bezug auf andere Plattformen a Seite ist ein Aktivität auf Android a UIViewController auf iOS und a Seite unter Windows Phone. Das Seite ist das Hauptobjekt, mit dem Sie sich beschäftigen, wenn Sie mit Übergängen und Navigation arbeiten. Auch ein Seite enthält nur ein einzelnes Kind, das in den meisten Situationen eine Art von ist Layout.
Layouts sind Steuerelemente zum Organisieren von UI-Komponenten auf Ihrem Computer Seite auf logische Weise. Innerhalb eines Layout, Sie können Eigenschaften der UI-Steuerelemente festlegen, z. B. Position und Größe. Sie können einem Layout beliebig viele UI-Komponenten hinzufügen, einschließlich Steuerelementen und anderen Layout Objekte.
In Xamarin.Forms sind Ansichten das, was Sie normalerweise als Steuerelemente bezeichnen würden. Verbreitet Aussicht Objekte in Xamarin.Forms sind Taste, Etikette, und Listenansicht, um ein paar zu nennen. Das Layout Klasse erbt tatsächlich von der Aussicht Klasse, was bedeutet, dass sie auf dieselbe Weise behandelt und hinzugefügt werden können Layout Objekte.
Zellen sind spezialisierte UI-Komponenten, mit denen angepasst wird, was normalerweise als Zeilen innerhalb bezeichnet wird Listenansicht und UITableView Objekte. Es sind vorgefertigt Zelle Typen, um Ihrem Computer eine Reihe verschiedener Anpassungen hinzuzufügen Aussicht Objekte.
Um eine grundlegende Xamarin.Forms-Anwendung zu erstellen, öffnen Sie Visual Studio und wählen Sie Datei> Neues Projekt, wähle aus Mobile Apps Kategorie und wählen Sie die entsprechende Vorlage. Ich habe die gewählt Leere App (Xamarin.Forms Shared) Vorlage. Dadurch wird eine Xamarin.Forms-Anwendung mit der Freigegebenes Projekt Vorlage.
Nach dem Klicken OK, Ihre Lösung wird mit vier Projekten erstellt. Wie bereits erwähnt, werden Sie drei plattformspezifische Projekte und ein gemeinsames Projekt haben. Das freigegebene Projekt enthält die Anwendungslogik sowie den gesamten Xamarin.Forms-Code, der für die Erstellung der Bildschirme verantwortlich ist (Seite Objekte) Ihrer Anwendung.
Wenn Sie das öffnen SampleFormsApp Projekt sehen Sie eine einzelne Klasse mit dem Namen App.cs. Dies ist die Hauptdatei des Projekts, das die Seite Definitionen, die letztendlich auf den Zielplattformen angezeigt werden. Es ist eine einfache Klasse, die nur Folgendes enthält:
öffentliche Klasse App öffentliche statische Seite GetMainPage () return new ContentPage Inhalt = neues Label Text = "Hallo, Formulare!", VerticalOptions = LayoutOptions.CenterAndExpand, HorizontalOptions = LayoutOptions.CenterAndExpand,;;
Die Klasse App ist ziemlich einfach, da sie nur eine einzige statische Methode enthält, die eine zurückgibt Inhaltsseite Objekt. EIN Inhaltsseite Objekt ist das einfachste, schnörkellosste Seite das kannst du schaffen. Es ist am einfachsten an eine zu denken Inhaltsseite als leere Leinwand, mit der Sie alles tun können, was Sie möchten. Es ist sehr wenig Funktionalität darin eingebaut.
Das finden Sie normalerweise am meisten Seite Objekte haben eine Inhalt Eigenschaft, die Sie zuweisen können Aussicht Einwände dagegen In diesem Fall ist es einfach Etikette Ansicht, die druckt "Hallo, Formulare!" auf dem Bildschirm und geben ihm einige grundlegende Formatierungen für die Zentrierung.
Um das zu bekommen Inhaltsseite Für das Laden auf jeder Plattform, auf die wir abzielen, muss in jedem Plattformprojekt benutzerdefinierter plattformspezifischer Code enthalten sein. Werfen wir zunächst einen Blick auf das iOS-Projekt. Öffne das SampleFormsApp.iOS Projekt und werfen Sie einen Blick auf die AppDelegate.cs Datei. Dies ist die Datei, die die Verkabelung in die Xamarin.Forms-Welt enthält.
public überschreiben bool FinishedLaunching (UIApplication-App, NSDictionary-Optionen) Forms.Init (); window = new UIWindow (UIScreen.MainScreen.Bounds); window.RootViewController = App.GetMainPage (). CreateViewController (); window.MakeKeyAndVisible (); wahr zurückgeben;
Zunächst initialisieren wir die Xamarin.Forms-Bibliothek mit dem Aufruf Forms.Init (). Danach wird der einzige benutzerdefinierte Code eingestellt window.RootViewController Eigenschaft zum Ergebnis der App.GetMainPage (). CreateViewController () Anruf. Diese Linie wird in die Xamarin.Forms-Welt eingeführt, und ab diesem Zeitpunkt wird weiterhin Xamarin.Forms verwendet.
Der Vorgang zur Initialisierung von Xamarin.Forms in Android und Windows Phone ist sehr ähnlich. Sie rufen an Drin Methode und setzen Sie den Anfang Seite das Ergebnis der sein App.GetMainPage () Methode. So sieht es in der aus SampleFormsApp.Android Projekt in der MainActivity.OnCreate Methode.
protected override void OnCreate (Bundle-Paket) base.OnCreate (Bundle); Xamarin.Forms.Forms.Init (dieses Bundle); SetPage (App.GetMainPage ());
Und in der SampleFormsApp.WinPhone Projekt in der Hauptseite Konstruktor der Teilklasse Hauptseite:
public MainPage () InitializeComponent (); Forms.Init (); Content = SampleFormsApp.App.GetMainPage (). ConvertPageToUIElement (this);
Sie sollten jetzt ein grundlegendes Verständnis von Xamarin.Forms haben und wissen, was Sie mit deren Verwendung erreichen können. Die Reise in diese erstaunliche Technologie hört nicht dort auf. Wenn Sie Xamarin.Forms verwenden, haben Sie eine andere Wahl, die sich auf das Layout bezieht. Und genau das wird im nächsten Tutorial behandelt.
Wenn Sie mehr über Xamarin erfahren möchten, besuchen Sie unseren Kurs Erstellen von Multiplattform-Apps mit C # in Xamarin.
In diesem Kurs erfahren Sie, wie Sie eine plattformübergreifende Anwendung aus einer einzigen Codebasis erstellen, die auf drei verschiedenen Plattformen ausgeführt wird: iOS, Android und Windows Phone 8. Denken Sie, dass dies nicht möglich ist? In kurzer Zeit werden Sie es selbst tun. Lass uns zur Arbeit gehen.
Sie können das gleich mit nehmen komplett frei 14-tägige Testversion eines Tuts + Abonnements. Werfen Sie einen Blick auf unsere Abonnementoptionen, um anzufangen, oder wenn Sie nur an diesem Kurs interessiert sind, können Sie ihn einzeln für 15 $ kaufen! Hier ist eine Vorschau für den Einstieg:
