Sviluppo con pacchetti di asset e riduzione dei pacchettiDeveloping with asset packages and package folding

Importante

Se si prevede di inviare l'app allo Store, è necessario contattare il supporto tecnico Windows Developer e ottenere l'approvazione per usare i pacchetti di asset e la riduzione dei pacchetti.If you intend to submit your app to the Store, you need to contact Windows developer support and get approval to use asset packages and package folding.

I pacchetti di asset possono ridurre le dimensioni complessive del pacchetto e l'ora di pubblicazione per le app nello Store.Asset packages can decrease the overall packaging size and publishing time for your apps to the Store. Per altre informazioni sui pacchetti di asset e su come è possibile velocizzare le iterazioni di sviluppo, vedere Introduzione ai pacchetti di asset.You can learn more about asset packages and how it can speed up your development iterations at Introduction to asset packages.

Se si sta pensando di usare i pacchetti di asset per l'app o si è già a conoscenza del fatto che si vuole usarlo, è probabile che si stiano chiedendo in che modo i pacchetti Asset modificheranno il processo di sviluppo.If you are thinking about using asset packages for your app or already know that you want to use it, then you are probably wondering about how asset packages will change your development process. In breve, lo sviluppo di app per l'utente rimane invariato, a causa della riduzione del pacchetto per i pacchetti di asset.In short, app development for you stays the same - this is possible because of package folding for asset packages.

Accesso ai file dopo la suddivisione dell'appFile access after splitting your app

Per comprendere il modo in cui la riduzione dei pacchetti non influisca sul processo di sviluppo, è possibile risalire prima di tutto per capire cosa accade quando si suddivide l'app in più pacchetti (con pacchetti di asset o pacchetti di risorse).To understand how package folding doesn’t impact your development process, let’s step back first to understand what happens when you split your app into multiple packages (with either asset packages or resource packages).

A un livello elevato, quando si suddividono alcuni file dell'app in altri pacchetti (che non sono pacchetti di architettura), non sarà possibile accedere a tali file direttamente rispetto alla posizione in cui viene eseguito il codice.At a high level, when you split some of your app’s files into other packages (that are not architecture packages), you will not be able to access those files directly relative to where your code runs. Questo è dovuto al fatto che i pacchetti vengono installati in directory diverse da cui viene installato il pacchetto dell'architettura.This is because these packages are all installed into different directories from where your architecture package is installed. Se, ad esempio, si sta creando un gioco e il gioco è localizzato in francese e tedesco ed è stato compilato per computer x86 e x64, è necessario disporre di questi file del pacchetto dell'app all'interno del bundle dell'app del gioco:For example, if you’re making a game and your game is localized into French and German and you built for both x86 and x64 machines, then you should have these app package files within the app bundle of your game:

  • MyGame_1 MyGame_1.0_x86. appxMyGame_1.0_x86.appx
  • MyGame_1 MyGame_1.0_x64. appxMyGame_1.0_x64.appx
  • MyGame_1 MyGame_1.0_language-fr. appxMyGame_1.0_language-fr.appx
  • MyGame_1 MyGame_1.0_language-de. appxMyGame_1.0_language-de.appx

Quando il gioco viene installato nel computer di un utente, ogni file del pacchetto dell'app avrà una propria cartella nella directory WindowsAppsWhen your game is installed to a user’s machine, each app package file will have its own folder in the WindowsApps directory. Quindi, per un utente francese che esegue Windows a 64 bit, il gioco sarà simile al seguente:So for a French user running 64-bit Windows, your game will look like this:

C:\Program Files\WindowsApps\
|-- MyGame_1.0_x64
|   `-- …
|-- MyGame_1.0_language-fr
|   `-- …
`-- …(other apps)

Si noti che i file del pacchetto dell'app che non sono applicabili all'utente non verranno installati (i pacchetti x86 e tedesco).Note that the app package files that are not applicable to the user will not be installed (the x86 and German packages).

Per questo utente, il file eseguibile principale del gioco si troverà all'interno della cartella MyGame_1.0_x64 e, in genere, potrà accedere ai file all'interno della cartella.For this user, your game’s main executable will be within the MyGame_1.0_x64 folder and will run from there, and normally, it will only have access to the files within this folder. Per accedere ai file nella cartella MyGame_1.0_language-fr , è necessario usare le API MRT o le API PackageManager.In order to access the files in the MyGame_1.0_language-fr folder, you would have to use either the MRT APIs or the PackageManager APIs. Le API MRT possono selezionare automaticamente il file più appropriato dalle lingue installate. è possibile trovare altre informazioni sulle API MRT in Windows. ApplicationModel. resources. Core.The MRT APIs can automatically select the most appropriate file from the languages installed, you can find out more about MRT APIs at Windows.ApplicationModel.Resources.Core. In alternativa, è possibile trovare il percorso installato del pacchetto in lingua francese usando la classe PackageManager.Alternatively, you can find the installed location of the French language package using the PackageManager Class. Si consiglia di non presupporre il percorso di installazione dei pacchetti dell'app perché può cambiare e può variare tra gli utenti.You should never assume the installed location of the packages of your app since this can change and can vary between users.

Riduzione del pacchetto di assetAsset package folding

In che modo è possibile accedere ai file nei pacchetti di asset?So how can you access the files in your asset packages? È possibile continuare a usare le API di accesso ai file in uso per accedere a qualsiasi altro file nel pacchetto dell'architettura.Well, you can continue to use the file access APIs you are using to access any other file in your architecture package. Il motivo è che i file dei pacchetti di asset verranno ridotti nel pacchetto di architettura quando viene installato tramite il processo di riduzione del pacchetto.This is because asset package files will be folded into your architecture package when it is installed through the package folding process. Inoltre, dal momento che i file del pacchetto di asset devono essere originariamente file all'interno dei pacchetti di architettura, questo significa che non è necessario modificare l'utilizzo dell'API quando si passa dalla distribuzione di file separati alla distribuzione in pacchetto nel processo di sviluppo.Furthermore, since asset package files should originally be files within your architecture packages, this means that you would not have to change API usage when you move from loose files deployment to packaged deployment in your development process.

Per comprendere meglio il funzionamento della riduzione dei pacchetti, iniziamo con un esempio.To understand more about how package folding works, let’s start with an example. Se si dispone di un progetto di gioco con la struttura di file seguente:If you have a game project with the following file structure:

MyGame
|-- Audios
|   |-- Level1
|   |   `-- ...
|   `-- Level2
|       `-- ...
|-- Videos
|   |-- Level1
|   |   `-- ...
|   `-- Level2
|       `-- ...
|-- Engine
|   `-- ...
|-- XboxLive
|   `-- ...
`-- Game.exe

Per suddividere il gioco in 3 pacchetti: un pacchetto di architettura x64, un pacchetto di asset per audio e un pacchetto di asset per i video, il gioco verrà suddiviso in questi pacchetti:If you want to split your game into 3 packages: an x64 architecture package, an asset package for audios, and an asset package for videos, your game will be divided into these packages:

MyGame_1.0_x64.appx
|-- Engine
|   `-- ...
|-- XboxLive
|   `-- ...
`-- Game.exe
MyGame_1.0_Audios.appx
`-- Audios
    |-- Level1
    |   `-- ...
    `-- Level2
        `-- ...
MyGame_1.0_Videos.appx
`-- Videos
    |-- Level1
    |   `-- ...
    `-- Level2
        `-- ...

Quando si installa il gioco, il pacchetto x64 verrà distribuito per primo.When you install your game, the x64 package will be deployed first. I due pacchetti di asset verranno comunque distribuiti nelle rispettive cartelle, proprio come MyGame_1.0_language-fr dell'esempio precedente.Then the two asset packages will still be deployed to their own folders, just like MyGame_1.0_language-fr from our previous example. Tuttavia, a causa della riduzione del pacchetto, anche i file del pacchetto di asset saranno collegati in modo da essere visualizzati nella cartella MyGame_1.0_x64 (pertanto, anche se i file vengono visualizzati in due posizioni, non si occupino del doppio dello spazio su disco).However, because of package folding, the asset package files will also be hard linked to appear in the MyGame_1.0_x64 folder (so even though the files appear in two locations, they do not take up twice the disk space). Il percorso in cui verranno visualizzati i file del pacchetto di asset è esattamente il percorso in cui si trovano rispetto alla radice del pacchetto.The location in which the asset package files will appear in is exactly the location that they are at relative to the root of the package. Ecco quindi il layout finale del gioco distribuito:So here’s what the final layout of the deployed game will look like:

C:\Program Files\WindowsApps\
|-- MyGame_1.0_x64
|   |-- Audios
|   |   |-- Level1
|   |   |   `-- ...
|   |   `-- Level2
|   |       `-- ...
|   |-- Videos
|   |   |-- Level1
|   |   |   `-- ...
|   |   `-- Level2
|   |       `-- ...
|   |-- Engine
|   |   `-- ...
|   |-- XboxLive
|   |   `-- ...
|   `-- Game.exe
|-- MyGame_1.0_Audios
|   `-- Audios
|       |-- Level1
|       |   `-- ...
|       `-- Level2
|           `-- ...
|-- MyGame_1.0_Videos
|   `-- Videos
|       |-- Level1
|       |   `-- ...
|       `-- Level2
|           `-- ...
`-- …(other apps)

Quando si usa la riduzione del pacchetto per i pacchetti di asset, è comunque possibile accedere ai file suddivisi in pacchetti di asset nello stesso modo (si noti che la cartella Architecture ha esattamente la stessa struttura della cartella del progetto originale) ed è possibile aggiungere pacchetti di asset o spostare i file tra i pacchetti di asset senza alcun effetto sul codice.When using package folding for asset packages, you can still access the files you’ve split into asset packages the same way (notice that the architecture folder has the exact same structure as the original project folder), and you can add asset packages or move files between asset packages without impacting your code.

A questo punto, per un esempio più complesso di riduzione dei pacchetti.Now for a more complicated package folding example. Supponiamo di voler suddividere i file in base al livello e, se si vuole usare la stessa struttura della cartella del progetto originale, i pacchetti dovrebbero avere un aspetto simile al seguente:Let’s say that you want to split your files based on level instead, and if you want to keep the same structure as the original project folder, your packages should look like this:

MyGame_1.0_x64.appx
|-- Engine
|   `-- ...
|-- XboxLive
|   `-- ...
`-- Game.exe
MyGame_Level1.appx
|-- Audios
|   `-- Level1
|       `-- ...
`-- Videos
    `-- Level1
        `-- ...

MyGame_Level2.appx
|-- Audios
|   `-- Level2
|       `-- ...
`-- Videos
    `-- Level2
        `-- ...

In questo modo sarà possibile unire le cartelle e i file di Level1 nel pacchetto di MyGame_Level1 e le cartelle e i file di Level2 nel pacchetto di MyGame_Level2 nelle cartelle audio e video durante la riduzione del pacchetto.This will allow the Level1 folders and files in the MyGame_Level1 package and Level2 folders and files in the MyGame_Level2 package to be merged into the Audios and Videos folders during package folding. Pertanto, come regola generale, il percorso relativo designato per i file in pacchetto nel file di mapping o il layout di creazione dei pacchetti per MakeAppx.exe è il percorso da usare per accedere a tali file dopo la riduzione del pacchetto.So as a general rule, the relative path designated for packaged files in the mapping file or packaging layout for MakeAppx.exe is the path you should use to access them after package folding.

Infine, se sono presenti due file in pacchetti di asset diversi che hanno gli stessi percorsi relativi, questo provocherà una collisione durante la riduzione del pacchetto.Lastly, if there are two files in different asset packages that have the same relative paths, this will cause a collision during package folding. Se si verifica un conflitto, la distribuzione dell'app provocherà un errore e non riuscirà.If a collision occurs, the deployment of your app will result in an error and fail. Inoltre, dal momento che la riduzione dei pacchetti sfrutta i collegamenti reali, se si usano i pacchetti di asset, l'app non sarà distribuita in unità non NTFS.Also, because package folding takes advantage of hard links, if you do use asset packages, your app will not be able to be deployed to non-NTFS drives. Se si sa che l'app verrà probabilmente spostata in unità rimovibili dagli utenti, è consigliabile non usare i pacchetti di asset.If you know your app will likely be moved to removable drives by your users, then you should not use asset packages.