Tutorial: enlace de una biblioteca de Objective-C a iOSWalkthrough: Binding an iOS Objective-C Library

En este artículo se proporciona un tutorial práctico de creación de un enlace de Xamarin.iOS para una biblioteca existente de Objective-C, InfColorPicker. Trata temas como compilar una biblioteca estática de Objective-C, enlace y utilizar el enlace en una aplicación de Xamarin.iOS.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.

Cuando se trabaja en iOS, pueden producirse los casos donde desee utilizar una biblioteca de Objective-C de terceros.When working on iOS, you might encounter cases where you want to consume a third-party Objective-C library. En estos casos, puede usar un Xamarin.iOS enlace proyecto para crear un C# enlace que le permitirá utilizar la biblioteca en las aplicaciones de Xamarin.iOS.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.

Por lo general en el ecosistema de iOS puede encontrar las bibliotecas de 3 modos:Generally in the iOS ecosystem you can find libraries in 3 flavors:

  • Como un archivo de biblioteca estática precompilado con .a extensión junto con sus encabezados (archivos. h).As a precompiled static library file with .a extension together with its header(s) (.h files). Por ejemplo, Analytics biblioteca de GoogleFor example, Google’s Analytics Library
  • Como un marco de trabajo precompilado.As a precompiled Framework. Esto es simplemente una carpeta que contiene la biblioteca estática, encabezados y recursos adicionales a veces con .framework extensión.This is just a folder containing the static library, headers and sometimes additional resources with .framework extension. Por ejemplo, biblioteca AdMob de Google.For example, Google’s AdMob Library.
  • Como archivos de código fuente.As just source code files. Por ejemplo, una biblioteca que contiene solo .m y .h Objective C archivos.For example, a library containing just .m and .h Objective C files.

En el primer y segundo escenario ya habrá una biblioteca estática de CocoaTouch precompilado así que en este artículo nos centraremos en el tercer escenario.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. Recuerde que, antes de empezar a crear un enlace, compruebe siempre el certificado proporcionado con la biblioteca para asegurarse de que esté libre para enlazarlo.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.

Este artículo proporciona un tutorial paso a paso de creación de un proyecto de enlace con el código abierto InfColorPicker proyecto Objective-C como por ejemplo, sin embargo, toda la información de esta guía se puede adaptar para su uso con cualquier biblioteca de Objective-C de terceros.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. La biblioteca de InfColorPicker proporciona un controlador de vista reutilizable que permite al usuario seleccionar un color basado en su representación HSB, lo más fácil de usar la selección de color.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.

Hablaremos sobre todos los pasos necesarios para consumir esta API concreta de Objective-C en Xamarin.iOS:We'll cover all the necessary steps to consume this particular Objective-C API in Xamarin.iOS:

  • En primer lugar, vamos a crear una biblioteca estática de Objective-C con Xcode.First, we'll create an Objective-C static library using Xcode.
  • A continuación, enlazamos la esta biblioteca estática con Xamarin.iOS.Then, we'll bind this static library with Xamarin.iOS.
  • A continuación, se muestra cómo Sharpie objetivo puede reducir la carga de trabajo mediante la generación automática de algunos (pero no todos) de las definiciones de API necesarias requeridas por el enlace de Xamarin.iOS.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.
  • Por último, vamos a crear una aplicación de Xamarin.iOS que usa el enlace.Finally, we'll create a Xamarin.iOS application that uses the binding.

La aplicación de ejemplo demuestra cómo utilizar un delegado seguro para la comunicación entre la API InfColorPicker y nuestro C# código.The sample application will demonstrate how to use a strong delegate for communication between the InfColorPicker API and our C# code. Una vez que hemos visto cómo usar a un delegado seguro, hablaremos sobre cómo usar a delegados débiles para realizar las mismas tareas.After we've seen how to use a strong delegate, we'll cover how to use weak delegates to perform the same tasks.

RequisitosRequirements

En este artículo se da por supuesto que tiene cierta familiaridad con Xcode y el lenguaje de Objective-C y que haya leído nuestro Binding Objective-C documentación.This article assumes that you have some familiarity with Xcode and the Objective-C language and you have read our Binding Objective-C documentation. Además, es necesario lo siguiente para completar los pasos que aparecen:Additionally, the following is required to complete the steps presented:

  • Xcode y el SDK de iOS -Xcode de Apple y la API de iOS más reciente debe estar instalado y configurado en el equipo del desarrollador.Xcode and iOS SDK - Apple's Xcode and the latest iOS API need to be installed and configured on the developer's computer.
  • Herramientas de línea de comandos de Xcode -las herramientas de línea de comandos de Xcode debe estar instaladas para la versión actualmente instalada de Xcode (vea los detalles de la instalación a continuación).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 para Mac o Visual Studio -la versión más reciente de Visual Studio para Mac o Visual Studio debe estar instalada y configurada en el equipo de desarrollo.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. Un Mac de Apple es necesario para desarrollar una aplicación de Xamarin.iOS, y cuando se usa Visual Studio debe estar conectado a host de compilación de una de Xamarin.iOSAn 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
  • La versión más reciente de objetivo Sharpie -descarga una copia actual de la herramienta Sharpie objetivo de aquí.The latest version of Objective Sharpie - A current copy of the Objective Sharpie tool downloaded from here. Si ya tiene Sharpie objetivo instalado, puede actualizar a la versión más reciente mediante el sharpie updateIf you already have Objective Sharpie installed, you can update it to the latest version by using the sharpie update

