Liaisons Xamarin.Mac dans les applications console

Article
07/13/2023

Il existe certains scénarios dans lesquels vous souhaitez utiliser certaines API natives Apple en C# pour créer une application sans tête ( qui n’a pas d’interface utilisateur) à l’aide de C#.

Les modèles de projet pour les applications Mac incluent un appel à NSApplication.Init() suivi d’un appel à , il ressemble généralement à NSApplication.Main(args)ceci :

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

L’appel à Init prépare le runtime Xamarin.Mac, l’appel à Main(args) démarre la boucle main de l’application Cocoa, qui prépare l’application à recevoir les événements du clavier et de la souris et à afficher la fenêtre main de votre application. L’appel à Main tentera également de localiser les ressources Cocoa, de préparer une fenêtre toplevel et s’attend à ce que le programme fait partie d’un bundle d’applications (programmes distribués dans un répertoire avec l’extension .app et une disposition très spécifique).

Les applications sans tête n’ont pas besoin d’interface utilisateur et n’ont pas besoin de s’exécuter dans le cadre d’une offre groupée d’applications.

Création de l’application console

Il est donc préférable de commencer avec un type de projet de console .NET standard.

Vous devez effectuer quelques opérations :

Créez un projet vide.
Référencez la bibliothèque Xamarin.Mac.dll.
Apportez la dépendance non managée à votre projet.

Ces étapes sont expliquées plus en détail ci-dessous :

Créer un projet de console vide

Créez un projet de console .NET, vérifiez qu’il s’agit de .NET et non de .NET Core, car Xamarin.Mac.dll ne s’exécute pas sous le runtime .NET Core, il s’exécute uniquement avec le runtime Mono.

Référencer la bibliothèque Xamarin.Mac

Pour compiler votre code, vous devez référencer l’assembly Xamarin.Mac.dll à partir de ce répertoire : /Library/Frameworks/Xamarin.Mac.framework/Versions/Current/lib/64bits/full

Pour ce faire, accédez aux références de projet, sélectionnez l’onglet Assembly .NET , puis cliquez sur le bouton Parcourir pour localiser le fichier sur le système de fichiers. Accédez au chemin d’accès ci-dessus, puis sélectionnez le Xamarin.Mac.dll dans ce répertoire.

Cela vous donnera accès aux API Cocoa au moment de la compilation. À ce stade, vous pouvez ajouter using AppKit en haut de votre fichier et appeler la NSApplication.Init() méthode. Il n’y a qu’une étape supplémentaire avant de pouvoir exécuter votre application.

Intégrer la bibliothèque de support non managée dans votre projet

Avant que votre application ne s’exécute, vous devez intégrer la bibliothèque de Xamarin.Mac support dans votre projet. Pour ce faire, ajoutez un nouveau fichier à votre projet (dans les options du projet, sélectionnez Ajouter, puis Ajouter un fichier existant) et accédez à ce répertoire :

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

Ici, sélectionnez le fichier libxammac.dylib. Vous aurez le choix entre copier, lier ou déplacer. Personnellement, j’aime le lien, mais la copie fonctionne aussi. Ensuite, vous devez sélectionner le fichier et, dans le volet de propriétés (sélectionnez Afficher>les propriétés des pavés> si le pavé de propriétés n’est pas visible), accédez à la section Générer et définissez le paramètre Copier sur Répertoire de sortie sur Copier si plus récent.

Vous pouvez maintenant exécuter votre application Xamarin.Mac.

Le résultat dans votre répertoire bin se présente comme suit :

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

Pour exécuter cette application, vous aurez besoin de tous ces fichiers dans le même répertoire.

Création d’une application autonome pour la distribution

Vous souhaiterez peut-être distribuer un seul exécutable à vos utilisateurs. Pour ce faire, vous pouvez utiliser l’outil mkbundle pour transformer les différents fichiers en un exécutable autonome.

Tout d’abord, assurez-vous que votre application se compile et s’exécute. Une fois que vous êtes satisfait des résultats, vous pouvez exécuter la commande suivante à partir de la ligne de commande :

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

Dans l’appel de ligne de commande ci-dessus, l’option -o est utilisée pour spécifier la sortie générée. Dans ce cas, nous avons passé /tmp/consoleapp. Il s’agit désormais d’une application autonome que vous pouvez distribuer et qui n’a aucune dépendance externe sur Mono ou Xamarin.Mac. Il s’agit d’un exécutable entièrement autonome.

La ligne de commande a spécifié manuellement le fichier machine.config à utiliser et un fichier de configuration de mappage de bibliothèque à l’échelle du système. Ils ne sont pas nécessaires pour toutes les applications, mais il est pratique de les regrouper, car ils sont utilisés lorsque vous utilisez davantage de fonctionnalités de .NET

Builds sans projet

Vous n’avez pas besoin d’un projet complet pour créer une application Xamarin.Mac autonome. Vous pouvez également utiliser de simples makefiles Unix pour effectuer le travail. L’exemple suivant montre comment configurer un makefile pour une application de ligne de commande simple :

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

Ce qui précède Makefile fournit trois cibles :

make générera le programme
make run générera et exécutera le programme dans le répertoire actif
make bundle créera un exécutable autonome

Partager via