Exemplarische Vorgehensweise: Binden einer IOS-Ziel-C-BibliothekWalkthrough: Binding an iOS Objective-C Library

Wichtig

Wir untersuchen derzeit die Nutzung benutzerdefinierter Bindungen auf der Xamarin-Plattform.We're currently investigating custom binding usage on the Xamarin platform. Nehmen Sie an dieser Umfrage teil, um zukünftige Entwicklungsarbeiten zu unterstützen.Please take this survey to inform future development efforts.

Dieser Artikel enthält eine praktische Exemplarische Vorgehensweise zum Erstellen einer xamarin. IOS-Bindung für eine vorhandene Ziel-C-Bibliothek, infcolorpicker. Es behandelt Themen wie das Kompilieren einer statischen Ziel-C-Bibliothek, deren Bindung und die Verwendung der Bindung in einer xamarin. IOS-Anwendung.This article provides a hands-on walkthrough of creating a Xamarin.iOS binding for an existing Objective-C library, InfColorPicker. It covers topics such as compiling a static Objective-C library, binding it, and using the binding in a Xamarin.iOS application.

Bei der Arbeit mit IOS kann es vorkommen, dass Sie eine Ziel-C-Bibliothek eines Drittanbieters verwenden möchten.When working on iOS, you might encounter cases where you want to consume a third-party Objective-C library. In diesen Fällen können Sie ein xamarin. IOS- Bindungs Projekt verwenden, um eine c#-Bindung zu erstellen, die es Ihnen ermöglicht, die Bibliothek in ihren xamarin. IOS-Anwendungen zu nutzen.In those situations, you can use a Xamarin.iOS Binding Project to create a C# binding that will allow you to consume the library in your Xamarin.iOS applications.

In der Regel im IOS-Ökosystem finden Sie Bibliotheken in drei Varianten:Generally in the iOS ecosystem you can find libraries in 3 flavors:

  • Als vorkompilierte statische Bibliotheksdatei mit .a Erweiterung zusammen mit den zugehörigen Headern (h-Dateien).As a precompiled static library file with .a extension together with its header(s) (.h files). Beispiel: die Analyse Bibliothek von GoogleFor example, Google’s Analytics Library
  • Als vorkompiliertes Framework.As a precompiled Framework. Dabei handelt es sich nur um einen Ordner, der die statische Bibliothek, Header und manchmal zusätzliche Ressourcen mit der .framework Erweiterung enthält.This is just a folder containing the static library, headers and sometimes additional resources with .framework extension. Beispielsweise die AdMob-Bibliothek von Google.For example, Google’s AdMob Library.
  • Nur als Quell Code Dateien.As just source code files. Beispielsweise eine Bibliothek, die nur .m und .h Ziel-C-Dateien enthält.For example, a library containing just .m and .h Objective C files.

Im ersten und zweiten Szenario gibt es bereits eine vorkompilierte, statische cocoatouch-Bibliothek, daher konzentrieren wir uns in diesem Artikel auf das dritte Szenario.In the first and second scenario there will already be a precompiled CocoaTouch Static Library so in this article we will focus on the third scenario. Bevor Sie beginnen, eine Bindung zu erstellen, sollten Sie die in der Bibliothek bereitgestellte Lizenz immer überprüfen, um sicherzustellen, dass Sie diese binden können.Remember, before you start to create a binding, always check the licence provided with the library to ensure that you are free to bind it.

Dieser Artikel enthält eine schrittweise exemplarische Vorgehensweise zum Erstellen eines Bindungs Projekts mithilfe des Open Source-Projekts " infcolorpicker " für Ziel-c. alle Informationen in diesem Handbuch können jedoch für die Verwendung mit der Ziel-c-Bibliothek von Drittanbietern angepasst werden.This article provides a step-by-step walkthrough of creating a binding project using the open source InfColorPicker Objective-C project as an example, however all information in this guide can be adapted for use with any third-party Objective-C library. Die infcolorpicker-Bibliothek stellt einen wiederverwendbaren Ansichts Controller bereit, mit dem der Benutzer eine Farbe basierend auf der HSB-Darstellung auswählen kann, wodurch die Farbauswahl benutzerfreundlicher wird.The InfColorPicker library provides a reusable view controller that allows the user to select a color based on its HSB representation, making color selection more user-friendly.

Beispiel für die infcolorpicker-Bibliothek, die unter IOS ausgeführt wirdExample of the InfColorPicker library running on iOS

Wir behandeln alle notwendigen Schritte, um diese spezielle Ziel-C-API in xamarin. IOS zu verwenden:We'll cover all the necessary steps to consume this particular Objective-C API in Xamarin.iOS:

  • Zuerst erstellen wir eine statische Ziel-C-Bibliothek mithilfe von Xcode.First, we'll create an Objective-C static library using Xcode.
  • Dann binden wir diese statische Bibliothek mit xamarin. IOS.Then, we'll bind this static library with Xamarin.iOS.
  • Zeigen Sie als nächstes an, wie die Arbeitsauslastung durch Ziel-Sharpie reduziert werden kann, indem automatisch einige (aber nicht alle) der für die xamarin. IOS-Bindung erforderlichen API-Definitionen erstellt werden.Next, show how Objective Sharpie can reduce the workload by automatically generating some (but not all) of the necessary API definitions required by the Xamarin.iOS binding.
  • Schließlich erstellen wir eine xamarin. IOS-Anwendung, die die Bindung verwendet.Finally, we'll create a Xamarin.iOS application that uses the binding.

Die Beispielanwendung veranschaulicht, wie ein starker Delegat für die Kommunikation zwischen der infcolorpicker-API und dem c#-Code verwendet wird.The sample application will demonstrate how to use a strong delegate for communication between the InfColorPicker API and our C# code. Nachdem Sie erfahren haben, wie Sie einen starken Delegaten verwenden, wird erläutert, wie Sie schwache Delegaten verwenden, um dieselben Aufgaben auszuführen.After we've seen how to use a strong delegate, we'll cover how to use weak delegates to perform the same tasks.

AnforderungenRequirements

In diesem Artikel wird davon ausgegangen, dass Sie mit Xcode und der Programmiersprache "Ziel-c" vertraut sind und dass Sie unsere Bindungs Ziel-c- Dokumentation gelesen haben.This article assumes that you have some familiarity with Xcode and the Objective-C language and you have read our Binding Objective-C documentation. Außerdem ist Folgendes erforderlich, um die folgenden Schritte auszuführen:Additionally, the following is required to complete the steps presented:

  • Xcode und IOS SDK : der Xcode von Apple und die neueste IOS-API müssen auf dem Computer des Entwicklers installiert und konfiguriert werden.Xcode and iOS SDK - Apple's Xcode and the latest iOS API need to be installed and configured on the developer's computer.
  • Xcode-Befehlszeilen Tools : die Xcode-Befehlszeilen Tools müssen für die aktuell installierte Version von Xcode installiert werden (Weitere Informationen zur Installation finden Sie unten).Xcode Command Line Tools - The Xcode Command Line Tools must be installed for the currently installed version of Xcode (see below for installation details).
  • Visual Studio für Mac oder Visual Studio : die neueste Version von Visual Studio für Mac oder Visual Studio sollte auf dem Entwicklungs Computer installiert und konfiguriert werden.Visual Studio for Mac or Visual Studio - The latest version of Visual Studio for Mac or Visual Studio should be installed and configured on the development computer. Zum Entwickeln einer xamarin. IOS-Anwendung ist ein Apple Mac erforderlich, und wenn Sie Visual Studio verwenden, müssen Sie mit einem xamarin. IOS-buildhost verbunden sein.An Apple Mac is required for developing a Xamarin.iOS application, and when using Visual Studio you must be connected to a Xamarin.iOS build host
  • Die neueste Version von Target Sharpie : eine aktuelle Kopie des Ziel-Sharpie-Tools, das hierheruntergeladen wird.The latest version of Objective Sharpie - A current copy of the Objective Sharpie tool downloaded from here. Wenn Sie bereits das Ziel "Sharpie" installiert haben, können Sie es mithilfe dersharpie updateIf you already have Objective Sharpie installed, you can update it to the latest version by using the sharpie update

Installieren der Xcode-Befehlszeilen ToolsInstalling the Xcode Command Line Tools