Instalar las herramientas de línea de comandos de XcodeInstalling the Xcode Command Line Tools

Como se indicó anteriormente, vamos a usar las herramientas de línea de comandos de Xcode (específicamente make y lipo) en este tutorial.As stated above, we'll be using Xcode Command Line Tools (specifically make and lipo) in this walkthrough. El make comando es una utilidad muy común de Unix que automatizará la compilación de programas ejecutables y bibliotecas mediante el uso de un archivos MAKE que especifica cómo se debe compilar el programa.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. El lipo comando es una utilidad de línea de comandos de OS X para crear la arquitectura de varios archivos; combinará varios .a archivos en un archivo que se puede utilizar todas las arquitecturas de hardware.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.

Según de Apple compilar desde la línea de comandos con las preguntas más frecuentes de Xcode documentación en OS X 10.9 y versiones posteriores, el descargas panel de Xcode preferencias cuadro de diálogo no ya es compatible con las herramientas de línea de comandos de descarga.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.

Necesita usar uno de los métodos siguientes para instalar las herramientas:You'll need to use one of the following methods to install the tools:

  • Instalar Xcode : al instalar Xcode, está equipado con todas sus herramientas de línea de comandos.Install Xcode - When you install Xcode, it comes bundled with all your command-line tools. En OS X 10.9 las correcciones de compatibilidad (instalado en /usr/bin), puede asignar cualquier herramienta que se incluye en /usr/bin a la herramienta correspondiente dentro de Xcode.In OS X 10.9 shims (installed in /usr/bin), can map any tool included in /usr/bin to the corresponding tool inside Xcode. Por ejemplo, el xcrun comando, que le permite buscar o ejecute cualquier herramienta dentro de Xcode desde la línea de comandos.For example, the xcrun command, which allows you to find or run any tool inside Xcode from the command line.

  • La aplicación Terminal -desde la aplicación Terminal, puede instalar las herramientas de línea de comandos ejecutando el xcode-select --install comando:The Terminal Application - From the Terminal application, you can install the command line tools by running the xcode-select --install command:

    • Inicie la aplicación Terminal.Start the Terminal Application.
    • Tipo xcode-select --install y presione ENTRAR, por ejemplo:Type xcode-select --install and press Enter, for example:
    Europa:~ kmullins$ xcode-select --install
    
    • Le pedirá que instale las herramientas de línea de comandos, haga clic en el instalar botón: You'll be asked to install the command line tools, click the Install button:

    • Las herramientas se descargará y se instala desde servidores de Apple: The tools will be downloaded and installed from Apple's servers:

  • Descargas para desarrolladores de Apple -paquete de las herramientas de línea de comandos está disponible el descargas para desarrolladores de Apple página web.Downloads for Apple Developers - The Command Line Tools package is available the Downloads for Apple Developers web page. Inicie sesión con su identificador de Apple, a continuación, buscar y descargar las herramientas de línea de comandos: Log in with your Apple ID, then search for and download the Command Line Tools:

Con las herramientas de línea de comandos instaladas, estamos listos continuar con el tutorial.With the Command Line Tools installed, we're ready to continue on with the walkthrough.

TutorialWalkthrough

En este tutorial, describiremos los pasos siguientes:In this walkthrough, we'll cover the following steps:

  • Crear una biblioteca estática : este paso implica la creación de una biblioteca estática de la InfColorPicker código Objective-C.Create a Static Library - This step involves creating a static library of the InfColorPicker Objective-C code. La biblioteca estática tendrá el .a la extensión de archivo y se incrustarán en el ensamblado de .NET del proyecto de biblioteca.The static library will have the .a file extension, and will be embedded into the .NET assembly of the library project.
  • Crear un proyecto de enlace de Xamarin.iOS -una vez que tenemos una biblioteca estática, se usará para crear un proyecto de enlace de Xamarin.iOS.Create a Xamarin.iOS Binding Project - Once we have a static library, we will use it to create a Xamarin.iOS binding project. El proyecto de enlace consta de la biblioteca estática que acabamos de crear y los metadatos en forma de C# código que se explica cómo se puede usar la API de C de objetivo.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. Estos metadatos se conocen normalmente como las definiciones de API.This metadata is commonly referred to as the API definitions. Vamos a usar objetivo Sharpie que nos ayudan a crear las definiciones de API.We'll use Objective Sharpie to help us with create the API definitions.
  • Normalizar las definiciones de API : Sharpie objetivo hace un gran trabajo ayudarnos, pero no puede hacer todo.Normalize the API Definitions - Objective Sharpie does a great job of helping us, but it can't do everything. Trataremos algunos cambios que se deben realizar en las definiciones de API para que se puedan usar.We'll discuss some changes that we need to make to the API definitions before they can be used.
  • Usar la biblioteca de enlace : por último, vamos a crear una aplicación de Xamarin.iOS para mostrar cómo usar nuestro proyecto de enlace recién creado.Use the Binding Library - Finally, we'll create a Xamarin.iOS application to show how to use our newly created binding project.

Ahora que sabemos qué pasos, vamos a pasar al resto del tutorial.Now that we understand what steps are involved, let's move on to the rest of the walkthrough.

Crear una biblioteca estáticaCreating A Static Library

Si se inspeccione el código para InfColorPicker en Github:If we inspect the code for InfColorPicker in Github:

