Xamarin.Mac-Bindungen in Konsolen-Apps

  • Artikel

Es gibt einige Szenarien, in denen Sie einige native Apple-APIs in C# verwenden möchten, um mithilfe von C# eine anwendung ohne Kopf zu erstellen , die keine Benutzeroberfläche hat.

Die Projektvorlagen für Mac-Anwendungen enthalten einen Aufruf NSApplication.Init() von, gefolgt von einem Aufruf von NSApplication.Main(args), der normalerweise wie folgt aussieht:

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

Der Aufruf von Init bereitet die Xamarin.Mac-Runtime vor, der Aufruf zum Main(args) Starten der Cocoa-Anwendung Standard Schleife, die die Anwendung auf den Empfang von Tastatur- und Mausereignissen vorbereitet und das Standard Fenster Ihrer Anwendung anzeigt. Der Aufruf von Main versucht auch, Cocoa-Ressourcen zu finden, ein Fenster auf oberster Ebene vorzubereiten und erwartet, dass das Programm Teil eines Anwendungspakets ist (Programme, die in einem Verzeichnis mit der .app Erweiterung und einem sehr spezifischen Layout verteilt sind).

Kopflose Anwendungen benötigen keine Benutzeroberfläche und müssen nicht als Teil eines Anwendungspakets ausgeführt werden.

Erstellen der Konsolen-App

Daher ist es besser, mit einem regulären .NET-Konsolenprojekttyp zu beginnen.

Sie müssen einige Dinge tun:

  • Erstellen Sie ein leeres Projekt.
  • Verweisen Sie auf die Xamarin.Mac.dll-Bibliothek.
  • Bringen Sie die nicht verwaltete Abhängigkeit zu Ihrem Projekt.

Die folgenden Schritte werden im Folgenden ausführlicher erläutert:

Erstellen eines leeren Konsolenprojekts

Erstellen Sie ein neues .NET-Konsolenprojekt, und stellen Sie sicher, dass es sich um .NET und nicht um .NET Core handelt, da Xamarin.Mac.dll nicht unter der .NET Core-Runtime ausgeführt wird, es wird nur mit der Mono-Runtime ausgeführt.

Verweisen auf die Xamarin.Mac-Bibliothek

Um Ihren Code zu kompilieren, müssen Sie aus diesem Verzeichnis auf die Xamarin.Mac.dll Assembly verweisen: /Library/Frameworks/Xamarin.Mac.framework/Versions/Current/lib/64bits/full

Wechseln Sie hierzu zu den Projektverweise, wählen Sie die Registerkarte .NET Assembly aus, und klicken Sie auf die Schaltfläche Durchsuchen , um die Datei im Dateisystem zu suchen. Navigieren Sie zum obigen Pfad, und wählen Sie dann den Xamarin.Mac.dll aus diesem Verzeichnis aus.

Dadurch erhalten Sie zur Kompilierzeit Zugriff auf die Cocoa-APIs. An diesem Punkt können Sie die Datei am Anfang hinzufügen using AppKit und die NSApplication.Init() -Methode aufrufen. Es gibt nur einen weiteren Schritt, bevor Sie Ihre Anwendung ausführen können.

Integrieren der nicht verwalteten Supportbibliothek in Ihr Projekt

Bevor Ihre Anwendung ausgeführt wird, müssen Sie die Xamarin.Mac Supportbibliothek in Ihr Projekt integrieren. Fügen Sie hierzu ihrem Projekt eine neue Datei hinzu (wählen Sie in den Projektoptionen Hinzufügen und dann Vorhandene Datei hinzufügen) aus, und navigieren Sie zu diesem Verzeichnis:

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

Wählen Sie hier die Datei libxammac.dylib aus. Es wird Ihnen eine Auswahl zum Kopieren, Verknüpfen oder Verschieben angeboten. Ich persönlich mag das Verknüpfen, aber das Kopieren funktioniert auch. Dann müssen Sie die Datei auswählen, und im Eigenschaftenpad (wählen Sie Pads-Eigenschaften>anzeigen> aus, wenn das Eigenschaftenpad nicht sichtbar ist), wechseln Sie zum Abschnitt Erstellen, und legen Sie die Einstellung In Ausgabeverzeichnis kopieren auf Kopieren, wenn neuer fest.

Sie können jetzt Ihre Xamarin.Mac-Anwendung ausführen.

Das Ergebnis in Ihrem Bin-Verzeichnis sieht wie folgt aus:

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

Zum Ausführen dieser App benötigen Sie alle diese Dateien im selben Verzeichnis.

Erstellen einer eigenständigen Anwendung für die Verteilung

Möglicherweise möchten Sie eine einzelne ausführbare Datei an Ihre Benutzer verteilen. Dazu können Sie das mkbundle Tool verwenden, um die verschiedenen Dateien in eine eigenständige ausführbare Datei umzuwandeln.

Stellen Sie zunächst sicher, dass Ihre Anwendung kompiliert und ausgeführt wird. Sobald Sie mit den Ergebnissen zufrieden sind, können Sie den folgenden Befehl über die Befehlszeile ausführen:

$ 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]
$ _

Beim obigen Befehlszeilenaufruf wird die Option -o verwendet, um die generierte Ausgabe anzugeben. In diesem Fall haben wir übergeben /tmp/consoleapp. Dies ist jetzt eine eigenständige Anwendung, die Sie verteilen können und keine externen Abhängigkeiten von Mono oder Xamarin.Mac aufweist, es ist eine vollständig eigenständige ausführbare Datei.

Die Befehlszeile hat die zu verwendende machine.config-Datei und eine systemweite Bibliothekszuordnungskonfigurationsdatei angegeben. Sie sind nicht für alle Anwendungen erforderlich, aber es ist praktisch, sie zu bündeln, da sie verwendet werden, wenn Sie mehr Funktionen von .NET verwenden.

Projektlose Builds

Sie benötigen kein vollständiges Projekt, um eine eigenständige Xamarin.Mac-Anwendung zu erstellen. Sie können auch einfache Unix-Makefiles verwenden, um den Auftrag zu erledigen. Das folgende Beispiel zeigt, wie Sie eine Makefile-Datei für eine einfache Befehlszeilenanwendung einrichten können:

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

Das oben genannte Makefile enthält drei Ziele:

  • make erstellt das Programm
  • make run erstellt und führt das Programm im aktuellen Verzeichnis aus.
  • make bundle erstellt eine eigenständige ausführbare Datei