Wie bereits erwähnt, verwenden wir Xcode-Befehlszeilen Tools (insbesondere make und lipo ) in dieser exemplarischen Vorgehensweise.As stated above, we'll be using Xcode Command Line Tools (specifically make and lipo) in this walkthrough. Der make Befehl ist ein sehr häufiges UNIX-Hilfsprogramm, das die Kompilierung ausführbarer Programme und Bibliotheken mithilfe eines Makefile automatisiert, das angibt, wie das Programm erstellt werden soll.The make command is a very common Unix utility that will automate the compilation of executable programs and libraries by using a makefile that specifies how the program should be built. Der lipo Befehl ist ein OS X-Befehlszeilen-Hilfsprogramm zum Erstellen von Dateien mit mehreren Architekturen. es werden mehrere .a Dateien zu einer Datei zusammengefasst, die von allen Hardwarearchitekturen verwendet werden kann.The lipo command is an OS X command line utility for creating multi-architecture files; it will combine multiple .a files into one file that can be used by all hardware architectures.

Gemäß der Apple-Dokumentation über die Befehlszeile mit der Dokumentation zu Xcode FAQ in OS X 10,9 und höher unterstützt der Download Bereich des Dialog Felds Xcode- Einstellungen nicht mehr die Download-Befehlszeilen Tools.According to Apple's Building from the Command Line with Xcode FAQ documentation, in OS X 10.9 and greater, the Downloads pane of Xcode Preferences dialog not longer supports the downloading command-line tools.

Sie müssen eine der folgenden Methoden verwenden, um die Tools zu installieren:You'll need to use one of the following methods to install the tools:

  • Installieren von Xcode : Wenn Sie Xcode installieren, werden alle Ihre Befehlszeilen Tools gebündelt.Install Xcode - When you install Xcode, it comes bundled with all your command-line tools. In OS X 10,9-Shims (installiert in /usr/bin ) kann jedes in enthaltene Tool /usr/bin dem entsprechenden Tool in Xcode zuordnen.In OS X 10.9 shims (installed in /usr/bin), can map any tool included in /usr/bin to the corresponding tool inside Xcode. Beispielsweise der- xcrun Befehl, mit dem Sie ein beliebiges Tool in Xcode über die Befehlszeile suchen oder ausführen können.For example, the xcrun command, which allows you to find or run any tool inside Xcode from the command line.

  • Die Terminalanwendung : Sie können die Befehlszeilen Tools über die Terminalanwendung installieren, indem Sie den folgenden xcode-select --install Befehl ausführen:The Terminal Application - From the Terminal application, you can install the command line tools by running the xcode-select --install command:

    • Starten Sie die Terminal Anwendung.Start the Terminal Application.
    • Geben xcode-select --install Sie ein, und drücken Sie die EingabeTaste:Type xcode-select --install and press Enter, for example:
    Europa:~ kmullins$ xcode-select --install
    
    • Sie werden aufgefordert, die Befehlszeilen Tools zu installieren. Klicken Sie auf die Schaltfläche Installieren , um  die Befehlszeilen Tools zu installieren.You'll be asked to install the command line tools, click the Install button: Installing the command line tools

    • Die Tools werden von den Apple-Servern heruntergeladen und installiert:  herunterladen der ToolsThe tools will be downloaded and installed from Apple's servers: Downloading the tools

  • Downloads für Apple-Entwickler : das Paket mit den Befehlszeilen Tools ist auf der Webseite Downloads for Apple Developers verfügbar.Downloads for Apple Developers - The Command Line Tools package is available the Downloads for Apple Developers web page. Melden Sie sich mit Ihrer Apple-ID an, suchen Sie die Befehlszeilen Tools, und laden Sie Sie herunter: Suchen  der Befehlszeilen ToolsLog in with your Apple ID, then search for and download the Command Line Tools: Finding the Command Line Tools

Wenn die Befehlszeilen Tools installiert sind, können wir mit der exemplarischen Vorgehensweise fortfahren.With the Command Line Tools installed, we're ready to continue on with the walkthrough.

Exemplarische VorgehensweiseWalkthrough

In dieser exemplarischen Vorgehensweise werden die folgenden Schritte behandelt:In this walkthrough, we'll cover the following steps:

  • Erstellen einer statischen Bibliothek : dieser Schritt umfasst das Erstellen einer statischen Bibliothek des Ziel-C-Codes von infcolorpicker .Create a Static Library - This step involves creating a static library of the InfColorPicker Objective-C code. Die statische Bibliothek verfügt über die .a Dateierweiterung und wird in die .NET-Assembly des Bibliotheks Projekts eingebettet.The static library will have the .a file extension, and will be embedded into the .NET assembly of the library project.
  • Erstellen eines xamarin. IOS-Bindungs Projekts : Sobald wir über eine statische Bibliothek verfügen, verwenden wir diese, um ein xamarin. IOS-Bindungs Projekt zu erstellen.Create a Xamarin.iOS Binding Project - Once we have a static library, we will use it to create a Xamarin.iOS binding project. Das Bindungs Projekt besteht aus der statischen Bibliothek, die wir soeben erstellt haben, und Metadaten in Form von c#-Code, in dem erläutert wird, wie die Ziel-C-API verwendet werden kann.The binding project consists of the static library we just created and metadata in the form of C# code that explains how the Objective-C API can be used. Diese Metadaten werden im Allgemeinen als API-Definitionen bezeichnet.This metadata is commonly referred to as the API definitions. Wir verwenden Ziel-Sharpie , um uns bei der Erstellung der API-Definitionen zu unterstützen.We'll use Objective Sharpie to help us with create the API definitions.
  • Normalisieren der API-Definitionen : Ziel-Sharpie führt zu einer großen Aufgabe, uns zu unterstützen, aber es kann nicht alles durchführen.Normalize the API Definitions - Objective Sharpie does a great job of helping us, but it can't do everything. Wir besprechen einige Änderungen, die wir an den API-Definitionen vornehmen müssen, bevor Sie verwendet werden können.We'll discuss some changes that we need to make to the API definitions before they can be used.
  • Verwenden der Bindungs Bibliothek : Schließlich erstellen wir eine xamarin. IOS-Anwendung, um zu zeigen, wie das neu erstellte Bindungs Projekt verwendet werden kann.Use the Binding Library - Finally, we'll create a Xamarin.iOS application to show how to use our newly created binding project.

Nachdem wir nun verstanden haben, welche Schritte ausgeführt werden, können wir uns mit dem Rest der exemplarischen Vorgehensweise beschäftigen.Now that we understand what steps are involved, let's move on to the rest of the walkthrough.

Erstellen einer statischen BibliothekCreating A Static Library

Wenn wir den Code für infcolorpicker in GitHub untersuchen:If we inspect the code for InfColorPicker in Github:

Überprüfen des Codes für infcolorpicker in GitHubInspect the code for InfColorPicker in Github

Die folgenden drei Verzeichnisse können im Projekt angezeigt werden:We can see the following three directories in the project:

  • Infcolorpicker : dieses Verzeichnis enthält den Ziel-C-Code für das Projekt.InfColorPicker - This directory contains the Objective-C code for the project.
  • Pickersamplepad : dieses Verzeichnis enthält ein Beispiel-iPad-Projekt.PickerSamplePad - This directory contains a sample iPad project.
  • Pickersamplephone : dieses Verzeichnis enthält ein Beispiel-iPhone-Projekt.PickerSamplePhone - This directory contains a sample iPhone project.

Laden wir das infcolorpicker-Projekt von GitHub herunter, und entpacken Sie es in das Verzeichnis unserer Wahl.Let's download the InfColorPicker project from GitHub and unzip it in the directory of our choosing. Wenn Sie das Xcode-Ziel für das PickerSamplePhone Projekt öffnen, wird die folgende Projektstruktur im Xcode-Navigator angezeigt:Opening up the Xcode target for PickerSamplePhone project, we see the following project structure in the Xcode Navigator:

Die Projektstruktur im Xcode-Navigator.The project structure in the Xcode Navigator

Dieses Projekt erreicht die Wiederverwendung von Code durch direktes Hinzufügen des infcolorpicker-Quellcodes (im roten Feld) zu jedem Beispiel Projekt.This project achieves code reuse by directly adding the InfColorPicker source code (in the red box) into each sample project. Der Code für das Beispiel Projekt befindet sich im blauen Feld.The code for the sample project is inside the blue box. Da uns dieses bestimmte Projekt keine statische Bibliothek bereitstellt, ist es erforderlich, ein Xcode-Projekt zu erstellen, um die statische Bibliothek zu kompilieren.Because this particular project does not provide us with a static library, it is necessary for us create an Xcode project to compile the static library.