Podemos ver los tres directorios siguientes en el proyecto:We can see the following three directories in the project:

  • InfColorPicker : este directorio contiene el código de Objective-C para el proyecto.InfColorPicker - This directory contains the Objective-C code for the project.
  • PickerSamplePad : este directorio contiene un proyecto de ejemplo de iPad.PickerSamplePad - This directory contains a sample iPad project.
  • PickerSamplePhone : este directorio contiene un proyecto de ejemplo de iPhone.PickerSamplePhone - This directory contains a sample iPhone project.

Vamos a descargar el proyecto InfColorPicker desde GitHub y descomprímalo en el directorio de nuestra elección.Let's download the InfColorPicker project from GitHub and unzip it in the directory of our choosing. Abriendo el destino de Xcode para PickerSamplePhone proyecto, vemos que la siguiente estructura de proyecto en el navegador de Xcode:Opening up the Xcode target for PickerSamplePhone project, we see the following project structure in the Xcode Navigator:

Este proyecto logra la reutilización del código agregando el código fuente de InfColorPicker (en el cuadro rojo) directamente en cada proyecto de ejemplo.This project achieves code reuse by directly adding the InfColorPicker source code (in the red box) into each sample project. El código del proyecto de ejemplo es dentro del cuadro azul.The code for the sample project is inside the blue box. Dado que este proyecto en particular no proporcionarnos una biblioteca estática, es necesario para nosotros crear un proyecto de Xcode para compilar la biblioteca estática.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.

Es el primer paso para que agregar el código fuente de InfoColorPicker en la biblioteca estática.The first step is for us to add the InfoColorPicker source code into the Static Library. Para lograr esto, vamos a hacer lo siguiente:To achieve this let's do the following:

  1. Inicie Xcode.Start Xcode.

  2. Desde el archivo menú, seleccione New > proyecto... :From the File menu select New > Project...:

  3. Seleccione Framework & biblioteca, biblioteca estática de Cocoa Touch plantilla y haga clic en el siguiente botón:Select Framework & Library, the Cocoa Touch Static Library template and click the Next button:

  4. Escriba InfColorPicker para el nombre del proyecto y haga clic en el siguiente botón:Enter InfColorPicker for the Project Name and click the Next button:

  5. Seleccione una ubicación para guardar el proyecto y haga clic en el Aceptar botón.Select a location to save the project and click the OK button.

  6. Ahora necesitamos agregar el origen desde el proyecto InfColorPicker a nuestro proyecto de biblioteca estática.Now we need to add the source from the InfColorPicker project to our static library project. Dado que el InfColorPicker.h archivo ya existe en la biblioteca estática (de forma predeterminada), Xcode no nos permitirá que la sobrescriba.Because the InfColorPicker.h file already exists in our static library (by default), Xcode will not allow us to overwrite it. Desde el buscador, navegar al código fuente InfColorPicker en el proyecto original que se han descomprimido desde GitHub, copie todos los archivos InfColorPicker y pegarlas en nuestro nuevo proyecto de biblioteca estática: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:

  7. Vuelva a Xcode, haga clic con el botón derecho en el InfColorPicker carpeta y seleccione agregar archivos a "InfColorPicker..." :Return to Xcode, right click on the InfColorPicker folder and select Add files to "InfColorPicker...":

  8. En el cuadro de diálogo Agregar archivos, vaya a los archivos de código fuente de InfColorPicker que acaba de copiar, selecciónelos todos y haga clic en el agregar botón: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:

  9. El código fuente se copiará en nuestro proyecto:The source code will be copied into our project:

  10. En el navegador de proyecto Xcode, seleccione el InfColorPicker.m de archivos y marque como comentario las dos últimas líneas (debido a la manera en que se escribió esta biblioteca, no se usa este archivo):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):

  11. Ahora debemos comprobar si hay cualquier marcos requeridos por la biblioteca.We now need to check if there are any Frameworks required by the library. Puede encontrar esta información en el archivo Léame, o bien, abra uno de los proyectos de ejemplo proporcionados.You can find this information either in the README, or by opening one of the sample projects provided. Este ejemplo se utiliza Foundation.framework, UIKit.framework, y CoreGraphics.framework así que vamos a agregarlos.This example uses Foundation.framework, UIKit.framework, and CoreGraphics.framework so let's add them.

  12. Seleccione el InfColorPicker destino > fases de compilación y expanda el vincular binario con bibliotecas sección:Select the InfColorPicker target > Build Phases and expand the Link Binary With Libraries section:

  13. Use la + botón para abrir el cuadro de diálogo que le permite agregar los marcos de marcos necesarios mencionados anteriormente:Use the + button to open the dialog allowing you to add the required frames frameworks listed above:

  14. El vincular binario con bibliotecas sección debe parecerse a la imagen siguiente:The Link Binary With Libraries section should now look like the image below:

En este momento estamos close, pero no es exactamente eso concluimos.At this point we're close, but we're not quite done. Se ha creado la biblioteca estática, pero es necesario crear para crear una Fat binario que incluye todas las arquitecturas necesarias para el dispositivo iOS y simulador de iOS.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.

Creación de un archivo binario FatCreating a Fat Binary

