Migrazione della app di esempio Photo Editor UWP tramite Windows App SDK (C++/WinRT)

Questo argomento è uno studio di caso sull'adozione dell'applicazione di esempio C++/WinRT UWP Photo Editor e della sua migrazione al Windows App SDK.

• Inizia a clonare il repository dell'app di esempio UWP e aprire la soluzione in Visual Studio.

Installare gli strumenti per il Windows App SDK

Per configurare il computer di sviluppo, vedere Installare gli strumenti per Windows App SDK.

Creare un nuovo project

• In Visual Studio creare un nuovo progetto C++/WinRT dal modello di progetto App vuota WinUI (in pacchetto ). Assegna un nome al progetto PhotoEditor, deseleziona Posiziona soluzione e progetto nella stessa directory. Puoi specificare come destinazione la versione più recente (non l'anteprima) del sistema operativo client.

Ordine in cui verrà eseguita la migrazione del codice

MainPage è un elemento importante e significativo dell'app. Ma se iniziassimo con la migrazione di quella versione, ci accorgeremmo presto che MainPage ha una dipendenza dalla vista DetailPage; e che DetailPage ha una dipendenza dal modello Photo. Pertanto, per questa procedura dettagliata adotteremo questo approccio.

• Inizieremo a copiare i file asset.
• Si eseguirà quindi la migrazione del modello Photo.
• Successivamente eseguiremo la migrazione della classe App (perché richiede un'aggiunta di alcuni membri da cui dipenderanno DetailPage e MainPage).
• Si inizierà quindi a eseguire la migrazione delle visualizzazioni, a partire prima da DetailPage.
• E alla fine si eseguirà la migrazione della visualizzazione MainPage .

Verranno copiati interi file del codice sorgente

In questa procedura dettagliata verrà eseguita la copia dei file di codice sorgente usando File Explorer. Se si preferisce copiare i contenuti dei file, vedere quindi l'Appendice: copia dei contenuti dei file del modello Foto alla fine di questo argomento per un esempio di come è possibile eseguire questa operazione per Foto (ed è quindi possibile applicare una procedura simile ad altri tipi nel progetto). Questa opzione comporta però molti più passaggi.

Copiare i file di asset

1. Nel clone del project di origine, in File Explorer individuare la cartella Windows-appsample-photo-editor>PhotoEditor>Assets. In questa cartella sono disponibili otto file di asset. Selezionare questi otto file e copiarli negli Appunti.

2. Anche in File Explorer, è possibile individuare la cartella corrispondente nel progetto di destinazione che hai creato. Il percorso della cartella è PhotoEditor>PhotoEditor>Assets. Incollare nella cartella i file di asset appena copiati e accettare la richiesta di sostituire i sette file già esistenti nella destinazione.

3. Nel progetto di destinazione in Visual Studio, in Solution Explorer, espandere la cartella Assets. Aggiungere alla cartella il file di risorsa esistente bg1.png appena incollato. È possibile posizionare il puntatore del mouse sui file di asset. Verrà visualizzata un'anteprima per ognuna, confermando di aver sostituito o aggiunto correttamente i file di asset.

Eseguire la migrazione del modello Photo

Photo è una classe di runtime che rappresenta una foto. Si tratta di un modello (nel senso di modelli, visualizzazioni e modelli di visualizzazione).

Copiare i file di codice sorgente Photo

1. Nel clone del project di origine, in File Explorer individuare la cartella Windows-appsample-photo-editor>PhotoEditor. Nelle cartella ci saranno i tre file di codice sorgente Photo.idl, Photo.he Photo.cpp; questi file implementano insieme la classe di runtime Photo. Selezionare questi tre file e copiarli negli Appunti.

2. In Visual Studio fare clic con il pulsante destro del mouse sul nodo project di destinazione e scegliere Apri cartella in File Explorer. Verrà aperta la cartella project di destinazione in File Explorer. Incollare nella cartella i tre file appena copiati.

3. Torna a Solution Explorer, con il nodo del progetto di destinazione selezionato, assicurati che Mostra tutti i file sia attivato. Fare clic con il pulsante destro del mouse sui tre file appena incollati e scegliere Include in Project. Disattivare Mostra tutti i file.

4. Nel progetto di origine, in Solution Explorer, Photo.h e .cpp sono annidati in Photo.idl per indicare che vengono generati da (da cui dipendono). Se ti piace questa disposizione, puoi eseguire la stessa operazione nel project di destinazione modificando manualmente \PhotoEditor\PhotoEditor\PhotoEditor\PhotoEditor.vcxproj (dovrai prima Save All in Visual Studio). Trova quanto segue:

   <ClInclude Include="Photo.h" />
   

   E sostituirlo con questo:

   <ClInclude Include="Photo.h">
     <DependentUpon>Photo.idl</DependentUpon>
   </ClInclude>
   

   Ripetere questa operazione per Photo.cpp e salvare e chiudere il file di project. Quando si riporta il focus su Visual Studio, fare clic su Ricarica.

Eseguire la migrazione del codice sorgente di Photo

1. In Photo.idlcercare il nome Windows.UI.Xaml dello spazio dei nomi (ovvero lo spazio dei nomi per XAML UWP) e modificarlo in Microsoft.UI.Xaml (ovvero lo spazio dei nomi per XAML winUI 3).

2. In Photo.cpp, aggiungere #include "Photo.g.cpp" alle direttive include esistenti, immediatamente dopo #include "Photo.h". Si tratta di una delle differenze di cui bisogna essere a conoscenza tra il nome delle cartelle e dei file (C++/WinRT) nei progetti UWP e Windows App SDK.

3. Eseguire la seguente ricerca/sostituzione (distinzione maiuscole/minuscole e parola intera) nel contenuto di tutto il codice sorgente nei file appena copiati e incollati.

   • Windows::UI::Xaml =>Microsoft::UI::Xaml

4. Da pch.h nel project di origine copiare gli elementi seguenti e incollarli in pch.h nel project di destinazione. Si tratta di un sottinsieme dei file di intestazione inclusi nel progetto di origine; queste sono solo le intestazioni necessarie per supportare il codice che abbiamo migrato finora.

   #include <winrt/Microsoft.UI.Xaml.Media.Imaging.h>
   #include <winrt/Windows.Storage.h>
   #include <winrt/Windows.Storage.FileProperties.h>
   #include <winrt/Windows.Storage.Streams.h>
   

5. Ora conferma di poter compilare la soluzione target (ma non eseguirla ancora).

Migrazione della classe App

Non sono necessarie modifiche al App.idl e al App.xaml del progetto di destinazione. È tuttavia necessario modificare App.xaml.h e App.xaml.cpp per aggiungere alcuni nuovi membri alla classe App . Questa operazione verrà eseguita in modo da consentire la compilazione dopo ogni sezione (ad eccezione dell'ultima, che riguarda App::OnLaunched).

Rendere disponibile l'oggetto finestra principale

In questo passaggio verrà apportata la modifica illustrata in Change Windows.UI.Xaml.Window.Current in App.Window.

Nel progetto di destinazione, App archivia l'oggetto finestra principale nel suo membro dati privato window. Più avanti nel processo di migrazione (quando si esegue la migrazione dell'uso del progetto di origine di Window.Current), sarà utile se tale membro dati window è statico ed è anche reso disponibile tramite una funzione di accesso. Queste modifiche verranno quindi apportate successivamente.

• Poiché stiamo rendendo statica la finestra, sarà necessario inizializzarla in App.xaml.cpp invece che tramite l'inizializzatore di membro predefinito attualmente in uso da parte del codice. Ecco l'aspetto di queste modifiche in App.xaml.h e App.xaml.cpp.

  // App.xaml.h
  ...
  struct App : AppT<App>
  {
       ...
       static winrt::Microsoft::UI::Xaml::Window Window(){ return window; };
  
  private:
       static winrt::Microsoft::UI::Xaml::Window window;
  };
  ...
  
  // App.xaml.cpp
  ...
  winrt::Microsoft::UI::Xaml::Window App::window{ nullptr };
  ...
  

App::OnNavigationFailed

L'app di esempio Photo Editor utilizza la logica di spostamento per spostarsi tra MainPage e DetailPage. Per ulteriori informazioni sulle app Windows App SDK che necessitano di navigazione (e quelle che non lo fanno), vedi Ho bisogno di implementare la navigazione tra le pagine?.

I membri di cui verrà eseguita la migrazione nelle prossime sezioni esistono tutti per supportare lo spostamento all'interno dell'app.

1. Per iniziare, eseguire la migrazione del gestore eventi OnNavigationFailed . Copiare la dichiarazione e la definizione della funzione membro dal project di origine e incollarla nel project di destinazione (in App.xaml.h e App.xaml.cpp).

2. Nel codice incollato in App.xaml.h, modificare Windows::UI::Xaml in Microsoft::UI::Xaml.

App::CreateRootFrame

1. L'project di origine contiene una funzione helper denominata App::CreateRootFrame. Copiare la dichiarazione e la definizione della funzione helper dal project di origine e incollarla nel project di destinazione (in App.xaml.h e App.xaml.cpp).

2. Nel codice incollato in App.xaml.h, modificare Windows::UI::Xaml in Microsoft::UI::Xaml.

3. Nel codice che hai incollato in App.xaml.cpp, modifica le due occorrenze di Window::Current() in window (che è il nome del membro dati della classe App che abbiamo visto in precedenza).

App::OnLaunched

Il project di destinazione contiene già un'implementazione del gestore eventi OnLaunched. Il parametro è un riferimento costante a un Microsoft::UI::Xaml::LaunchActivatedEventArgs, che è corretto per il Windows App SDK (a differenza del project di origine, che usa Windows::ApplicationModel::Activation::LaunchActivatedEventArgs, che è corretto per la piattaforma UWP.

• È sufficiente unire le due definizioni (origine e destinazione) di OnLaunched in modo che App::OnLaunched in App.xaml.cpp nel project di destinazione sia simile all'elenco seguente. Tenere presente che usa window (invece di Window::Current(), come la versione UWP).

  void App::OnLaunched(LaunchActivatedEventArgs const&)
  {
       window = make<MainWindow>();
  
       Frame rootFrame = CreateRootFrame();
       if (!rootFrame.Content())
       {
           rootFrame.Navigate(xaml_typename<PhotoEditor::MainPage>());
       }
  
       window.Activate();
  }
  

Il codice precedente fornisce ad App una dipendenza da MainPage, quindi non sarà possibile compilare da questo punto fino a quando non sarà stata eseguita la migrazione di DetailPage e poi di MainPage. Quando saremo in grado di costruire di nuovo, lo comunicheremo.

Migrazione della visualizzazione DetailPage

DetailPage è la classe che rappresenta la pagina dell'editor di foto, in cui gli effetti Win2D vengono attivati, impostati e concatenati. Si arriva alla pagina dell'editor di foto selezionando un'anteprima della foto in MainPage. DetailPage è una vista (nel senso di modelli, viste e modelli di visualizzazione).

Fare riferimento al pacchetto NuGet Win2D

Per supportare il codice in DetailPage, l'project di origine ha una dipendenza da Microsoft.Graphics.Win2D. Sarà quindi necessaria anche una dipendenza da Win2D nel project di destinazione.

• Nella soluzione di destinazione in Visual Studio fare clic su Tools>NuGet Package Manager>Gestisci pacchetti NuGet per la soluzione... >Browse. Verificare che Includi versione preliminare sia deselezionato, quindi digitare o incollare Microsoft.Graphics.Win2D nella casella di ricerca. Selezionare l'elemento corretto nei risultati della ricerca, controllare PhotoEditor project e fare clic su Installa per installare il pacchetto.

Copiare i file del codice sorgente DetailPage

1. Nel clone del project di origine, in File Explorer individuare la cartella Windows-appsample-photo-editor>PhotoEditor. Nella cartella sono disponibili i quattro file di codice sorgente DetailPage.idl, DetailPage.xaml, DetailPage.h e DetailPage.cpp; questi file implementano insieme la visualizzazione DetailPage. Selezionare questi quattro file e copiarli negli Appunti.

2. In Visual Studio fare clic con il pulsante destro del mouse sul nodo project di destinazione e scegliere Apri cartella in File Explorer. Verrà aperta la cartella project di destinazione in File Explorer. Incollare nella cartella i quattro file appena copiati.

3. Sempre in File Explorer, modificare rispettivamente i nomi di DetailPage.h e DetailPage.cpp in DetailPage.xaml.h e DetailPage.xaml.cpp. Si tratta di una delle differenze di cui bisogna essere a conoscenza tra il nome delle cartelle e dei file (C++/WinRT) nei progetti UWP e Windows App SDK.

4. Torna a Solution Explorer, con il nodo del progetto di destinazione selezionato, assicurati che Mostra tutti i file sia attivato. Fare clic con il pulsante destro del mouse sui quattro file appena incollati (e rinominati) e scegliere Include In Project. Disattivare Mostra tutti i file.

5. Nel progetto di origine, in Solution ExplorerDetailPage.idl è annidato in DetailPage.xaml. Se ti piace questa disposizione, puoi eseguire la stessa operazione nel project di destinazione modificando manualmente \PhotoEditor\PhotoEditor\PhotoEditor\PhotoEditor.vcxproj (dovrai prima Save All in Visual Studio). Trova quanto segue:

   <Midl Include="DetailPage.idl" />
   

   E sostituirlo con questo:

   <Midl Include="DetailPage.idl">
     <DependentUpon>DetailPage.xaml</DependentUpon>
   </Midl>
   

Salvare e chiudere il file project. Quando si riporta il focus su Visual Studio, fare clic su Ricarica.

Migrazione del codice sorgente DetailPage

1. In DetailPage.idl, cercare Windows.UI.Xaml e modificarlo in Microsoft.UI.Xaml.

2. In DetailPage.xaml.cpp, modificare #include "DetailPage.h" in #include "DetailPage.xaml.h".

3. Immediatamente sotto, aggiungere #include "DetailPage.g.cpp".

4. Per la chiamata al metodo statico App::Window (che stiamo per aggiungere) per la compilazione, sempre in DetailPage.xaml.cpp, aggiungere #include "App.xaml.h" immediatamente prima di #include "Photo.h".

5. Eseguire la ricerca/sostituzione seguente (distinzione maiuscole/minuscole e parola intera) nel contenuto del codice sorgente nei file appena copiati e incollati.

   • In DetailPage.xaml.h e .xaml.cpp, Windows::UI::Composition =>Microsoft::UI::Composition
   • In DetailPage.xaml.h e .xaml.cpp, Windows::UI::Xaml =>Microsoft::UI::Xaml
   • In DetailPage.xaml.cpp, Window::Current() =>App::Window()

6. Da pch.h nel project di origine copiare gli elementi seguenti e incollarli in pch.h nel project di destinazione.

   #include <winrt/Windows.Graphics.Effects.h>
   #include <winrt/Microsoft.Graphics.Canvas.Effects.h>
   #include <winrt/Microsoft.Graphics.Canvas.UI.Xaml.h>
   #include <winrt/Microsoft.UI.Composition.h>
   #include <winrt/Microsoft.UI.Xaml.Input.h>
   #include <winrt/Windows.Graphics.Imaging.h>
   #include <winrt/Windows.Storage.Pickers.h>
   

7. Inoltre, nella parte superiore di pch.h, subito dopo #pragma once, aggiungere questo:

   // This is required because we are using std::min and std::max, otherwise 
   // we have a collision with min and max macros being defined elsewhere.
   #define NOMINMAX
   

Non è ancora possibile eseguire la compilazione, ma lo sarà dopo avere eseguito la migrazione di MainPage (l'operazione successiva).

Migrazione della visualizzazione MainPage

La pagina principale dell'app rappresenta la visualizzazione che compare per prima quando si esegue l'app. È la pagina che carica le foto dalla Raccolta di immagini e mostra una vista in miniatura disposta a mosaico.

Copiare i file del codice sorgente MainPage

1. Analogamente a quanto fatto con DetailPage, copiare ora MainPage.idl, MainPage.xaml, MainPage.h e MainPage.cpp.

2. Rinominare i file .h e .cpp in .xaml.h e in .xaml.cpp, rispettivamente.

3. Includere tutti e quattro i file nel progetto di destinazione come fatto prima.

4. Nel progetto di origine, in Solution ExplorerMainPage.idl è annidato in MainPage.xaml. Se si preferisce questa disposizione, è possibile eseguire la stessa operazione nel project di destinazione modificando manualmente \PhotoEditor\PhotoEditor\PhotoEditor\PhotoEditor.vcxproj. Trova quanto segue:

   <Midl Include="MainPage.idl" />
   

   Sostituire tale riga con:

   <Midl Include="MainPage.idl">
     <DependentUpon>MainPage.xaml</DependentUpon>
   </Midl>
   

Migrazione del codice sorgente MainPage

1. In MainPage.idl, cerca Windows.UI.Xaml e modifica entrambe le occorrenze in Microsoft.UI.Xaml.

2. In MainPage.xaml.cpp, modificare #include "MainPage.h" in #include "MainPage.xaml.h".

3. Immediatamente sotto, aggiungere #include "MainPage.g.cpp".

4. Per la chiamata al metodo statico App::Window (che stiamo per aggiungere) per la compilazione, sempre in MainPage.xaml.cpp, aggiungere #include "App.xaml.h" immediatamente prima di #include "Photo.h".

Per il passaggio successivo, verrà apportata la modifica illustrata in ContentDialog e Popup.

5. Quindi, sempre in MainPage.xaml.cpp, nel metodo MainPage::GetItemsAsync , subito dopo la riga ContentDialog unsupportedFilesDialog{};, aggiungere questa riga di codice.

   unsupportedFilesDialog.XamlRoot(this->Content().XamlRoot());
   

6. Eseguire la ricerca/sostituzione seguente (distinzione maiuscole/minuscole e parola intera) nel contenuto del codice sorgente nei file appena copiati e incollati.

   • In MainPage.xaml.h e .xaml.cpp, Windows::UI::Composition =>Microsoft::UI::Composition
   • In MainPage.xaml.h e .xaml.cpp, Windows::UI::Xaml =>Microsoft::UI::Xaml
   • In MainPage.xaml.cpp, Window::Current() =>App::Window()

7. Da pch.h nel project di origine copiare gli elementi seguenti e incollarli in pch.h nel project di destinazione.

   #include <winrt/Microsoft.UI.Xaml.Hosting.h>
   #include <winrt/Microsoft.UI.Xaml.Media.Animation.h>
   #include <winrt/Windows.Storage.Search.h>
   

A questo punto, verificare che sia possibile compilare la soluzione di destinazione (ma non eseguirla ancora).

Aggiornamento di MainWindow

1. In MainWindow.xamleliminare StackPanel e il relativo contenuto, perché non è necessaria alcuna interfaccia utente in MainWindow. In questo modo viene lasciato solo l'elemento Window vuoto.

2. In MainWindow.idl, eliminare il segnaposto Int32 MyProperty;, lasciando solo il costruttore.

3. In MainWindow.xaml.h e MainWindow.xaml.cpp, eliminare le dichiarazioni e le definizioni del segnaposto MyProperty e myButton_Click, lasciando solo il costruttore.

Modifiche alla migrazione necessarie a causa della differenza nel modello di threading

Le due modifiche in questa sezione sono necessarie a causa di una differenza del modello di threading tra UWP e Windows App SDK, come descritto in ASTA al modello di threading STA. Di seguito sono riportate brevi descrizioni delle cause dei problemi e quindi un modo per risolverli.

Pagina Principale

MainPage carica i file di immagine dalla cartella Pictures, chiama StorageItemContentProperties.GetImagePropertiesAsync per ottenere le proprietà del file di immagine, crea un oggetto modello Photo per ogni file di immagine (salvando le stesse proprietà in un membro dati), e aggiunge tale oggetto Photo a un insieme. La raccolta degli oggetti Photo è associata a dati di un GridView nell'interfaccia utente. Per conto di tale GridView, MainPage gestisce l'evento ContainerContentChanging, e per la fase 1, il gestore chiama una coroutine che invoca StorageFile.GetThumbnailAsync. Questa chiamata a GetThumbnailAsync comporta il pumping dei messaggi (non viene restituita immediatamente ed esegue tutte le operazioni asincrone) e ciò causa la reentrancy. Il risultato è che la GridView ha la raccolta di Elementi cambiata mentre si sta applicando il layout, provocando un arresto anomalo.

Se si commenta la chiamata a StorageItemContentProperties::GetImagePropertiesAsync, non si verifica l'errore. Ma la vera correzione consiste nel rendere la chiamata StorageFile.GetThumbnailAsync esplicitamente asincrona attendendo cooperativamente wil::resume_foreground subito prima di chiamare GetThumbnailAsync. Ciò funziona perché wil::resume_foreground pianifica il codice che lo segue per essere un'attività in DispatcherQueue.

Ecco il codice da modificare:

// MainPage.xaml.cpp
IAsyncAction MainPage::OnContainerContentChanging(ListViewBase sender, ContainerContentChangingEventArgs args)
{
    ...
    if (args.Phase() == 1)
    {
        ...
        try
        {
            co_await wil::resume_foreground(this->DispatcherQueue());
            auto thumbnail = co_await impleType->GetImageThumbnailAsync(this->DispatcherQueue());
            image.Source(thumbnail);
        }
        ...
    }
}

Foto

La proprietà Photo::ImageTitle è associata ai dati dell'interfaccia utente, quindi l'interfaccia utente chiama la funzione di accesso per quella proprietà ogni volta che ha bisogno del suo valore. Tuttavia, quando si tenta di accedere a ImageProperties.Title da tale funzione di accesso nel thread dell'interfaccia utente, otteniamo una violazione di accesso.

È quindi possibile accedere a Title una sola volta dal costruttore di Photo e memorizzarlo nel membro dati m_imageName se non è vuoto. Nella funzione di accesso Photo::ImageTitle è sufficiente accedere al membro dati m_imageName.

Ecco il codice da modificare:

// Photo.h
...
Photo(Photo(Windows::Storage::FileProperties::ImageProperties const& props,
    ...
    ) : ...
{
    if (m_imageProperties.Title() != L"")
    {
        m_imageName = m_imageProperties.Title();
    }
}
...
hstring ImageTitle() const
{
    return m_imageName;
}
...

Queste sono le ultime modifiche che è necessario apportare per eseguire la migrazione dell'app di esempio Photo Editor. Nella sezione Testare l'app migrata si verificherà che siano stati eseguiti correttamente i passaggi.

Problemi noti

Problema del tipo di app (influisce solo sull'anteprima 3)

Se è stato seguito questo case study usando il modello di project da VSIX per Windows App SDK version 1.0 Preview 3, sarà necessario apportare una piccola correzione a PhotoEditor.vcxproj. Ecco come farlo.

In Visual Studio, in Solution Explorer fare clic con il pulsante destro del mouse sul nodo project e scegliere Unload Project. Ora PhotoEditor.vcxproj è aperto per la modifica. Come primo elemento figlio di Project, aggiungere un elemento PropertyGroup simile al seguente:

<Project ... >
    <PropertyGroup>
        <EnableWin32Codegen>true</EnableWin32Codegen>
    </PropertyGroup>
    <Import ... />
...

Salvare e chiudere PhotoEditor.vcxproj. Fare clic con il pulsante destro del mouse sul nodo del progetto e scegliere Ricarica Progetto. Ricompilare ora il project.

Testare l'app migrata

Compilare ora il project ed eseguire l'app per testarla. Selezionare un'immagine, impostare un livello di zoom, scegliere gli effetti e configurarli.

Appendice: copia dei contenuti dei file del modello Photo

Come accennato in precedenza, hai la possibilità di copiare i file del codice sorgente stessi o i relativi contenuti. Abbiamo già mostrato come copiare gli stessi file del codice sorgente. In questa sezione viene quindi illustrato un esempio di copia dei contenuti del file.

Nel project di origine in Visual Studio individuare la cartella PhotoEditor (Windows universale)>Models. La cartella contiene i file Photo.idl, Photo.h e Photo.cpp, che insieme implementano la classe di runtime Photo.

Aggiungere l'IDL e generare stub

Nel progetto di destinazione in Visual Studio, aggiungi un nuovo elemento Midl File (.idl) al progetto. Denominare il nuovo elemento Photo.idl. Eliminare i contenuti predefiniti di Photo.idl.

Dal project di origine in Visual Studio copiare il contenuto di Models>Photo.idl e incollarli nel file Photo.idl appena aggiunto al project di destinazione. Nel codice incollato, cercare Windows.UI.Xaml e modificarlo in Microsoft.UI.Xaml.

Salva il file.

Ora compilate la soluzione di destinazione. Anche se non verrà completata, la compilazione è necessaria ora perché genererà i file di codice sorgente (stub) necessari per iniziare l'implementazione del modello Photo.

In Visual Studio fare clic con il pulsante destro del mouse sul nodo project di destinazione e scegliere Apri cartella in File Explorer. Verrà aperta la cartella project di destinazione in File Explorer. Qui, passare alla cartella Generated Files\sources (in modo che ci si trovi in \PhotoEditor\PhotoEditor\PhotoEditor\Generated Files\sources). Copiare i file stub Photo.h e .cpp e incollarli nella cartella di progetto, che è ora su di due livelli di cartelle in \PhotoEditor\PhotoEditor\PhotoEditor.

Torna a Solution Explorer, con il nodo del progetto di destinazione selezionato, assicurati che Mostra tutti i file sia attivato. Fare clic con il pulsante destro del mouse sui file stub appena incollati (Photo.h e .cpp) e scegliere Include in Project. Disattivare Mostra tutti i file.

Vedrai static_assert nella parte superiore di Photo.h e .cpp, che dovrai rimuovere.

Verificare che sia nuovamente possibile la compilazione (ma non ancora l'esecuzione).

Migrazione del codice negli stub

Copiare il contenuto di Photo.h e .cpp dal project di origine nel project di destinazione.

Da qui, i passaggi rimanenti per eseguire la migrazione del codice copiato sono uguali a quelli indicati nella sezione Migrazione del codice sorgente di Photo.

Argomenti correlati

• Windows App SDK e versioni di Windows supportate
• App di esempio Photo Editor UWP
• Strategia di migrazione globale
• Mappatura delle API UWP nel Windows App SDK
• migrazione di WinUI