Der erste Schritt besteht darin, dass wir den infocolorpicker-Quellcode der statischen Bibliothek hinzufügen.The first step is for us to add the InfoColorPicker source code into the Static Library. Um dies zu erreichen, gehen Sie folgendermaßen vor:To achieve this let's do the following:

  1. Starten Sie Xcode.Start Xcode.

  2. Wählen Sie im Menü Datei die Option Neues > Projekt... aus:From the File menu select New > Project...:

    Erstellen eines neuen ProjektsStarting a new project

  3. Wählen Sie Framework & Bibliothekaus, und klicken Sie dann auf die Schalt Fläche weiter :Select Framework & Library, the Cocoa Touch Static Library template and click the Next button:

    Vorlage für die statische Cocoa-Eingabe Vorlage auswählenSelect the Cocoa Touch Static Library template

  4. Geben Sie InfColorPicker als Projektnamen ein, und klicken Sie auf die Schaltfläche weiter :Enter InfColorPicker for the Project Name and click the Next button:

    Geben Sie infcolorpicker als Projektnamen ein.Enter InfColorPicker for the Project Name

  5. Wählen Sie einen Speicherort für das Projekt aus, und klicken Sie auf die Schaltfläche OK .Select a location to save the project and click the OK button.

  6. Nun müssen wir die Quelle aus dem Projekt infcolorpicker dem statischen Bibliotheksprojekt hinzufügen.Now we need to add the source from the InfColorPicker project to our static library project. Da die Datei " infcolorpicker. h " in der statischen Bibliothek bereits vorhanden ist (standardmäßig), lässt Xcode nicht zu, dass Sie überschrieben werden kann.Because the InfColorPicker.h file already exists in our static library (by default), Xcode will not allow us to overwrite it. Navigieren Sie aus dem Finderin das ursprüngliche Projekt, das Sie aus GitHub entzippt haben, zum infcolorpicker-Quellcode, kopieren Sie alle infcolorpicker-Dateien, und fügen Sie Sie in unser neues statisches Bibliotheksprojekt ein:From the Finder, navigate to the InfColorPicker source code in the original project that we unzipped from GitHub, copy all of the InfColorPicker files and paste them into our new static library project:

    Alle infcolorpicker-Dateien kopierenCopy all of the InfColorPicker files

  7. Kehren Sie zu Xcode zurück, klicken Sie mit der rechten Maustaste auf den Ordner infcolorpicker , und wählen Sie dann Dateien zu "infcolorpicker" hinzufügenaus:Return to Xcode, right click on the InfColorPicker folder and select Add files to "InfColorPicker...":

    Hinzufügen von DateienAdding files

  8. Navigieren Sie im Dialogfeld "Dateien hinzufügen" zu den von uns soeben kopierten Quell Code Dateien für infcolorpicker, wählen Sie alle aus, und klicken Sie auf die Schaltfläche Hinzufügen :From the Add Files dialog box, navigate to the InfColorPicker source code files that we just copied, select them all and click the Add button:

    Alle auswählen und auf die Schaltfläche "hinzufügen" klickenSelect all and click the Add button

  9. Der Quellcode wird in unser Projekt kopiert:The source code will be copied into our project:

    Der Quellcode wird in das Projekt kopiert.The source code will be copied into the project

  10. Wählen Sie im Xcode-Projekt Navigator die Datei infcolorpicker. m aus, und kommentieren Sie die letzten beiden Zeilen aus (aufgrund der Art und Weise, in der diese Bibliothek geschrieben wurde, wird diese Datei nicht verwendet):From the Xcode Project Navigator, select the InfColorPicker.m file and comment out the last two lines (because of the way this library was written, this file is not used):

    Bearbeiten der Datei "infcolorpicker. m"Editing the InfColorPicker.m file

  11. Wir müssen jetzt überprüfen, ob für die Bibliothek Frameworks erforderlich sind.We now need to check if there are any Frameworks required by the library. Sie finden diese Informationen entweder in der Infodatei oder indem Sie eines der bereitgestellten Beispiel Projekte öffnen.You can find this information either in the README, or by opening one of the sample projects provided. In diesem Beispiel Foundation.framework werden, UIKit.framework und CoreGraphics.framework hinzugefügt.This example uses Foundation.framework, UIKit.framework, and CoreGraphics.framework so let's add them.

  12. Wählen Sie das Ziel > buildphasen aus, und erweitern Sie den Abschnitt Link Binary with Libraries :Select the InfColorPicker target > Build Phases and expand the Link Binary With Libraries section:

    Erweitern Sie den Abschnitt Link Binary with Libraries.Expand the Link Binary With Libraries section

  13. Verwenden + Sie die Schaltfläche, um das Dialogfeld zu öffnen, in dem Sie die oben aufgeführten erforderlichen Frames hinzufügen können:Use the + button to open the dialog allowing you to add the required frames frameworks listed above:

    Fügen Sie die oben aufgeführten erforderlichen Frame-Frameworks hinzu.Add the required frames frameworks listed above

  14. Der Abschnitt Link Binary with Libraries sollte nun wie in der folgenden Abbildung aussehen:The Link Binary With Libraries section should now look like the image below:

    Der Link Binary with Libraries-AbschnittThe Link Binary With Libraries section

An diesem Punkt sind wir geschlossen, aber wir sind noch nicht fertig.At this point we're close, but we're not quite done. Die statische Bibliothek wurde erstellt, aber wir müssen Sie erstellen, um eine FAT-Binärdatei zu erstellen, die alle erforderlichen Architekturen für IOS-Geräte und IOS-Simulator enthält.The static library has been created, but we need to build it to create a Fat binary that includes all of the required architectures for both iOS device and iOS simulator.

Erstellen einer FAT-BinärdateiCreating a Fat Binary

Alle IOS-Geräte verfügen über Prozessoren, die von der ARM-Architektur betrieben werden und mit der Zeit entwickelt wurdenAll iOS devices have processors powered by ARM architecture that have developed over time. Jede neue Architektur hat neue Anweisungen und andere Verbesserungen hinzugefügt, wobei die Abwärtskompatibilität weiterhin gewahrt bleibt.Each new architecture added new instructions and other improvements while still maintaining backwards compatibility. IOS-Geräte verfügen über ARMv6, armv7, armv7s, arm64-Anweisungs Sätze – Obwohl ARMv6 nicht mehr verwendet wird.iOS devices have armv6, armv7, armv7s, arm64 instruction sets – although armv6 not used any more. Der IOS-Simulator wird nicht von Arm unterversorgt und ist stattdessen ein x86-und x86_64 gestützter Simulator.The iOS simulator is not powered by ARM and is instead a x86 and x86_64 powered simulator. Dies bedeutet, dass Bibliotheken für jeden Anweisungs Satz bereitgestellt werden müssen.That means libraries must be provided for each instruction set.

Eine FAT-Bibliothek ist eine .a Datei, die alle unterstützten Architekturen enthält.A Fat library is .a file containing all the supported architectures.

Das Erstellen einer FAT-Binärdatei ist ein dreistufiger Prozess:Creating a fat binary is a three step process:

  • Kompilieren Sie eine ARM 7-& ARM64 Version der statischen Bibliothek.Compile an ARM 7 & ARM64 version of the static library.
  • Kompilieren Sie eine x86-und x84_64-Version der statischen Bibliothek.Compile an x86 and x84_64 version of the static library.
  • Verwenden Sie das- lipo Befehlszeilen Tool, um die beiden statischen Bibliotheken zu einer zu kombinieren.Use the lipo command line tool to combine the two static libraries into one.

Diese drei Schritte sind zwar recht unkompliziert, es kann jedoch erforderlich sein, Sie in Zukunft zu wiederholen, wenn die Ziel-C-Bibliothek Updates empfängt oder wenn wir Fehlerbehebungen benötigen.While these three steps are rather straightforward, it may be necessary to repeat them in the future when the Objective-C library receives updates or if we require bug fixes. Wenn Sie diese Schritte automatisieren, wird die zukünftige Wartung und Unterstützung des IOS-Bindungs Projekts vereinfacht.If you decide to automate these steps, it will simplify the future maintenance and support of the iOS binding project.

Es stehen zahlreiche Tools zur Verfügung, mit denen Sie Aufgaben wie Shellskripts, Rake, xbuildund Make automatisieren können.There are many tools available to automate such tasks - a shell script, rake, xbuild, and make. Wenn die Xcode-Befehlszeilen Tools installiert sind, make wird ebenfalls installiert. Dies ist das Buildsystem, das für diese exemplarische Vorgehensweise verwendet wird.When the Xcode Command Line tools are installed, make is also installed, so that is the build system that will be used for this walkthrough. Hier ist ein Makefile , mit dem Sie eine freigegebene Bibliothek für mehrere Architekturen erstellen können, die auf einem IOS-Gerät und dem Simulator für jede Bibliothek funktioniert:Here is a Makefile that you can use to create a multi-architecture shared library that will work on an iOS device and the simulator for any library:

XBUILD=/Applications/Xcode.app/Contents/Developer/usr/bin/xcodebuild
PROJECT_ROOT=./YOUR-PROJECT-NAME
PROJECT=$(PROJECT_ROOT)/YOUR-PROJECT-NAME.xcodeproj
TARGET=YOUR-PROJECT-NAME

all: lib$(TARGET).a

lib$(TARGET)-i386.a:
    $(XBUILD) -project $(PROJECT) -target $(TARGET) -sdk iphonesimulator -configuration Release clean build
    -mv $(PROJECT_ROOT)/build/Release-iphonesimulator/lib$(TARGET).a $@

lib$(TARGET)-armv7.a:
    $(XBUILD) -project $(PROJECT) -target $(TARGET) -sdk iphoneos -arch armv7 -configuration Release clean build
    -mv $(PROJECT_ROOT)/build/Release-iphoneos/lib$(TARGET).a $@

lib$(TARGET)-arm64.a:
    $(XBUILD) -project $(PROJECT) -target $(TARGET) -sdk iphoneos -arch arm64 -configuration Release clean build
    -mv $(PROJECT_ROOT)/build/Release-iphoneos/lib$(TARGET).a $@

lib$(TARGET).a: lib$(TARGET)-i386.a lib$(TARGET)-armv7.a lib$(TARGET)-arm64.a
    xcrun -sdk iphoneos lipo -create -output $@ $^

clean:
    -rm -f *.a *.dll

Geben Sie die Makefile -Befehle im nur-Text-Editor Ihrer Wahl ein, und aktualisieren Sie die Abschnitte mit Ihrem Projektnamen mit dem Namen Ihres Projekts.Enter the Makefile commands in the plain text editor of your choosing, and update the sections with YOUR-PROJECT-NAME with the name of your project. Es ist auch wichtig, sicherzustellen, dass Sie die obigen Anweisungen genau einfügen, wobei die Registerkarten in den Anweisungen beibehalten werden.It is also important to ensure that you paste the instructions above exactly, with the tabs within the instructions preserved.

Speichern Sie die Datei mit dem Namen Makefile am gleichen Speicherort wie die statische Bibliothek infcolorpicker Xcode, die wir oben erstellt haben:Save the file with the name Makefile to the same location as the InfColorPicker Xcode Static Library we created above:

Speichern Sie die Datei mit dem Namen Makefile.Save the file with the name Makefile

Öffnen Sie die Terminal Anwendung auf Ihrem Mac, und navigieren Sie zum Speicherort Ihrer Makefile.Open the Terminal Application on your Mac and navigate to the location of your Makefile. Geben make Sie in das Terminal ein, drücken Sie die Eingabe Taste, und das Makefile wird ausgeführt:Type make into the Terminal, press Enter and the Makefile will be executed:

Beispiel für Makefile-AusgabeSample makefile output

Wenn Sie make ausführen, wird ein großer Text durch Scrollen von angezeigt.When you run make, you will see a lot of text scrolling by. Wenn alles ordnungsgemäß funktioniert hat, sehen Sie, dass die Wörter Build erfolgreich sind und dass libInfColorPicker-armv7.a libInfColorPicker-i386.a libInfColorPickerSDK.a Dateien an denselben Speicherort wie das Makefilekopiert werden:If everything worked correctly, you'll see the words BUILD SUCCEEDED and the libInfColorPicker-armv7.a, libInfColorPicker-i386.a and libInfColorPickerSDK.a files will be copied to the same location as the Makefile:

Die vom Makefile generierten Dateien libinf ColorPicker-armv7. a, libinf ColorPicker-i386. a und libinf colorpickersdk. aThe libInfColorPicker-armv7.a, libInfColorPicker-i386.a and libInfColorPickerSDK.a files generated by the Makefile

Mit dem folgenden Befehl können Sie die Architekturen in der FAT-Binärdatei bestätigen:You can confirm the architectures within your Fat binary by using the following command:

xcrun -sdk iphoneos lipo -info libInfColorPicker.a

Folgendes sollte angezeigt werden:This should display the following:

Architectures in the fat file: libInfColorPicker.a are: i386 armv7 x86_64 arm64

An diesem Punkt haben wir den ersten Schritt der IOS-Bindung abgeschlossen, indem wir mithilfe von Xcode und den Xcode-Befehlszeilen Tools und eine statische Bibliothek erstellt haben make lipo .At this point, we've completed the first step of our iOS binding by creating a static library using Xcode and the Xcode Command Line tools make and lipo. Fahren Sie mit dem nächsten Schritt fort, und verwenden Sie "Target -Sharpie ", um die Erstellung der API-Bindungen für uns zu automatisieren.Let's move to the next step and use Objective-Sharpie to automate the creation of the API bindings for us.

Erstellen eines xamarin. IOS-Bindungs ProjektsCreate a Xamarin.iOS Binding Project

Bevor wir "Target -Sharpie " verwenden können, um den Bindungsprozess zu automatisieren, müssen wir ein xamarin. IOS-Bindungs Projekt erstellen, um die API-Definitionen zu beherbergen (die wir mit "Target -Sharpie " verwenden, um uns bei der Erstellung zu unterstützen) und die c#-Bindung für uns erstellen.Before we can use Objective-Sharpie to automate the binding process, we need to create a Xamarin.iOS Binding Project to house the API Definitions (that we'll be using Objective-Sharpie to help us build) and create the C# binding for us.

Führen Sie die folgenden Schritte aus:Let's do the following:

  1. Starten Sie Visual Studio für Mac.Start Visual Studio for Mac.

  2. Wählen Sie im Menü Datei die Option neueProjekt Mappe > ... aus:From the File menu, select New > Solution...:

    Starten einer neuen Projekt Mappe

  3. Wählen Sie im Dialogfeld neue Projekt Mappe die Option Bibliothek > IOS-Bindungs Projekt:From the New Solution dialog box, select Library > iOS Binding Project:

    IOS-Bindungs Projekt auswählen

  4. Klicken Sie auf die Schaltfläche Weiter.Click the Next button.

  5. Geben Sie "infcolorpickerbinding" als Projektnamen ein, und klicken Sie auf die Schaltfläche Erstellen , um die Projekt Mappe zu erstellen:Enter "InfColorPickerBinding" as the Project Name and click the Create button to create the solution:

    Geben Sie infcolorpickerbinding als Projektnamen ein.

Die Projekt Mappe wird erstellt, und es werden zwei Standard Dateien eingeschlossen:The solution will be created and two default files will be included:

Die Lösungs Struktur im Projektmappen-Explorer

  • ApiDefinition.cs : Diese Datei enthält die Verträge, die definieren, wie die Ziel-C-API in c# umschließt wird.ApiDefinition.cs - This file will contain the contracts that define how Objective-C API's will be wrapped in C#.
  • Structs.cs : Diese Datei enthält alle Strukturen oder Enumerationswerte, die von den Schnittstellen und Delegaten benötigt werden.Structs.cs - This file will hold any structures or enumeration values that are required by the interfaces and delegates.

Wir arbeiten mit diesen beiden Dateien später in der exemplarischen Vorgehensweise.We'll be working with these two files later in the walkthrough. Zuerst müssen wir die infcolorpicker-Bibliothek zum Bindungs Projekt hinzufügen.First, we need to add the InfColorPicker library to the binding project.

Einschließen der statischen Bibliothek in das Bindungs ProjektIncluding the Static Library in the Binding Project

Wir haben jetzt das Basis Bindungs Projekt vorbereitet, und wir müssen die zuvor erstellte FAT-Datei für die-Bibliothek der infcolorpicker -Bibliothek hinzufügen.Now we have our base Binding Project ready, we need to add the Fat Binary library we created above for the InfColorPicker library.

Gehen Sie folgendermaßen vor, um die Bibliothek hinzuzufügen:Follow these steps to add the library:

  1. Klicken Sie im Lösungspad mit der rechten Maustaste auf den Ordner native References , und wählen Sie native Verweise hinzufügenaus:Right-click on the Native References folder in the Solution Pad and select Add Native References:

    Native Verweise hinzufügen

  2. Navigieren Sie zur FAT-Binärdatei, die wir zuvor erstellt haben ( libInfColorPickerSDK.a ), und drücken Sie die Schaltfläche ÖffnenNavigate to the Fat Binary we made earlier (libInfColorPickerSDK.a) and press the Open button:

    Wählen Sie die Datei "libinf colorpickersdk. a" aus.

  3. Die Datei wird in das Projekt eingeschlossen:The file will be included in the project:

    Einschließen einer Datei