Todos los dispositivos iOS tienen procesadores con tecnología de arquitectura ARM que han desarrollado con el tiempo.All iOS devices have processors powered by ARM architecture that have developed over time. Cada nueva arquitectura agrega otras mejoras y nuevas instrucciones mientras todavía mantiene la compatibilidad.Each new architecture added new instructions and other improvements while still maintaining backwards compatibility. los dispositivos iOS tienen armv6, armv7, armv7s, conjuntos de instrucciones arm64 – aunque armv6 no se utiliza.iOS devices have armv6, armv7, armv7s, arm64 instruction sets – although armv6 not used any more. El simulador de iOS no funciona con ARM y está en su lugar un x86 y x86_64 con tecnología de simulador.The iOS simulator is not powered by ARM and is instead a x86 and x86_64 powered simulator. Esto significa que las bibliotecas que se deben proporcionar para cada conjunto de instrucciones.That means libraries must be provided for each instruction set.

Es una biblioteca Fat .a archivo que contiene todas las arquitecturas admitidas.A Fat library is .a file containing all the supported architectures.

La creación de un contenido de grasas binario es un proceso de tres pasos:Creating a fat binary is a three step process:

  • Compile una versión 7 de ARM y ARM64 de la biblioteca estática.Compile an ARM 7 & ARM64 version of the static library.
  • Compile una versión x86 y x84_64 de la biblioteca estática.Compile an x86 and x84_64 version of the static library.
  • Use el lipo herramienta de línea de comandos para combinar las dos bibliotecas estáticas en uno.Use the lipo command line tool to combine the two static libraries into one.

Aunque estos tres pasos son bastante sencillos, puede ser necesario repetirlos en el futuro cuando la biblioteca de Objective-C recibe las actualizaciones o si se requieren correcciones de errores.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. Si decide automatizar estos pasos, se simplificará el mantenimiento futuro y soporte técnico del proyecto de enlace de iOS.If you decide to automate these steps, it will simplify the future maintenance and support of the iOS binding project.

Hay muchas herramientas disponibles para automatizar tareas - un script de shell, rake, xbuild, y realizar.There are many tools available to automate such tasks - a shell script, rake, xbuild, and make. Cuando se instalan las herramientas de línea de comandos de Xcode, make también está instalado, por lo que es el sistema de compilación que se usará para este tutorial.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. Este es un archivos MAKE que puede usar para crear una biblioteca compartida de arquitectura de múltiples que funcionará en un dispositivo iOS y el simulador para cualquier biblioteca: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

Escriba el archivos MAKE comandos en el editor de texto sin formato de su elección y actualizar las secciones con YOUR-PROJECT-NAME con el nombre del proyecto.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. También es importante asegurarse de que pegar exactamente las instrucciones anteriores con las pestañas dentro de las instrucciones que se conservan.It is also important to ensure that you paste the instructions above exactly, with the tabs within the instructions preserved.

Guarde el archivo con el nombre archivos MAKE a la misma ubicación que la biblioteca estática de Xcode de InfColorPicker hemos creado anteriormente:Save the file with the name Makefile to the same location as the InfColorPicker Xcode Static Library we created above:

Abra la aplicación Terminal del Mac y navegue hasta la ubicación de un archivo MAKE.Open the Terminal Application on your Mac and navigate to the location of your Makefile. Tipo make en el Terminal, presione ENTRAR y archivos MAKE se va a ejecutar:Type make into the Terminal, press Enter and the Makefile will be executed:

Al ejecutar make, verá mucho el desplazamiento por el texto.When you run make, you will see a lot of text scrolling by. Si todo funcionó correctamente, verá las palabras compilación correcta y libInfColorPicker-armv7.a, libInfColorPicker-i386.a y libInfColorPickerSDK.a archivos se copiarán en la misma ubicación que el archivos MAKE: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:

Puede confirmar las arquitecturas dentro de su archivo binario Fat mediante el comando siguiente:You can confirm the architectures within your Fat binary by using the following command:

xcrun -sdk iphoneos lipo -info libInfColorPicker.a

Esto debería mostrar lo siguiente:This should display the following:

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

En este momento, nos hemos completado el primer paso de nuestro enlace iOS mediante la creación de una biblioteca estática mediante Xcode y las herramientas de línea de comandos de Xcode make y 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. Vamos a continuar con el siguiente paso y usar objetivo Sharpie para automatizar la creación de los enlaces de API para nosotros.Let's move to the next step and use Objective-Sharpie to automate the creation of the API bindings for us.

Crear un proyecto de enlace de Xamarin.iOSCreate a Xamarin.iOS Binding Project

Para poder usar objetivo Sharpie para automatizar el proceso de enlace, es necesario crear un proyecto de enlace de Xamarin.iOS para alojar las definiciones de API (que vamos a usar objetivo Sharpie para ayudarnos a compilación) y cree el C# enlace para nosotros.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.

Vamos a hacer lo siguiente:Let's do the following:

  1. Inicie Visual Studio para Mac.Start Visual Studio for Mac.

  2. Desde el archivo menú, seleccione New > solución... :From the File menu, select New > Solution...:

  3. En el cuadro de diálogo nueva solución, seleccione biblioteca > enlace proyecto iOS:From the New Solution dialog box, select Library > iOS Binding Project:

  4. Haga clic en el siguiente botón.Click the Next button.

  5. Escriba "InfColorPickerBinding" como el nombre del proyecto y haga clic en el crear botón para crear la solución:Enter "InfColorPickerBinding" as the Project Name and click the Create button to create the solution:

Se creará la solución y dos archivos de forma predeterminada se incluyen:The solution will be created and two default files will be included:

  • ApiDefinition.cs -este archivo contendrá los contratos que definen cómo se ajustará la API de Objective-C en C#.ApiDefinition.cs - This file will contain the contracts that define how Objective-C API's will be wrapped in C#.
  • Structs.cs : este archivo contendrá las estructuras o valores de enumeración que son necesarios por las interfaces y delegados.Structs.cs - This file will hold any structures or enumeration values that are required by the interfaces and delegates.

