Publicera .NET-appar för macOS

Publicering av .NET-program för macOS kräver flera ytterligare steg jämfört med andra plattformar, på grund av Apples säkerhetskrav.

Förutsättningar

Kontrollera att du har följande innan du publicerar .NET-programmet för macOS:

• Apple Developer-konto: Krävs för kodsignering och notarisering.
• Xcode-kommandoradsverktyg: Tillhandahåller codesign, altooloch andra verktyg.
• .NET SDK: Kontrollera att du har den senaste .NET SDK:en installerad.

Skapa din app med hjälp av .NET SDK

Använd någon av metoderna som beskrivs i publiceringsöversikten för .NET-program för att skapa ett program. Du kan skapa antingen ett ramverksberoende eller fristående program.

Signera och publicera din app

Använd Apples utvecklardokumentation för att signera och notarisera appens interna binärfiler. .NET skapar en intern körbar apphost som startpunkt för din app. Den här appvärden måste vara signerad och om din app använder särskilda funktioner måste den tilldelas lämpliga rättigheter.

Rättigheter för appar som inte har utgivits som Native AOT

För appar som inte har publicerats som Native AOT krävs rättigheten com.apple.security.cs.allow-jit .

Rättigheter för appar som publicerats som Native AOT

För appar som publicerats som Native AOT behövs inga behörigheter.

Valfria rättigheter för felsökning och diagnostik

Följande rättigheter aktiverar ytterligare felsöknings- och diagnostikfunktioner:

• com.apple.security.get-task-allow: Behövs för dumpsamling med createdump och dotnet dump.
• com.apple.security.cs.debugger: Krävs för att koppla ett felsökningsprogram till processen.

Universella binärer

macOS stöder universella binärfiler: en enda Mach-O fil som innehåller datorkod för mer än en CPU-arkitektur. macOS väljer den del som motsvarar den aktuella processorn, så en fil körs direkt på både Apple Silicon-datorer (arm64) och på Intel-datorer (x64).

.NET skapar inte universella binärfiler direkt. I stället publicerar du appen en gång per arkitektur och sammanfogar de två inbyggda körbara objekten med Apple-verktyget lipo . Två .NET publiceringslägen skapar en fristående intern körbar fil som du kan sammanfoga på följande sätt:

• Appar i en enda fil (PublishSingleFile)
• Native AOT-distribution (PublishAot)

Publicera en universell binärfil i en enda fil

Publicera appen en gång per arkitektur i separata kataloger:

dotnet publish -c Release -r osx-arm64 --self-contained true \
    -p:PublishSingleFile=true -o out/osx-arm64

dotnet publish -c Release -r osx-x64 --self-contained true \
    -p:PublishSingleFile=true -o out/osx-x64

Sammanfoga sedan de två körbara filer och signera resultatet igen:

mkdir -p out/universal
lipo -create -output out/universal/MyApp out/osx-arm64/MyApp out/osx-x64/MyApp
codesign --force --sign - out/universal/MyApp

En fristående publicering med en enskild fil bäddar in körningen, de hanterade sammansättningarna och de interna biblioteken i själva den körbara filen, så den sammanfogade filen är den fullständiga appen. Den universella binärfilen är ungefär summan av de två indata.

Kopiera eventuella återstående filer från en av de arkitekturspecifika utdatakatalogerna (till exempel appsettings.json eller filer som undantagits från paketet) intill den sammanslagna körbara filen.

Publicera en intern AOT-universell binär fil

Stegen är desamma som för en enda fil, men ersätt egenskaperna för en fil med PublishAot:

dotnet publish -c Release -r osx-arm64 -p:PublishAot=true -o out/osx-arm64
dotnet publish -c Release -r osx-x64   -p:PublishAot=true -o out/osx-x64

mkdir -p out/universal
lipo -create -output out/universal/MyApp out/osx-arm64/MyApp out/osx-x64/MyApp
codesign --force --sign - out/universal/MyApp

Native AOT ger mycket mindre utdatafiler än publicering som en enda fil, så den universella binärfilen förblir också liten.

Intern AOT genererar också ett MyApp.dSYM paket med felsökningssymboler per arkitektur. Om du vill behålla symboler för båda segmenten behåller du katalogerna per arkitektur eller sammanfogar DWARF binärfilerna i paketen med lipo.