Wenn die Datei " . a " dem Projekt hinzugefügt wird, legt xamarin. IOS automatisch den Buildvorgang der Datei auf objcbindingnativelibraryfest und erstellt eine spezielle Datei mit dem Namen libInfColorPickerSDK.linkwith.cs .When the .a file is added to the project, Xamarin.iOS will automatically set the Build Action of the file to ObjcBindingNativeLibrary, and create a special file called libInfColorPickerSDK.linkwith.cs.

Diese Datei enthält das LinkWith Attribut, das xamarin. IOS anweist, wie die soeben hinzugefügte statische Bibliothek behandelt werden soll.This file contains the LinkWith attribute that tells Xamarin.iOS how handle the static library that we just added. Der Inhalt dieser Datei wird im folgenden Code Ausschnitt gezeigt:The contents of this file are shown in the following code snippet:

using ObjCRuntime;

[assembly: LinkWith ("libInfColorPickerSDK.a", SmartLink = true, ForceLoad = true)]

Das LinkWith -Attribut identifiziert die statische Bibliothek für das Projekt und einige wichtige Linker-Flags.The LinkWith attribute identifies the static library for the project and some important linker flags.

Als nächstes müssen wir die API-Definitionen für das infcolorpicker-Projekt erstellen.The next thing we need to do is to create the API definitions for the InfColorPicker project. Im Rahmen dieser exemplarischen Vorgehensweise verwenden wir das Ziel "Sharpie", um die Datei " ApiDefinition.cs" zu generieren.For the purposes of this walkthrough, we will use Objective Sharpie to generate the file ApiDefinition.cs.

Verwenden von Ziel-SharpieUsing Objective Sharpie

Ziel-Sharpie ist ein von xamarin bereitgestelltes Befehlszeilen Tool, das beim Erstellen der Definitionen helfen kann, die erforderlich sind, um eine Ziel-C-Bibliothek von Drittanbietern an c# zu binden.Objective Sharpie is a command line tool (provided by Xamarin) that can assist in creating the definitions required to bind a 3rd party Objective-C library to C#. In diesem Abschnitt verwenden wir den Ziel-Sharpie, um die anfängliche ApiDefinition.cs für das infcolorpicker-Projekt zu erstellen.In this section, we'll use Objective Sharpie to create the initial ApiDefinition.cs for the InfColorPicker project.

Zum Einstieg laden wir die Ziel-Sharpie-Installationsdatei herunter, wie in diesem Handbuchausführlich beschrieben.To get started, let's download Objective Sharpie installer file as detailed in this guide. Führen Sie das Installationsprogramm aus, und befolgen Sie alle Aufforderungen auf dem Bildschirm vom Installations-Assistenten, um Ziel-Sharpie auf unserem Entwicklungs Computer zu installieren.Run the installer and follow all of the onscreen prompts from the install wizard to install Objective Sharpie on our development computer.

Nachdem Sie das Ziel "Sharpie" erfolgreich installiert haben, starten Sie die Terminal-app, und geben Sie den folgenden Befehl ein, um Hilfe zu allen Tools zu erhalten, die zur Unterstützung der Bindung bereitstellt:After we have Objective Sharpie successfully installed, let's start the Terminal app and enter the following command to get help on all of the tools that it provides to assist in binding:

sharpie -help

Wenn Sie den obigen Befehl ausführen, wird die folgende Ausgabe generiert:If we execute the above command, the following output will be generated:

Europa:Resources kmullins$ sharpie -help
usage: sharpie [OPTIONS] TOOL [TOOL_OPTIONS]

Options:
  -h, --helpShow detailed help
  -v, --versionShow version information

Available Tools:
  xcode              Get information about Xcode installations and available SDKs.
  pod                Create a Xamarin C# binding to Objective-C CocoaPods
  bind               Create a Xamarin C# binding to Objective-C APIs
  update             Update to the latest release of Objective Sharpie
  verify-docs        Show cross reference documentation for [Verify] attributes
  docs               Open the Objective Sharpie online documentation

Im Rahmen dieser exemplarischen Vorgehensweise verwenden wir die folgenden Ziel-Sharpie-Tools:For the purpose of this walkthrough, we will be using the following Objective Sharpie tools:

  • Xcode : Diese Tools enthalten Informationen über unsere aktuelle Xcode-Installation und die Versionen von IOS-und Mac-APIs, die installiert wurden.xcode - This tools gives us information about our current Xcode install and the versions of iOS and Mac APIs that we have installed. Diese Informationen werden später verwendet, wenn wir unsere Bindungen generieren.We will be using this information later when we generate our bindings.
  • Bind : Wir verwenden dieses Tool, um die h -Dateien im Projekt infcolorpicker in die anfänglichen ApiDefinition.cs -und StructsAndEnums.cs -Dateien zu analysieren.bind - We'll use this tool to parse the .h files in the InfColorPicker project into the initial ApiDefinition.cs and StructsAndEnums.cs files.

Um Hilfe zu einem bestimmten Ziel-Sharpie-Tool zu erhalten, geben Sie den Namen des Tools und die -help Option ein.To get help on a specific Objective Sharpie tool, enter the name of the tool and the -help option. Beispielsweise sharpie xcode -help gibt die folgende Ausgabe zurück:For example, sharpie xcode -help returns the following output:

Europa:Resources kmullins$ sharpie xcode -help
usage: sharpie xcode [OPTIONS]+

Options:
  -h, -help           Show detailed help
  -v, -verbose        Be verbose with output

Xcode Options:
  -sdks               List all available Xcode SDKs. Pass -verbose for more
                        details.
  -sdkpath SDK        Output the path of the SDK
  -frameworks SDK     List all available framework directories in a given SDK.

Bevor wir den Bindungsprozess starten können, müssen wir Informationen zu unseren aktuell installierten sdden erhalten, indem wir den folgenden Befehl in das Terminal eingeben sharpie xcode -sdks :Before we can start the binding process, we need to get information about our current installed SDKs by entering the following command into the Terminal sharpie xcode -sdks:

amyb:Desktop amyb$ sharpie xcode -sdks
sdk: appletvos9.2    arch: arm64
sdk: iphoneos9.3     arch: arm64   armv7
sdk: macosx10.11     arch: x86_64  i386
sdk: watchos2.2      arch: armv7

Im obigen Beispiel sehen wir, dass das iphoneos9.3 SDK auf dem Computer installiert ist.From the above, we can see that we have the iphoneos9.3 SDK installed on our machine. Nachdem diese Informationen vorhanden sind, können wir die infcolorpicker .h -Projektdateien in die anfängliche ApiDefinition.cs und StructsAndEnums.cs das infcolorpicker-Projekt analysieren.With this information in place, we are ready to parse the InfColorPicker project .h files into the initial ApiDefinition.cs and StructsAndEnums.cs for the InfColorPicker project.

Geben Sie den folgenden Befehl in der Terminal-app ein:Enter the following command in the Terminal app:

sharpie bind --output=InfColorPicker --namespace=InfColorPicker --sdk=[iphone-os] -scope [full-path-to-project]/InfColorPicker/InfColorPicker [full-path-to-project]/InfColorPicker/InfColorPicker/*.h

Dabei [full-path-to-project] steht für den vollständigen Pfad zu dem Verzeichnis, in dem sich die Projektdatei " infcolorpicker " auf dem Computer befindet, und [iPhone-OS] ist das IOS SDK, das wir installiert haben, wie im sharpie xcode -sdks Befehl angegeben.Where [full-path-to-project] is the full path to the directory where the InfColorPicker Xcode project file is located on our computer, and [iphone-os] is the iOS SDK that we have installed, as noted by the sharpie xcode -sdks command. Beachten Sie, dass in diesem Beispiel ** * . h** als Parameter übergeben wurde, der alle Header Dateien in diesem Verzeichnis enthält. Dies ist normalerweise nicht der Fall, Sie sollten jedoch die Header Dateien sorgfältig durchlesen, um die h -Datei der obersten Ebene zu suchen, die auf alle anderen relevanten Dateien verweist, und Sie einfach an den Ziel-Sharpie zu übergeben.Note that in this example we've passed *.h as a parameter, which includes all the header files in this directory - normally you should NOT do this, but instead carefully read through the header files to find the top-level .h file that references all the other relevant files, and just pass that to Objective Sharpie.

Tipp

Übergeben Sie für das- -scope Argument den Ordner mit den Headern, die Sie binden möchten.For the -scope argument, pass in the folder that has the headers you want to bind. Ohne das- -scope Argument versucht Target Sharpie, Bindungen für alle importierten IOS SDK-Header zu generieren, z. b. #import <UIKit.h> , was zu einer Datei mit sehr großen Definitionen führt, die bei der Kompilierung des Bindungs Projekts wahrscheinlich Fehler generieren wird.Without the -scope argument, Objective Sharpie will try to generate bindings for any iOS SDK headers that are imported, e.g. #import <UIKit.h>, resulting in a huge definitions file that will likely generate errors when compiling the binding project. Wenn das -scope Argument festgelegt wird, generiert Target Sharpie keine Bindungen für Header außerhalb des Bereichs bezogenen Ordners.With the -scope argument set, Objective Sharpie will not generate bindings for any headers outside of the scoped folder.

Die folgende Ausgabe wird im Terminal generiert:The following output will be generated in the terminal:

Europa:Resources kmullins$ sharpie bind -output InfColorPicker -namespace InfColorPicker -sdk iphoneos8.1 /Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPicker.h -unified
Compiler configuration:
    -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk -miphoneos-version-min=8.1 -resource-dir /Library/Frameworks/ObjectiveSharpie.framework/Versions/1.1.1/clang-resources -arch armv7 -ObjC

[  0%] parsing /Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPicker.h
In file included from /Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPicker.h:60:
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:28:1: warning: no 'assign',
      'retain', or 'copy' attribute is specified - 'assign' is assumed [-Wobjc-property-no-attribute]
@property (nonatomic) UIColor* sourceColor;
^
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:28:1: warning: default property
      attribute 'assign' not appropriate for non-GC object [-Wobjc-property-no-attribute]
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:29:1: warning: no 'assign',
      'retain', or 'copy' attribute is specified - 'assign' is assumed [-Wobjc-property-no-attribute]
@property (nonatomic) UIColor* resultColor;
^
/Users/kmullins/Projects/InfColorPicker/InfColorPicker/InfColorPickerController.h:29:1: warning: default property
      attribute 'assign' not appropriate for non-GC object [-Wobjc-property-no-attribute]
4 warnings generated.
[100%] parsing complete
[bind] InfColorPicker.cs
Europa:Resources kmullins$

Und die InfColorPicker.enums.cs -und InfColorPicker.cs -Dateien werden in unserem Verzeichnis erstellt:And the InfColorPicker.enums.cs and InfColorPicker.cs files will be created in our directory:

Die Dateien InfColorPicker.enums.cs und InfColorPicker.csThe InfColorPicker.enums.cs and InfColorPicker.cs files

Öffnen Sie beide Dateien im Bindungs Projekt, das wir oben erstellt haben.Open both of these files in the Binding project that we created above. Kopieren Sie den Inhalt der Datei InfColorPicker.cs , und fügen Sie ihn in die Datei ApiDefinition.cs ein. ersetzen Sie dabei den vorhandenen namespace ... Codeblock durch den Inhalt der InfColorPicker.cs -Datei (sodass die using Anweisungen intakt bleiben):Copy the contents of the InfColorPicker.cs file and paste it into the ApiDefinition.cs file, replacing the existing namespace ... code block with the contents of the InfColorPicker.cs file (leaving the using statements intact):

Die infcolorpickercontrollerdelegatdatei

Normalisieren der API-DefinitionenNormalize the API Definitions

Bei Ziel-Sharpie tritt mitunter ein Problem Delegates auf. Daher müssen wir die Definition der InfColorPickerControllerDelegate Schnittstelle ändern und die [Protocol, Model] Zeile durch Folgendes ersetzen:Objective Sharpie sometimes has an issue translating Delegates, so we will need to modify the definition of the InfColorPickerControllerDelegate interface and replace the [Protocol, Model] line with the following:

[BaseType(typeof(NSObject))]
[Model]

So sieht die Definition wie folgt aus:So that the definition looks like:

Die DefinitionThe definition

Als nächstes führen wir das gleiche mit dem Inhalt der Datei aus InfColorPicker.enums.cs , kopieren und Einfügen in die StructsAndEnums.cs Datei, sodass die using Anweisungen intakt bleiben:Next, we do the same thing with the contents of the InfColorPicker.enums.cs file, copying and pasting them in the StructsAndEnums.cs file leaving the using statements intact:

Der Inhalt der Datei "StructsAndEnums.cs".The contents the StructsAndEnums.cs file

Sie können auch feststellen, dass der Ziel-Sharpie die Bindung mit [Verify] Attributen versehen hat.You may also find that Objective Sharpie has annotated the binding with [Verify] attributes. Diese Attribute geben an, dass Sie sicherstellen sollten, dass Ziel-Sharpie das richtige ist, indem Sie die Bindung mit der ursprünglichen c/Ziel-c-Deklaration vergleichen (die in einem Kommentar oberhalb der gebundenen Deklaration bereitgestellt wird).These attributes indicate that you should verify that Objective Sharpie did the correct thing by comparing the binding with the original C/Objective-C declaration (which will be provided in a comment above the bound declaration). Nachdem Sie die Bindungen überprüft haben, sollten Sie das Verify-Attribut entfernen.Once you have verified the bindings, you should remove the verify attribute. Weitere Informationen finden Sie im Leitfaden zur Überprüfung .For more information, refer to the Verify guide.

An diesem Punkt sollte das Bindungs Projekt abgeschlossen und bereit für die Erstellung sein.At this point, our binding project should be complete and ready to build. Erstellen wir nun das Bindungs Projekt, und stellen Sie sicher, dass keine Fehler aufgetreten sind:Let's build our binding project and make sure that we ended up with no errors:

Erstellen Sie das Bindungs Projekt, und stellen Sie sicher, dass keine Fehler vorliegen.Build the binding project and make sure there are no errors

Verwenden der BindungUsing the Binding

Gehen Sie folgendermaßen vor, um eine Beispiel-iPhone-Anwendung zur Verwendung der oben erstellten IOS-Bindungs Bibliothek zu erstellen:Follow these steps to create a sample iPhone application to use the iOS Binding Library created above:

  1. Erstellen eines xamarin. IOS-Projekts : Fügen Sie der Projekt Mappe ein neues xamarin. IOS-Projekt mit dem Namen " infcolorpickersample " hinzu, wie in den folgenden Screenshots gezeigt:Create Xamarin.iOS Project - Add a new Xamarin.iOS project called InfColorPickerSample to the solution, as shown in the following screenshots:

    Hinzufügen einer einzelnen Ansichts-App

    Festlegen des Bezeichners

  2. Fügen Sie dem Bindungs Projekt einen Verweis hinzu : Aktualisieren Sie das Projekt infcolorpickersample , sodass es einen Verweis auf das Projekt infcolorpickerbinding hat:Add Reference to the Binding Project - Update the InfColorPickerSample project so that it has a reference to the InfColorPickerBinding project:

    Hinzufügen eines Verweises auf das Bindungs Projekt

  3. Erstellen der iPhone-Benutzeroberfläche : Doppelklicken Sie auf die Datei " mainstoryboard. Storyboard " im Projekt " infcolorpickersample ", um Sie im IOS-Designer zu bearbeiten.Create the iPhone User Interface - Double click on the MainStoryboard.storyboard file in the InfColorPickerSample project to edit it in the iOS Designer. Fügen Sie der Ansicht eine Schaltfläche hinzu, und nennen Sie Sie ChangeColorButton , wie im folgenden dargestellt:Add a Button to the view and call it ChangeColorButton, as shown in the following:

    Hinzufügen einer Schaltfläche zur Ansicht

  4. Fügen Sie infcolorpickerview. XIb hinzu : die infcolorpicker-Ziel-C-Bibliothek enthält eine XIb -Datei.Add the InfColorPickerView.xib - The InfColorPicker Objective-C library includes a .xib file. Xamarin. IOS schließt this . XIb nicht in das Bindungs Projekt ein, was zu Laufzeitfehlern in der Beispielanwendung führt.Xamarin.iOS will not include this .xib in the binding project, which will cause run-time errors in our sample application. Um dieses Problem zu umgehen, fügen Sie dem xamarin. IOS-Projekt die XIb -Datei hinzu.The workaround for this is to add the .xib file to our Xamarin.iOS project. Wählen Sie das xamarin. IOS-Projekt aus, klicken Sie mit der rechten Maustaste, und wählen Sie Hinzufügen > Dateienhinzufügen aus. Fügen Sie die XIb -Datei wie im folgenden Screenshot gezeigt hinzu:Select the Xamarin.iOS project, right-click and select Add > Add Files, and add the .xib file as shown in the following screenshot:

    Fügen Sie infcolorpickerview. XIb hinzu.

  5. Wenn Sie gefragt werden, kopieren Sie die XIb -Datei in das Projekt.When asked, copy the .xib file into the project.

Im nächsten Schritt betrachten wir die Protokolle in "Ziel-C" und deren Behandlung in Bindungs-und c#-Code.Next, let's take a quick look at Protocols in Objective-C and how we handle them in binding and C# code.

Protokolle und xamarin. IOSProtocols and Xamarin.iOS

In Ziel-C definiert ein Protokoll Methoden (oder Meldungen), die unter bestimmten Umständen verwendet werden können.In Objective-C, a protocol defines methods (or messages) that can be used in certain circumstances. Konzeptionell ähneln Sie den Schnittstellen in c#.Conceptually, they are very similar to interfaces in C#. Ein wichtiger Unterschied zwischen einem Ziel-C-Protokoll und einer c#-Schnittstelle besteht darin, dass Protokolle optionale Methoden aufweisen können, die von einer Klasse nicht implementiert werden müssen.One major difference between an Objective-C protocol and a C# interface is that protocols can have optional methods - methods that a class does not have to implement. Ziel-C verwendet das- @optional Schlüsselwort, um anzugeben, welche Methoden optional sind.Objective-C uses the @optional keyword is used to indicate which methods are optional. Weitere Informationen zu Protokollen finden Sie unter Ereignisse, Protokolle undDelegaten.For more information on protocols see Events, Protocols and Delegates.

Infcolorpickercontroller verfügt über ein solches Protokoll, wie im folgenden Code Ausschnitt gezeigt:InfColorPickerController has one such protocol, shown in the code snippet below:

@protocol InfColorPickerControllerDelegate

@optional

- (void) colorPickerControllerDidFinish: (InfColorPickerController*) controller;
// This is only called when the color picker is presented modally.

- (void) colorPickerControllerDidChangeColor: (InfColorPickerController*) controller;

@end

Dieses Protokoll wird von infcolorpickercontroller verwendet, um Clients darüber zu informieren, dass der Benutzer eine neue Farbe ausgewählt hat und dass infcolorpickercontroller fertiggestellt ist.This protocol is used by InfColorPickerController to inform clients that the user has picked a new color and that the InfColorPickerController is finished. Ziel-Sharpie hat dieses Protokoll zugeordnet, wie im folgenden Code Ausschnitt gezeigt:Objective Sharpie mapped this protocol as shown in the following code snippet:

[BaseType(typeof(NSObject))]
[Model]
public partial interface InfColorPickerControllerDelegate {

    [Export ("colorPickerControllerDidFinish:")]
    void ColorPickerControllerDidFinish (InfColorPickerController controller);

    [Export ("colorPickerControllerDidChangeColor:")]
    void ColorPickerControllerDidChangeColor (InfColorPickerController controller);
}

Wenn die Bindungs Bibliothek kompiliert wird, erstellt xamarin. IOS eine abstrakte Basisklasse InfColorPickerControllerDelegate mit dem Namen, die diese Schnittstelle mit virtuellen Methoden implementiert.When the binding library is compiled, Xamarin.iOS will create an abstract base class called InfColorPickerControllerDelegate, which implements this interface with virtual methods.

Es gibt zwei Möglichkeiten, wie Sie diese Schnittstelle in einer xamarin. IOS-Anwendung implementieren können:There are two ways that we can implement this interface in a Xamarin.iOS application:

  • Starker Delegat: die Verwendung eines starken Delegaten umfasst das Erstellen einer c#-Klasse, die InfColorPickerControllerDelegate die entsprechenden Methoden Unterklassen und überschreibt.Strong Delegate - Using a strong delegate involves creating a C# class that subclasses InfColorPickerControllerDelegate and overrides the appropriate methods. Infcolorpickercontroller verwendet eine Instanz dieser Klasse, um mit den Clients zu kommunizieren.InfColorPickerController will use an instance of this class to communicate with its clients.
  • Schwacher Delegat: bei einem schwachen Delegaten handelt es sich um eine etwas andere Technik, die das Erstellen einer öffentlichen Methode für eine Klasse (z. b.) und das anschließende verfügbar machen InfColorPickerSampleViewController dieser Methode für das InfColorPickerDelegate Protokoll über ein Export Attribut umfasstWeak Delegate - A weak delegate is a slightly different technique that involves creating a public method on some class (such as InfColorPickerSampleViewController) and then exposing that method to the InfColorPickerDelegate protocol via an Export attribute.

Starke Delegaten bieten IntelliSense, Typsicherheit und eine bessere Kapselung.Strong delegates provide Intellisense, type safety, and better encapsulation. Aus diesen Gründen sollten Sie anstelle eines schwachen Delegaten starke Delegaten verwenden.For these reasons, you should use strong delegates where you can, instead of a weak delegate.

In dieser exemplarischen Vorgehensweise werden beide Verfahren erläutert: zuerst wird ein starker Delegat implementiert, und anschließend wird erläutert, wie ein schwacher Delegat implementiert wird.In this walkthrough we will discuss both techniques: first implementing a strong delegate, and then explaining how to implement a weak delegate.

Implementieren eines starken DelegatenImplementing a Strong Delegate

Beenden Sie die xamarin. IOS-Anwendung, indem Sie einen starken Delegaten verwenden, um auf die Meldung zu reagieren colorPickerControllerDidFinish: :Finish the Xamarin.iOS application by using a strong delegate to respond to the colorPickerControllerDidFinish: message:

Subclass infcolorpickercontrollerdelegat -fügt dem Projekt eine neue Klasse mit dem Namen hinzu ColorSelectedDelegate .Subclass InfColorPickerControllerDelegate - Add a new class to the project called ColorSelectedDelegate. Bearbeiten Sie die-Klasse, sodass Sie den folgenden Code enthält:Edit the class so that it has the following code:

using InfColorPickerBinding;
using UIKit;

namespace InfColorPickerSample
{
  public class ColorSelectedDelegate:InfColorPickerControllerDelegate
  {
    readonly UIViewController parent;

    public ColorSelectedDelegate (UIViewController parent)
    {
      this.parent = parent;
    }

    public override void ColorPickerControllerDidFinish (InfColorPickerController controller)
    {
      parent.View.BackgroundColor = controller.ResultColor;
      parent.DismissViewController (false, null);
    }
  }
}

Xamarin. IOS bindet den Ziel-C-Delegaten, indem eine abstrakte Basisklasse mit dem Namen erstellt wird InfColorPickerControllerDelegate .Xamarin.iOS will bind the Objective-C delegate by creating an abstract base class called InfColorPickerControllerDelegate. Unterklasse dieses Typs, und überschreiben Sie die- ColorPickerControllerDidFinish Methode, um auf den Wert der- ResultColor Eigenschaft von zuzugreifen InfColorPickerController .Subclass this type and override the ColorPickerControllerDidFinish method to access the value of the ResultColor property of InfColorPickerController.

Erstellen einer Instanz von colorselecteddelegat : für den Ereignishandler wird eine Instanz des ColorSelectedDelegate Typs benötigt, den wir im vorherigen Schritt erstellt haben.Create a instance of ColorSelectedDelegate - Our event handler will need an instance of the ColorSelectedDelegate type that we created in the previous step. Bearbeiten Sie die InfColorPickerSampleViewController -Klasse, und fügen Sie der-Klasse die folgende Instanzvariable hinzu:Edit the class InfColorPickerSampleViewController and add the following instance variable to the class:

ColorSelectedDelegate selector;

Initialisieren Sie die colorselecteddelegatvariable . um sicherzustellen, dass selector eine gültige-Instanz ist, aktualisieren Sie die-Methode ViewDidLoad in, ViewController um dem folgenden Code Ausschnitt zu entsprechen:Initialize the ColorSelectedDelegate variable - To ensure that selector is a valid instance, update the method ViewDidLoad in ViewController to match the following snippet:

public override void ViewDidLoad ()
{
  base.ViewDidLoad ();
  ChangeColorButton.TouchUpInside += HandleTouchUpInsideWithStrongDelegate;
  selector = new ColorSelectedDelegate (this);
}

Implementieren Sie die Methode "shandtouchupinsidewithstrongdelegat -Next implementieren Sie den Ereignishandler für", wenn der Benutzer colorchangebuttonberührt.Implement the method HandleTouchUpInsideWithStrongDelegate - Next implement the event handler for when the user touches ColorChangeButton. Bearbeiten ViewController Sie, und fügen Sie die folgende Methode hinzu:Edit ViewController, and add the following method:

using InfColorPicker;
...

private void HandleTouchUpInsideWithStrongDelegate (object sender, EventArgs e)
{
    InfColorPickerController picker = InfColorPickerController.ColorPickerViewController();
    picker.Delegate = selector;
    picker.PresentModallyOverViewController (this);
}

Zuerst wird eine Instanz von InfColorPickerController über eine statische Methode abgerufen, und diese Instanz wird über die-Eigenschaft auf unseren starken Delegaten aufmerksam gemacht InfColorPickerController.Delegate .We first obtain an instance of InfColorPickerController via a static method, and make that instance aware of our strong delegate via the property InfColorPickerController.Delegate. Diese Eigenschaft wurde von Ziel-Sharpie automatisch für uns generiert.This property was automatically generated for us by Objective Sharpie. Schließlich wird aufgerufen PresentModallyOverViewController , um die Ansicht anzuzeigen InfColorPickerSampleViewController.xib , sodass der Benutzer eine Farbe auswählen kann.Finally we call PresentModallyOverViewController to show the view InfColorPickerSampleViewController.xib so that the user may select a color.

Ausführen der Anwendung : an dieser Stelle wird der gesamte Code ausgeführt.Run the Application - At this point we're done with all of our code. Wenn Sie die Anwendung ausführen, sollten Sie in der Lage sein, die Hintergrundfarbe der zu ändern, InfColorColorPickerSampleView wie in den folgenden Screenshots gezeigt:If you run the application, you should be able to change the background color of the InfColorColorPickerSampleView as shown in the following screenshots:

Ausführen der AnwendungRunning the Application

Herzlichen Glückwunsch!Congratulations! An diesem Punkt haben Sie eine Ziel-C-Bibliothek erfolgreich erstellt und für die Verwendung in einer xamarin. IOS-Anwendung gebunden.At this point you've successfully created and bound an Objective-C library for use in a Xamarin.iOS application. Als Nächstes erfahren Sie mehr über die Verwendung von schwachen Delegaten.Next, let's learn about using weak delegates.

Implementieren eines schwachen DelegatenImplementing a Weak Delegate

Anstatt eine Klasse zu Unterklassen, die an das Ziel-C-Protokoll für einen bestimmten Delegaten gebunden ist, können Sie mit xamarin. IOS auch die Protokoll Methoden in jeder Klasse implementieren, die von abgeleitet NSObject ist, die Methoden mit dem versehen ExportAttribute und dann die entsprechenden Selektoren bereitstellen.Instead of subclassing a class bound to the Objective-C protocol for a particular delegate, Xamarin.iOS also lets you implement the protocol methods in any class that derives from NSObject, decorating your methods with the ExportAttribute, and then supplying the appropriate selectors. Wenn Sie diesen Ansatz verwenden, weisen Sie der-Eigenschaft anstelle der-Eigenschaft eine Instanz der-Klasse zu WeakDelegate Delegate .When you take this approach, you assign an instance of your class to the WeakDelegate property instead of to the Delegate property. Ein schwacher Delegat bietet Ihnen die Flexibilität, ihre Delegatklasse in eine andere Vererbungs Hierarchie zu bringen.A weak delegate offers you the flexibility to take your delegate class down a different inheritance hierarchy. Sehen wir uns an, wie Sie einen schwachen Delegaten in unserer xamarin. IOS-Anwendung implementieren und verwenden.Let’s see how to implement and use a weak delegate in our Xamarin.iOS application.

Create Event Handler for touchupinside : Erstellen Sie einen neuen Ereignishandler für das- TouchUpInside Ereignis der Schaltfläche Hintergrundfarbe ändern.Create Event Handler for TouchUpInside - Let's create a new event handler for the TouchUpInside event of the Change Background Color button. Dieser Handler nimmt dieselbe Rolle wie der Handler, den HandleTouchUpInsideWithStrongDelegate wir im vorherigen Abschnitt erstellt haben, verwendet aber einen schwachen Delegaten anstelle eines starken Delegaten.This handler will fill the same role as the HandleTouchUpInsideWithStrongDelegate handler that we created in the previous section, but will use a weak delegate instead of a strong delegate. Bearbeiten Sie die ViewController -Klasse, und fügen Sie die folgende Methode hinzu:Edit the class ViewController, and add the following method:

private void HandleTouchUpInsideWithWeakDelegate (object sender, EventArgs e)
{
    InfColorPickerController picker = InfColorPickerController.ColorPickerViewController();
    picker.WeakDelegate = this;
    picker.SourceColor = this.View.BackgroundColor;
    picker.PresentModallyOverViewController (this);
}

ViewDidLoad aktualisieren : Wir müssen ändern ViewDidLoad , damit der soeben erstellte Ereignishandler verwendet wird.Update ViewDidLoad - We must change ViewDidLoad so that it uses the event handler that we just created. Bearbeiten ViewController und ändern ViewDidLoad Sie den folgenden Code Ausschnitt:Edit ViewController and change ViewDidLoad to resemble the following code snippet:

public override void ViewDidLoad ()
{
    base.ViewDidLoad ();
    ChangeColorButton.TouchUpInside += HandleTouchUpInsideWithWeakDelegate;
}

Behandeln von colorpickercontrollerdidfinish: Message: wenn der ViewController abgeschlossen ist, sendet IOS die Nachricht colorPickerControllerDidFinish: an die WeakDelegate .Handle the colorPickerControllerDidFinish: Message - When the ViewController is finished, iOS will send the message colorPickerControllerDidFinish: to the WeakDelegate. Wir müssen eine c#-Methode erstellen, die diese Nachricht verarbeiten kann.We need to create a C# method that can handle this message. Zu diesem Zweck erstellen wir eine c#-Methode und schmücken Sie dann mit dem ExportAttribute .To do this, we create a C# method and then adorn it with the ExportAttribute. Bearbeiten ViewController Sie, und fügen Sie der-Klasse die folgende Methode hinzu:Edit ViewController, and add the following method to the class:

[Export("colorPickerControllerDidFinish:")]
public void ColorPickerControllerDidFinish (InfColorPickerController controller)
{
    View.BackgroundColor = controller.ResultColor;
    DismissViewController (false, null);
}

Führen Sie die Anwendung aus.Run the application. Es sollte sich nun genau wie zuvor Verhalten, aber es verwendet einen schwachen Delegaten anstelle des starken Delegaten.It should now behave exactly as it did before, but it's using a weak delegate instead of the strong delegate. An diesem Punkt haben Sie diese exemplarische Vorgehensweise erfolgreich abgeschlossen.At this point you've successfully completed this walkthrough. Sie sollten nun wissen, wie ein xamarin. IOS-Bindungs Projekt erstellt und genutzt werden kann.You should now have an understanding of how to create and consume a Xamarin.iOS binding project.

ZusammenfassungSummary

In diesem Artikel wurde das Erstellen und Verwenden eines xamarin. IOS-Bindungs Projekts erläutert.This article walked through the process of creating and using a Xamarin.iOS binding project. Zuerst wurde erläutert, wie eine vorhandene Ziel-C-Bibliothek in eine statische Bibliothek kompiliert wird.First we discussed how to compile an existing Objective-C library into a static library. Anschließend haben wir erläutert, wie Sie ein xamarin. IOS-Bindungs Projekt erstellen und die API-Definitionen für die Ziel-C-Bibliothek mit dem Ziel-Sharpie generieren.Then we covered how to create a Xamarin.iOS binding project, and how to use Objective Sharpie to generate the API definitions for the Objective-C library. Wir haben erläutert, wie Sie die generierten API-Definitionen aktualisieren und optimieren, damit Sie für den öffentlichen Gebrauch geeignet sind.We discussed how to update and tweak the generated API definitions to make them suitable for public consumption. Nachdem das xamarin. IOS-Bindungs Projekt fertiggestellt wurde, haben wir mit der Verwendung dieser Bindung in einer xamarin. IOS-Anwendung weiterentwickelt, wobei der Schwerpunkt auf der Verwendung starker Delegaten und schwacher Delegaten liegt.After the Xamarin.iOS binding project was finished, we moved on to consuming that binding in a Xamarin.iOS application, with a focus on using strong delegates and weak delegates.