Vamos a trabajar con estos dos archivos más adelante en el tutorial.We'll be working with these two files later in the walkthrough. En primer lugar, tenemos que agregar la biblioteca InfColorPicker al proyecto de enlace.First, we need to add the InfColorPicker library to the binding project.

Inclusión de la biblioteca estática en el proyecto de enlaceIncluding the Static Library in the Binding Project

Ahora tenemos nuestro proyecto de enlace, base, en listo, tenemos que agregar la biblioteca Fat binario que hemos creado anteriormente para el InfColorPicker biblioteca.Now we have our base Binding Project ready, we need to add the Fat Binary library we created above for the InfColorPicker library.

Siga estos pasos para agregar la biblioteca:Follow these steps to add the library:

  1. Haga doble clic en el las referencias nativas carpeta en el panel de solución y seleccione agregar las referencias nativas:Right-click on the Native References folder in the Solution Pad and select Add Native References:

  2. Navegue hasta la Fat binario hemos realizado anteriormente (libInfColorPickerSDK.a) y presione la abierto botón:Navigate to the Fat Binary we made earlier (libInfColorPickerSDK.a) and press the Open button:

  3. El archivo se incluirán en el proyecto:The file will be included in the project:

Cuando el .a archivo se agrega al proyecto, Xamarin.iOS establecerá automáticamente el acción de compilación del archivo a ObjcBindingNativeLibraryy cree un archivo especial llama a 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.

Este archivo contiene el LinkWith atributo que indica que Xamarin.iOS cómo agrega la biblioteca estática que acabamos de identificador.This file contains the LinkWith attribute that tells Xamarin.iOS how handle the static library that we just added. El contenido de este archivo se muestra en el siguiente fragmento de código:The contents of this file are shown in the following code snippet:

using ObjCRuntime;

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

El LinkWith atributo identifica la biblioteca estática para el proyecto y algunos indicadores importantes del vinculador.The LinkWith attribute identifies the static library for the project and some important linker flags.

Lo siguiente que debemos hacer es crear las definiciones de API para el proyecto InfColorPicker.The next thing we need to do is to create the API definitions for the InfColorPicker project. Para los fines de este tutorial, usaremos Sharpie objetivo para generar el archivo ApiDefinition.cs.For the purposes of this walkthrough, we will use Objective Sharpie to generate the file ApiDefinition.cs.

Uso de Sharpie objetivoUsing Objective Sharpie

Sharpie objetivo es una línea de comando de herramienta (proporcionado por Xamarin) que puede ayudarle a crear las definiciones necesarias para enlazar una biblioteca de Objective-C parte 3ª a C#.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#. En esta sección, vamos a usar Sharpie objetivo para la creación inicial ApiDefinition.cs para el proyecto InfColorPicker.In this section, we'll use Objective Sharpie to create the initial ApiDefinition.cs for the InfColorPicker project.

Para empezar, vamos a descargar archivo de instalador de objetivo Sharpie tal como se detalla en este guía.To get started, let's download Objective Sharpie installer file as detailed in this guide. Ejecute al instalador y siga todos los mensajes en la pantalla desde el Asistente para instalación para instalar Sharpie objetivo en nuestro equipo de desarrollo.Run the installer and follow all of the onscreen prompts from the install wizard to install Objective Sharpie on our development computer.

Después de que tengamos objetivo Sharpie correctamente instalado, vamos a iniciar la aplicación Terminal y escriba el siguiente comando para obtener ayuda acerca de todas las herramientas que proporciona para ayudar en el enlace: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

Si ejecutamos el comando anterior, se generará el siguiente resultado: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.

  bind     Create a Xamarin C# binding to Objective-C APIs
Europa:Resources kmullins$

Con el propósito de este tutorial, vamos a usar las siguientes herramientas Sharpie objetivo:For the purpose of this walkthrough, we will be using the following Objective Sharpie tools:

  • xcode : herramientas nos da información sobre la instalación de Xcode actual y las versiones de iOS y las API de Mac que hemos instalado.xcode - This tools gives us information about our current Xcode install and the versions of iOS and Mac APIs that we have installed. Vamos a usar esta información más adelante cuando se generan nuestro enlaces.We will be using this information later when we generate our bindings.
  • enlazar -vamos a usar esta herramienta para analizar el .h los archivos del proyecto InfColorPicker en inicial ApiDefinition.cs y StructsAndEnums.cs archivos.bind - We'll use this tool to parse the .h files in the InfColorPicker project into the initial ApiDefinition.cs and StructsAndEnums.cs files.

Para obtener ayuda sobre una herramienta Sharpie objetivo específica, escriba el nombre de la herramienta y el -help opción.To get help on a specific Objective Sharpie tool, enter the name of the tool and the -help option. Por ejemplo, sharpie xcode -help devuelve el siguiente resultado: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
      --sdks                 List all available Xcode SDKs. Pass -verbose for
                               more details.
Europa:Resources kmullins$

Antes de que podemos empezar el proceso de enlace, es necesario obtener información acerca de nuestro SDK instalados actual escribiendo el comando siguiente en el Terminal 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

