Associações do Xamarin.Mac em aplicativos de console

  • Artigo

Há alguns cenários em que você deseja usar algumas apis nativas da Apple em C# para criar um aplicativo sem periféneos – um que não tem uma interface do usuário – usando C#.

Os modelos de projeto para aplicativos Mac incluem uma chamada para NSApplication.Init() seguida por uma chamada para NSApplication.Main(args), geralmente tem esta aparência:

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

A chamada para Init prepara o runtime do Xamarin.Mac, a chamada para Main(args) inicia o loop de main do aplicativo Cocoa, que prepara o aplicativo para receber eventos de teclado e mouse e mostrar a janela main do aplicativo. A chamada para Main também tentará localizar os recursos do Cocoa, preparar uma janela toplevel e espera que o programa faça parte de um pacote de aplicativos (programas distribuídos em um diretório com a .app extensão e um layout muito específico).

Aplicativos sem cabeça não precisam de uma interface do usuário e não precisam ser executados como parte de um pacote de aplicativos.

Criando o aplicativo de console

Portanto, é melhor começar com um tipo de projeto normal do Console do .NET.

Você precisa fazer algumas coisas:

  • Criar um projeto vazio.
  • Referencie a biblioteca de Xamarin.Mac.dll.
  • Traga a dependência não gerenciada para seu projeto.

Estas etapas são explicadas mais detalhadamente abaixo:

Criar um projeto de console vazio

Crie um novo Projeto de Console do .NET, verifique se ele é .NET e não .NET Core, pois Xamarin.Mac.dll não é executado no runtime do .NET Core, ele é executado apenas com o runtime mono.

Referenciar a biblioteca Xamarin.Mac

Para compilar seu código, você desejará referenciar o Xamarin.Mac.dll assembly deste diretório: /Library/Frameworks/Xamarin.Mac.framework/Versions/Current/lib/64bits/full

Para fazer isso, acesse as referências do projeto, selecione a guia Assembly do .NET e clique no botão Procurar para localizar o arquivo no sistema de arquivos. Navegue até o caminho acima e selecione o Xamarin.Mac.dll desse diretório.

Isso lhe dará acesso às APIs cocoa em tempo de compilação. Neste ponto, você pode adicionar using AppKit à parte superior do arquivo e chamar o NSApplication.Init() método . Há apenas mais uma etapa antes que você possa executar seu aplicativo.

Colocar a biblioteca de suporte não gerenciada em seu projeto

Antes que seu aplicativo seja executado, você precisa trazer a Xamarin.Mac biblioteca de suporte para seu projeto. Para fazer isso, adicione um novo arquivo ao seu projeto (em opções de projeto, selecione Adicionar e Adicionar Arquivo Existente) e navegue até este diretório:

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

Aqui, selecione o arquivo libxammac.dylib. Você terá a opção de copiar, vincular ou mover. Eu pessoalmente gosto de vincular, mas copiar também funciona. Em seguida, você precisa selecionar o arquivo e, no painel de propriedades (selecione Exibir>Propriedades de Painéis> se o painel de propriedades não estiver visível), vá para a seção Compilar e defina a configuração Copiar para Diretório de Saída como Copiar se for mais recente.

Agora você pode executar seu aplicativo Xamarin.Mac.

O resultado no diretório bin terá esta aparência:

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

Para executar esse aplicativo, você precisará de todos esses arquivos no mesmo diretório.

Criando um aplicativo autônomo para distribuição

Talvez você queira distribuir um único executável para seus usuários. Para fazer isso, você pode usar a mkbundle ferramenta para transformar os vários arquivos em um executável autossuficiível.

Primeiro, verifique se o aplicativo é compilado e executado. Quando estiver satisfeito com os resultados, você poderá executar o seguinte comando na linha de comando:

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

Na invocação de linha de comando acima, a opção -o é usada para especificar a saída gerada, nesse caso, passamos /tmp/consoleapp. Agora esse é um aplicativo autônomo que você pode distribuir e não tem dependências externas no Mono ou no Xamarin.Mac, ele é um executável totalmente autocontido.

A linha de comando especificou manualmente o arquivo demachine.config a ser usado e um arquivo de configuração de mapeamento de biblioteca em todo o sistema. Eles não são necessários para todos os aplicativos, mas é conveniente agrupá-los, pois eles são usados quando você usa mais recursos do .NET

Builds sem projeto

Você não precisa de um projeto completo para criar um aplicativo Xamarin.Mac autocontido. Você também pode usar makefiles unix simples para fazer o trabalho. O exemplo a seguir mostra como você pode configurar um makefile para um aplicativo de linha de comando simples:

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

O acima Makefile fornece três destinos:

  • make criará o programa
  • make run criará e executará o programa no diretório atual
  • make bundle criará um executável autossuficiível