Enlaces de Xamarin.Mac en aplicaciones de consola

  • Artículo
  • 4 minutos para leer

Hay algunos escenarios en los que desea usar algunas de las API nativas de Apple en C# para compilar una aplicación sin sentido( una que no tiene una interfaz de usuario) mediante C#.

Las plantillas de proyecto para aplicaciones Mac incluyen una llamada a seguida de una llamada NSApplication.Init() a , normalmente tiene este NSApplication.Main(args) aspecto:

static class MainClass {
    static void Main (string [] args)
    {
        NSApplication.Init ();
        NSApplication.Main (args);
    }
}

La llamada a prepara el tiempo de ejecución de Xamarin.Mac, la llamada a inicia el bucle principal de la aplicación Cocoa, que prepara la aplicación para recibir eventos de teclado y mouse y mostrar la ventana principal de InitMain(args) la aplicación. La llamada a también intentará localizar recursos de Cocoa, preparar una ventana de nivel superior y espera que el programa forma parte de un paquete de aplicaciones (programas distribuidos en un directorio con la extensión y un diseño muy Main.app específico).

Las aplicaciones sin sentido no necesitan una interfaz de usuario y no necesitan ejecutarse como parte de un conjunto de aplicaciones.

Creación de la aplicación de consola

Por lo tanto, es mejor empezar con un tipo de proyecto de consola de .NET normal.

Debe hacer algunas cosas:

  • Creación de un proyecto vacío.
  • Haga referencia a Xamarin.Mac.dll biblioteca.
  • Lleve la dependencia no administrada al proyecto.

Estos pasos se explican con más detalle a continuación:

Creación de una consola vacía Project

Cree una nueva consola de .NET Project, asegúrese de que es .NET y no .NET Core, ya que Xamarin.Mac.dll no se ejecuta en el entorno de ejecución de .NET Core, solo se ejecuta con el entorno de ejecución Mono.

Referencia a la biblioteca de Xamarin.Mac

Para compilar el código, querrá hacer referencia al Xamarin.Mac.dll ensamblado desde este directorio: /Library/Frameworks/Xamarin.Mac.framework/Versions/Current/lib/64bits/full

Para ello, vaya a las referencias del proyecto, seleccione la pestaña Ensamblado de .NET y haga clic en el botón Examinar para buscar el archivo en el sistema de archivos. Vaya a la ruta de acceso anterior y, a continuación, seleccione elXamarin.Mac.dll de ese directorio.

Esto le dará acceso a las API de Cocoa en tiempo de compilación. En este momento, puede agregar using AppKit a la parte superior del archivo y llamar al método NSApplication.Init() . Solo hay un paso más antes de poder ejecutar la aplicación.

Traer la biblioteca de compatibilidad no administrada al proyecto

Antes de que se ejecute la aplicación, debe traer la biblioteca Xamarin.Mac de soporte técnico al proyecto. Para ello, agregue un nuevo archivo al proyecto (en las opciones del proyecto, seleccione Agregar y,a continuación, Agregar archivo existente)y vaya a este directorio:

/Library/Frameworks/Xamarin.Mac.framework/Versions/Current/SDKs/Xamarin.macOS.sdk/lib

Aquí, seleccione el archivo libxammac.dylib. Se le ofrecerá una opción de copiar, vincular o mover. Personalmente me gusta la vinculación, pero la copia también funciona. A continuación, debe seleccionar el archivo y, en el panel de propiedades (seleccione > Ver propiedades de panel si el panel de propiedades no está visible), vaya a la sección Compilación y establezca la opción Copiar en directorio de salida en Copiar si es más reciente.>

Ahora puede ejecutar la aplicación xamarin.mac.

El resultado en el directorio bin tendrá el siguiente aspecto:

Xamarin.Mac.dll
Xamarin.Mac.pdb
consoleapp.exe
consoleapp.pdb
libxammac.dylib

Para ejecutar esta aplicación, necesitará todos esos archivos en el mismo directorio.

Creación de una aplicación independiente para la distribución

Es posible que quiera distribuir un único ejecutable a los usuarios. Para ello, puede usar la herramienta para mkbundle convertir los distintos archivos en un ejecutable autocontenido.

En primer lugar, asegúrese de que la aplicación se compila y se ejecuta. Una vez que esté satisfecho con los resultados, puede ejecutar el siguiente comando desde la línea de comandos:

$ mkbundle --simple -o /tmp/consoleapp consoleapp.exe --library libxammac.dylib --config /Library/Frameworks/Mono.framework/Versions/Current/etc/mono/config --machine-config /Library/Frameworks/Mono.framework/Versions/Current//etc/mono/4.5/machine.config
[Output from the bundling tool]
$ _

En la invocación de línea de comandos anterior, la opción se usa para especificar la salida -o generada; en este caso, se pasó /tmp/consoleapp . Ahora se trata de una aplicación independiente que puede distribuir y no tiene dependencias externas en Mono o Xamarin.Mac, es un ejecutable totalmente independiente.

La línea de comandos especificó manualmente el archivo machine.config que se usará y un archivo de configuración de asignación de biblioteca para todo el sistema. No son necesarias para todas las aplicaciones, pero es conveniente agruparlas, ya que se usan cuando se usan más funcionalidades de .NET.

Project compilaciones sin conexión

No necesita un proyecto completo para crear una aplicación de Xamarin.Mac independiente, también puede usar archivos Make de Unix simples para realizar el trabajo. En el ejemplo siguiente se muestra cómo configurar un archivo Make para una aplicación de línea de comandos sencilla:

XAMMAC_PATH=/Library/Frameworks/Xamarin.Mac.framework/Versions/Current//lib/x86_64/full/
DYLD=/Library/Frameworks/Xamarin.Mac.framework/Versions/Current//lib
MONODIR=/Library/Frameworks/Mono.framework/Versions/Current/etc/mono

all: consoleapp.exe

consoelapp.exe: consoleapp.cs Makefile
    mcs -g -r:$(XAMMAC_PATH)/Xamarin.Mac.dll consoleapp.cs
    
run: consoleapp.exe
    MONO_PATH=$(XAMMAC_PATH) DYLD_LIBRARY_PATH=$(DYLD) mono --debug consoleapp.exe $(COMMAND)

bundle: consoleapp.exe
    mkbundle --simple consoleapp.exe -o ncsharp -L $(XAMMAC_PATH) --library $(DYLD)/libxammac.dylib --config $(MONODIR)/config --machine-config $(MONODIR)/4.5/machine.config

Lo anterior Makefile proporciona tres destinos:

  • make compilará el programa
  • make run compilará y ejecutará el programa en el directorio actual.
  • make bundle creará un ejecutable autocontenido