De lo anterior, podemos ver que tenemos el iphoneos9.3 SDK instalado en la máquina.From the above, we can see that we have the iphoneos9.3 SDK installed on our machine. Con esta información en su lugar, estamos preparados para analizar el proyecto InfColorPicker .h archivos a la inicial ApiDefinition.cs y StructsAndEnums.cs para el proyecto InfColorPicker.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.

Escriba el siguiente comando en la aplicación Terminal:Enter the following command in the Terminal app:

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

Donde [full-path-to-project] es la ruta de acceso completa al directorio donde la InfColorPicker se encuentra el archivo de proyecto de Xcode en nuestro equipo y [iphone-SO] es el SDK de iOS que hemos instalado, como indica la sharpie xcode -sdks comando.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. Tenga en cuenta que en este ejemplo hemos pasado *.h como un parámetro, que incluye todas los archivos de encabezado en este directorio - normalmente debe no lo hace, pero en su lugar, lea detenidamente a través de la archivos de encabezado para buscar el nivel superior .h archivo que hace referencia a todos los archivos pertinentes y solo se pasa al objetivo Sharpie.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.

La siguiente salida se generarán en el terminal: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$

Y el InfColorPicker.enums.cs y InfColorPicker.cs archivos se crearán en el directorio:And the InfColorPicker.enums.cs and InfColorPicker.cs files will be created in our directory:

Abra ambos archivos en el proyecto de enlace que se crearon anteriormente.Open both of these files in the Binding project that we created above. Copie el contenido de la InfColorPicker.cs de archivo y péguelo en el ApiDefinition.cs archivo, reemplazando las existentes namespace ... bloque de código con el contenido de la InfColorPicker.cs archivo (dejando el using instrucciones intactas):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):

Normalizar las definiciones de APINormalize the API Definitions

Objetivo Sharpie a veces, tiene un problema de traducir Delegates, por lo que necesitamos modificar la definición de la InfColorPickerControllerDelegate interfaz y reemplace el [Protocol, Model] línea con lo siguiente: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]

Para que la definición tiene el siguiente aspecto:So that the definition looks like:

A continuación, hacemos lo mismo con el contenido de la InfColorPicker.enums.cs archivo, copiar y pegar en el StructsAndEnums.cs archivo dejando la using intactas las instrucciones: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:

También es posible que Sharpie objetivo se anota el enlace con [Verify] atributos.You may also find that Objective Sharpie has annotated the binding with [Verify] attributes. Estos atributos indican que debe comprobar que el objetivo Sharpie hizo lo correcto comparando el enlace con la declaración de C, Objective-C original (que se proporcionará en un comentario sobre la declaración de enlace).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). Una vez que haya comprobado los enlaces, debe quitar el atributo compruebe.Once you have verified the bindings, you should remove the verify attribute. Para obtener más información, consulte el compruebe guía.For more information, refer to the Verify guide.

En este momento, nuestro proyecto de enlace debe ser completo y listo para compilar.At this point, our binding project should be complete and ready to build. Vamos a crear nuestro proyecto de enlace y asegúrese de que se finalizó sin errores:Let's build our binding project and make sure that we ended up with no errors:

Compile el proyecto de enlace y asegúrese de que no hay erroresBuild the binding project and make sure there are no errors

Mediante el enlaceUsing the Binding

Siga estos pasos para crear una aplicación de iPhone de ejemplo para usar la biblioteca de enlace creada anteriormente de iOS:Follow these steps to create a sample iPhone application to use the iOS Binding Library created above:

  1. Crear proyecto de Xamarin.iOS -agregar un nuevo proyecto de Xamarin.iOS denominado InfColorPickerSample a la solución, como se muestra en las capturas de pantalla siguiente:Create Xamarin.iOS Project - Add a new Xamarin.iOS project called InfColorPickerSample to the solution, as shown in the following screenshots:

  2. Agregar referencia al proyecto de enlace -actualización de la InfColorPickerSample del proyecto para que tenga una referencia a la InfColorPickerBinding proyecto:Add Reference to the Binding Project - Update the InfColorPickerSample project so that it has a reference to the InfColorPickerBinding project:

  3. Crear la interfaz de usuario de iPhone -haga doble clic en el MainStoryboard.storyboard de archivos en el InfColorPickerSample proyecto para editarlo en el Diseñador de iOS.Create the iPhone User Interface - Double click on the MainStoryboard.storyboard file in the InfColorPickerSample project to edit it in the iOS Designer. Agregar un botón a la vista y llámelo ChangeColorButton, tal y como se muestra en la siguiente:Add a Button to the view and call it ChangeColorButton, as shown in the following:

  4. Agregar el InfColorPickerView.xib -InfColorPicker Objective-C en la biblioteca incluye un .xib archivo.Add the InfColorPickerView.xib - The InfColorPicker Objective-C library includes a .xib file. Xamarin.iOS no incluirá este .xib en el proyecto de enlace, lo que provocará errores en tiempo de ejecución en nuestra aplicación de ejemplo.Xamarin.iOS will not include this .xib in the binding project, which will cause run-time errors in our sample application. Para solucionar esto consiste en agregar el .xib archivo a nuestro proyecto de Xamarin.iOS.The workaround for this is to add the .xib file to our Xamarin.iOS project. Seleccione el proyecto de Xamarin.iOS, contextual y seleccione Agregar > Agregar archivosy agregue el .xib archivo tal como se muestra en la captura de pantalla siguiente:Select the Xamarin.iOS project, right-click and select Add > Add Files, and add the .xib file as shown in the following screenshot:

  5. Cuando se le pida, copie el .xib archivo en el proyecto.When asked, copy the .xib file into the project.

A continuación, echemos un vistazo rápido a los protocolos en Objective-C y cómo se controlan en el enlace y C# código.Next, let's take a quick look at Protocols in Objective-C and how we handle them in binding and C# code.

Protocolos y Xamarin.iOSProtocols and Xamarin.iOS

En Objective-C, un protocolo define los métodos (o mensajes) que se puede utilizar en determinadas circunstancias.In Objective-C, a protocol defines methods (or messages) that can be used in certain circumstances. Conceptualmente, son muy similares a las interfaces de C#.Conceptually, they are very similar to interfaces in C#. Una diferencia importante entre un protocolo de Objective-C y un C# interfaz es que los protocolos pueden tener métodos opcionales - métodos que una clase no tiene que implementar.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. Objective-C usa las @optional palabra clave se utiliza para indicar qué métodos son opcionales.Objective-C uses the @optional keyword is used to indicate which methods are optional. Para obtener más información sobre los protocolos consulte eventos, protocolos y delegados.For more information on protocols see Events, Protocols and Delegates.

InfColorPickerController tiene un protocolo este tipo, se muestra en el siguiente fragmento de código: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

Este protocolo se usa por InfColorPickerController para informar a los clientes que el usuario ha seleccionado un nuevo color y que la InfColorPickerController haya finalizado.This protocol is used by InfColorPickerController to inform clients that the user has picked a new color and that the InfColorPickerController is finished. Sharpie objetivo había asignado este protocolo, como se muestra en el siguiente fragmento de código: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);
}

Cuando se compila la biblioteca de enlace, Xamarin.iOS creará una clase base abstracta denominada InfColorPickerControllerDelegate, que implementa esta interfaz con los métodos virtuales.When the binding library is compiled, Xamarin.iOS will create an abstract base class called InfColorPickerControllerDelegate, which implements this interface with virtual methods.

Hay dos maneras de que podemos implementar esta interfaz en una aplicación de Xamarin.iOS:There are two ways that we can implement this interface in a Xamarin.iOS application:

  • Delegado seguro -mediante un delegado seguro implica la creación de un C# que cree subclases de clases InfColorPickerControllerDelegate e invalida los métodos adecuados.Strong Delegate - Using a strong delegate involves creating a C# class that subclasses InfColorPickerControllerDelegate and overrides the appropriate methods. InfColorPickerController utilizará una instancia de esta clase para comunicarse con sus clientes.InfColorPickerController will use an instance of this class to communicate with its clients.
  • Delegado débil -un delegado débil es una técnica ligeramente diferente que implica la creación de un método público en alguna clase (como InfColorPickerSampleViewController) y, a continuación, exponer ese método a la InfColorPickerDelegate protocolo a través de un Export atributo.Weak 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.

Delegados seguros proporcionan Intellisense, seguridad de tipos y una mejor encapsulación.Strong delegates provide Intellisense, type safety, and better encapsulation. Por estas razones, debe usar a delegados seguros donde puede, en lugar de un delegado débil.For these reasons, you should use strong delegates where you can, instead of a weak delegate.

En este tutorial, veremos dos técnicas: implementar primero un delegado seguro y, a continuación, que se explica cómo implementar un delegado débil.In this walkthrough we will discuss both techniques: first implementing a strong delegate, and then explaining how to implement a weak delegate.

Implementación de un delegado seguroImplementing a Strong Delegate

Finalizar la aplicación de Xamarin.iOS mediante el uso de un delegado seguro para responder a la colorPickerControllerDidFinish: mensaje:Finish the Xamarin.iOS application by using a strong delegate to respond to the colorPickerControllerDidFinish: message:

Subclase InfColorPickerControllerDelegate -agregar una nueva clase al proyecto denominado ColorSelectedDelegate.Subclass InfColorPickerControllerDelegate - Add a new class to the project called ColorSelectedDelegate. Modifique la clase para que tenga el código siguiente: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 se enlazará el delegado de Objective-C mediante la creación de una clase base abstracta denominada InfColorPickerControllerDelegate.Xamarin.iOS will bind the Objective-C delegate by creating an abstract base class called InfColorPickerControllerDelegate. Subclase este tipo y la invalidación del ColorPickerControllerDidFinish método para acceder al valor de la ResultColor propiedad de InfColorPickerController.Subclass this type and override the ColorPickerControllerDidFinish method to access the value of the ResultColor property of InfColorPickerController.

Crear una instancia de ColorSelectedDelegate -nuestro controlador de eventos tendrá una instancia de la ColorSelectedDelegate tipo que creamos en el paso anterior.Create a instance of ColorSelectedDelegate - Our event handler will need an instance of the ColorSelectedDelegate type that we created in the previous step. Modifique la clase InfColorPickerSampleViewController y agregue la siguiente variable de instancia a la clase:Edit the class InfColorPickerSampleViewController and add the following instance variable to the class:

ColorSelectedDelegate selector;

Inicialice la variable ColorSelectedDelegate : para asegurarse de que selector es válido de la instancia, el método de actualización ViewDidLoad en ViewController para que coincida con el siguiente fragmento de código: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);
}

Implemente el método HandleTouchUpInsideWithStrongDelegate -a continuación, implemente el controlador de eventos cuando el usuario toca ColorChangeButton.Implement the method HandleTouchUpInsideWithStrongDelegate - Next implement the event handler for when the user touches ColorChangeButton. Editar ViewControllery agregue el siguiente método: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);
}

Obtenemos primero una instancia de InfColorPickerController a través de un método estático y asegúrese de que la instancia consciente de nuestro delegado seguro a través de la propiedad 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. Esta propiedad se generó automáticamente para que podamos por objetivo Sharpie.This property was automatically generated for us by Objective Sharpie. Por último, llamamos PresentModallyOverViewController para mostrar la vista InfColorPickerSampleViewController.xib para que el usuario puede seleccionar un color.Finally we call PresentModallyOverViewController to show the view InfColorPickerSampleViewController.xib so that the user may select a color.

Ejecute la aplicación : en este punto hemos terminado con todo nuestro código.Run the Application - At this point we're done with all of our code. Si ejecuta la aplicación, podrá cambiar el color de fondo de la InfColorColorPickerSampleView tal como se muestra en las capturas de pantalla siguiente:If you run the application, you should be able to change the background color of the InfColorColorPickerSampleView as shown in the following screenshots:

¡Enhorabuena!Congratulations! En este punto ha creado correctamente y enlaza una biblioteca de Objective-C para su uso en una aplicación de Xamarin.iOS.At this point you've successfully created and bound an Objective-C library for use in a Xamarin.iOS application. A continuación, vamos a aprender sobre el uso de delegados débiles.Next, let's learn about using weak delegates.

Implementación de un delegado débilImplementing a Weak Delegate

En lugar de crear subclases de una clase enlazada con el protocolo de Objective-C para un determinado delegado, Xamarin.iOS también le permite implementar los métodos de protocolo en cualquier clase que derive de NSObject, decoración de los métodos con el ExportAttributey, a continuación, se ha proporcionado los selectores adecuados.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. Al adoptar este enfoque, asigne una instancia de la clase a la WeakDelegate propiedad en lugar de a la Delegate propiedad.When you take this approach, you assign an instance of your class to the WeakDelegate property instead of to the Delegate property. Un delegado débil le ofrece la flexibilidad para tomar la clase delegada hacia abajo de una jerarquía de herencia diferente.A weak delegate offers you the flexibility to take your delegate class down a different inheritance hierarchy. Vamos a ver cómo implementar y utilizar a un delegado débil en nuestra aplicación de Xamarin.iOS.Let’s see how to implement and use a weak delegate in our Xamarin.iOS application.

Crear el controlador de eventos para TouchUpInside -vamos a crear un nuevo controlador de eventos para el TouchUpInside eventos del botón Cambiar Color de fondo.Create Event Handler for TouchUpInside - Let's create a new event handler for the TouchUpInside event of the Change Background Color button. Este controlador llenará la misma función que el HandleTouchUpInsideWithStrongDelegate controlador que se creó en la sección anterior, pero utiliza un delegado débil en lugar de un delegado seguro.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. Modifique la clase ViewControllery agregue el siguiente método: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);
}

Actualizar ViewDidLoad -debemos cambiar ViewDidLoad para que use el controlador de eventos que acabamos de crear.Update ViewDidLoad - We must change ViewDidLoad so that it uses the event handler that we just created. Editar ViewController y cambiar ViewDidLoad similar a la de fragmento de código siguiente:Edit ViewController and change ViewDidLoad to resemble the following code snippet:

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

Controlar la colorPickerControllerDidFinish: Mensaje : si el ViewController está terminado, iOS enviará el mensaje colorPickerControllerDidFinish: a la WeakDelegate.Handle the colorPickerControllerDidFinish: Message - When the ViewController is finished, iOS will send the message colorPickerControllerDidFinish: to the WeakDelegate. Es necesario crear un C# método que puede controlar este mensaje.We need to create a C# method that can handle this message. Para ello, creamos un C# método y, a continuación, agregar adornos a él con el ExportAttribute.To do this, we create a C# method and then adorn it with the ExportAttribute. Editar ViewControllery agregue el siguiente método a la clase:Edit ViewController, and add the following method to the class:

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

Ejecute la aplicación.Run the application. Ahora debe se comportan exactamente como lo hizo antes, pero usa a un delegado débil en lugar del delegado seguro.It should now behave exactly as it did before, but it's using a weak delegate instead of the strong delegate. En este momento se ha completado correctamente este tutorial.At this point you've successfully completed this walkthrough. Ahora debe tener una comprensión de cómo crear y consumir un proyecto de enlace de Xamarin.iOS.You should now have an understanding of how to create and consume a Xamarin.iOS binding project.

ResumenSummary

En este artículo ha avanzado a través del proceso de creación y uso de un proyecto de enlace de Xamarin.iOS.This article walked through the process of creating and using a Xamarin.iOS binding project. Primero analizamos cómo compilar una biblioteca de Objective-C existente en una biblioteca estática.First we discussed how to compile an existing Objective-C library into a static library. A continuación, hemos tratado la creación de un proyecto de enlace de Xamarin.iOS y cómo usar Sharpie objetivo para generar las definiciones de API de la biblioteca de Objective-C.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. Analizamos cómo actualizar y ajustar las definiciones de API generadas para que sean adecuados para consumo público.We discussed how to update and tweak the generated API definitions to make them suitable for public consumption. Una vez se ha finalizado el proyecto de enlace de Xamarin.iOS, pasamos a consumir ese enlace en una aplicación de Xamarin.iOS, con un enfoque sobre el uso de delegados fuertes y débiles delegados.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.