Aggiornare manualmente un'app Xamarin.Forms a un'app .NET maUI multiprogetto
L'aggiornamento di un'app multiprogetto Xamarin.Forms a un'app .NET multipiattaforma (.NET MAUI) segue gli stessi passaggi di un progetto Xamarin.Android e Xamarin.iOS, con passaggi aggiuntivi per sfruttare le modifiche apportate a .NET MAUI.
Questo articolo descrive come eseguire manualmente la migrazione di un Xamarin.Forms progetto di libreria a un progetto di libreria MAUI .NET. Prima di eseguire questa operazione, è necessario aggiornare i Xamarin.Forms progetti della piattaforma in modo che siano progetti in stile SDK. I progetti in stile SDK sono lo stesso formato di progetto usato da tutti i carichi di lavoro .NET e rispetto a molti progetti Xamarin sono molto meno dettagliato. Per informazioni sull'aggiornamento dei progetti di app, vedere Aggiornare progetti Xamarin.Android, Xamarin.iOS e Xamarin.Mac a progetti .NET, migrazione del progetto Xamarin.Android, migrazione del progetto Xamarin Apple e Xamarin.Forms migrazione del progetto UWP.
Per eseguire la migrazione di un Xamarin.Forms progetto di libreria a un progetto di libreria MAUI .NET, è necessario:
- Aggiornare l'app Xamarin.Forms per usare Xamarin.Forms 5.
- Aggiornare le dipendenze dell'app alle versioni più recenti.
- Assicurarsi che l'app funzioni ancora.
- Aggiornare il file di progetto in modo che sia in stile SDK.
- Aggiornare gli spazi dei nomi.
- Risolvere eventuali modifiche all'API.
- Configurare .NET MAUI.
- Aggiornare o sostituire dipendenze incompatibili con le versioni di .NET 8.
- Compilare e testare l'app.
Per semplificare il processo di aggiornamento, è necessario creare un nuovo progetto di libreria MAUI .NET con lo stesso nome del Xamarin.Forms progetto di libreria e quindi copiare il codice, la configurazione e le risorse. Questo è l'approccio descritto di seguito.
Aggiornare l'app Xamarin.Forms
Prima di aggiornare l'app Xamarin.Forms a .NET MAUI, è necessario aggiornare Xamarin.Forms l'app per usare Xamarin.Forms 5 e assicurarsi che funzioni ancora correttamente. È anche necessario aggiornare le dipendenze usate dall'app alle versioni più recenti.
Ciò consentirà di semplificare il resto del processo di migrazione, in quanto ridurrà al minimo le differenze api tra Xamarin.Forms e .NET MAUI e garantirà l'uso di versioni compatibili con .NET delle dipendenze, se presenti.
Crea un nuovo progetto
In Visual Studio creare un nuovo progetto di libreria di classi MAUI .NET con lo stesso nome del Xamarin.Forms progetto di libreria. Questo progetto ospiterà il codice dal Xamarin.Forms progetto di libreria. L'apertura del file di progetto consentirà di verificare di avere un progetto di tipo .NET SDK:
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFrameworks>net8.0;net8.0-android;net8.0-ios;net8.0-maccatalyst</TargetFrameworks>
<TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net8.0-windows10.0.19041.0</TargetFrameworks>
<!-- Uncomment to also build the tizen app. You will need to install tizen by following this: https://github.com/Samsung/Tizen.NET -->
<!-- <TargetFrameworks>$(TargetFrameworks);net8.0-tizen</TargetFrameworks> -->
<UseMaui>true</UseMaui>
<SingleProject>true</SingleProject>
<ImplicitUsings>enable</ImplicitUsings>
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">11.0</SupportedOSPlatformVersion>
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">13.1</SupportedOSPlatformVersion>
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">21.0</SupportedOSPlatformVersion>
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</SupportedOSPlatformVersion>
<TargetPlatformMinVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows'">10.0.17763.0</TargetPlatformMinVersion>
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'tizen'">6.5</SupportedOSPlatformVersion>
</PropertyGroup>
</Project>
Nei progetti della piattaforma aggiungere un riferimento a questo nuovo progetto di libreria. Copiare quindi i Xamarin.Forms file di libreria nel progetto di libreria MAUI .NET.
Modifiche dello spazio dei nomi
Gli spazi dei nomi sono stati modificati nel passaggio da Xamarin.Forms a MAUI .NET e Xamarin.Essentials le funzionalità fanno ora parte di .NET MAUI. Per eseguire gli aggiornamenti dello spazio dei nomi, eseguire una ricerca e sostituire per gli spazi dei nomi seguenti:
I progetti MAUI .NET usano direttive implicite global using . Questa funzionalità consente di rimuovere using le direttive per lo Xamarin.Essentials spazio dei nomi, senza doverle sostituire con gli spazi dei nomi MAUI .NET equivalenti.
Inoltre, lo spazio dei nomi XAML predefinito è passato da http://xamarin.com/schemas/2014/forms in Xamarin.Forms a http://schemas.microsoft.com/dotnet/2021/maui in .NET MAUI. Pertanto, è necessario sostituire tutte le occorrenze di xmlns="http://xamarin.com/schemas/2014/forms" con xmlns="http://schemas.microsoft.com/dotnet/2021/maui".
Nota
È possibile aggiornare Xamarin.Forms rapidamente gli spazi dei nomi in Microsoft.Maui usando azioni rapide in Visual Studio, purché sia installato Upgrade Assistant .
Modifiche API
Alcune API sono state modificate nel passaggio da Xamarin.Forms a MAUI .NET. Si tratta di diversi motivi, tra cui la rimozione di funzionalità duplicate causate dal Xamarin.Essentials fatto che fa parte di .NET MAUI e garantisce che le API seguano le linee guida per la denominazione .NET. Le sezioni seguenti illustrano queste modifiche.
Modifiche al colore
In Xamarin.Formslo Xamarin.Forms.Color struct consente di costruire Color oggetti usando double valori e di specificare colori denominati, ad esempio Xamarin.Forms.Color.AliceBlue. In .NET MAUI questa funzionalità è stata separata nella Microsoft.Maui.Graphics.Color classe e nella Microsoft.Maui.Graphics.Colors classe .
La Microsoft.Maui.Graphics.Color classe, nello spazio dei Microsoft.Maui.Graphics nomi , consente di costruire Color oggetti usando float valori, byte valori e int valori. La Microsoft.Maui.Graphics.Colors classe , che è anche nello spazio dei Microsoft.Maui.Graphics nomi , in gran parte fornisce gli stessi colori denominati. Ad esempio, usare Colors.AliceBlue per specificare il AliceBlue colore.
La tabella seguente illustra le modifiche dell'API tra lo Xamarin.Forms.Color struct e la Microsoft.Maui.Graphics.Color classe :
| Xamarin.FormsAPI | API MAUI .NET | Commento |
|---|---|---|
Xamarin.Forms.Color.R |
Microsoft.Maui.Graphics.Color.Red | |
Xamarin.Forms.Color.G |
Microsoft.Maui.Graphics.Color.Green | |
Xamarin.Forms.Color.B |
Microsoft.Maui.Graphics.Color.Blue | |
Xamarin.Forms.Color.A |
Microsoft.Maui.Graphics.Color.Alpha | |
Xamarin.Forms.Color.Hue |
Microsoft.Maui.Graphics.Color.GetHue | Xamarin.Forms la proprietà sostituita con un metodo in .NET MAUI. |
Xamarin.Forms.Color.Saturation |
Microsoft.Maui.Graphics.Color.GetSaturation | Xamarin.Forms la proprietà sostituita con un metodo in .NET MAUI. |
Xamarin.Forms.Color.Luminosity |
Microsoft.Maui.Graphics.Color.GetLuminosity | Xamarin.Forms la proprietà sostituita con un metodo in .NET MAUI. |
Xamarin.Forms.Color.Default |
Nessun equivalente di .NET MAUI. Per impostazione predefinita, invece, Microsoft.Maui.Graphics.Color gli oggetti sono null. |
|
Xamarin.Forms.Color.Accent |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Color.FromHex |
Microsoft.Maui.Graphics.Color.FromArgb | Microsoft.Maui.Graphics.Color.FromHex è obsoleto e verrà rimosso in una versione futura. |
Inoltre, tutti i valori numerici in un Microsoft.Maui.Graphics.Color sono , anziché double come usato in Xamarin.Forms.Colorfloat.
Nota
A differenza di Xamarin.Forms, un Microsoft.Maui.Graphics.Color oggetto non ha una conversione implicita in System.Drawing.Color.
Modifiche al layout
La tabella seguente elenca le API di layout che sono state rimosse nel passaggio da Xamarin.Forms a .NET MAUI:
| Xamarin.FormsAPI | API MAUI .NET | Commenti |
|---|---|---|
Xamarin.Forms.AbsoluteLayout.IAbsoluteList<T>.Add |
L'overload Add che accetta 3 argomenti non è presente in .NET MAUI. |
|
Xamarin.Forms.Grid.IGridList<T>.AddHorizontal |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Grid.IGridList<T>.AddVertical |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.RelativeLayout |
Microsoft.Maui.Controls.Compatibility.RelativeLayout | In .NET MAUI RelativeLayout esiste solo come controllo di compatibilità per gli utenti che eseguono la migrazione da Xamarin.Forms. Usare Grid invece o aggiungere per xmlns lo spazio dei nomi di compatibilità. |
Inoltre, l'aggiunta di elementi figlio a un layout nel codice in Xamarin.Forms viene eseguita aggiungendo gli elementi figlio alla raccolta del Children layout:
Grid grid = new Grid();
grid.Children.Add(new Label { Text = "Hello world" });
In .NET MAUI la Children raccolta è destinata all'uso interno di .NET MAUI e non deve essere modificata direttamente. Pertanto, negli elementi figlio di codice deve essere aggiunto direttamente al layout:
Grid grid = new Grid();
grid.Add(new Label { Text = "Hello world" });
Importante
Tutti i Add metodi di estensione del layout, ad esempio GridExtensions.Add, vengono richiamati Children nel layout anziché nella raccolta di layout.
Quando si esegue l'app .NET MAUI aggiornata, è possibile notare che il comportamento del layout è diverso. Per altre informazioni, vedere Modifiche al comportamento del layout da Xamarin.Forms.
Modifiche di layout personalizzate
Il processo di creazione di un layout personalizzato in Xamarin.Forms comporta la creazione di una classe che deriva da Layout<View>e l'override dei VisualElement.OnMeasure metodi e Layout.LayoutChildren . Per altre informazioni, vedere Creare un layout personalizzato in Xamarin.Forms.
In .NET MAUI le classi di layout derivano dalla classe astratta Layout . Questa classe delega il layout e la misurazione multipiattaforma a una classe di gestione layout. Ogni classe di gestione layout implementa l'interfaccia ILayoutManager , che specifica che Measure e ArrangeChildren le implementazioni devono essere fornite:
- L'implementazione Measure chiama IView.Measure in ogni visualizzazione del layout e restituisce le dimensioni totali del layout in base ai vincoli.
- L'implementazione ArrangeChildren determina la posizione di ogni visualizzazione all'interno dei limiti del layout e le chiamate Arrange a ogni visualizzazione con i limiti appropriati. Il valore restituito è la dimensione effettiva del layout.
Per altre informazioni, vedere Layout personalizzati.
Modifiche del dispositivo
Xamarin.Forms ha una Xamarin.Forms.Device classe che consente di interagire con il dispositivo e la piattaforma in cui è in esecuzione l'app. La classe equivalente in .NET MAUI, Microsoft.Maui.Controls.Device, è deprecata e la relativa funzionalità viene sostituita da più tipi.
La tabella seguente illustra le sostituzioni MAUI di .NET per la funzionalità nella Xamarin.Forms.Device classe :
| Xamarin.FormsAPI | API MAUI .NET | Commenti |
|---|---|---|
Xamarin.Forms.Device.Android |
Microsoft.Maui.Devices.DevicePlatform.Android | |
Xamarin.Forms.Device.iOS |
Microsoft.Maui.Devices.DevicePlatform.iOS | |
Xamarin.Forms.Device.GTK |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Device.macOS |
Nessun equivalente di .NET MAUI. Usare invece Microsoft.Maui.Devices.DevicePlatform.MacCatalyst. | |
Xamarin.Forms.Device.Tizen |
Microsoft.Maui.Devices.DevicePlatform.Tizen | |
Xamarin.Forms.Device.UWP |
Microsoft.Maui.Devices.DevicePlatform.WinUI | |
Xamarin.Forms.Device.WPF |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Device.Flags |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Device.FlowDirection |
Microsoft.Maui.ApplicationModel.AppInfo.RequestedLayoutDirection | |
Xamarin.Forms.Device.Idiom |
Microsoft.Maui.Devices.DeviceInfo.Idiom | |
Xamarin.Forms.Device.IsInvokeRequired |
Microsoft.Maui.Dispatching.Dispatcher.IsDispatchRequired | |
Xamarin.Forms.Device.OS |
Microsoft.Maui.Devices.DeviceInfo.Platform | |
Xamarin.Forms.Device.RuntimePlatform |
Microsoft.Maui.Devices.DeviceInfo.Platform | |
Xamarin.Forms.Device.BeginInvokeOnMainThread |
Microsoft.Maui.ApplicationModel.MainThread.BeginInvokeOnMainThread | |
Xamarin.Forms.Device.GetMainThreadSynchronizationContextAsync |
Microsoft.Maui.ApplicationModel.MainThread.GetMainThreadSynchronizationContextAsync | |
Xamarin.Forms.Device.GetNamedColor |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Device.GetNamedSize |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Device.Invalidate |
Microsoft.Maui.Controls.VisualElement.InvalidateMeasure | |
Xamarin.Forms.Device.InvokeOnMainThreadAsync |
Microsoft.Maui.ApplicationModel.MainThread.InvokeOnMainThreadAsync | |
Xamarin.Forms.Device.OnPlatform |
Microsoft.Maui.Devices.DeviceInfo.Platform | |
Xamarin.Forms.Device.OpenUri |
Microsoft.Maui.ApplicationModel.Launcher.OpenAsync | |
Xamarin.Forms.Device.SetFlags |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Device.SetFlowDirection |
Microsoft.Maui.Controls.Window.FlowDirection | |
Xamarin.Forms.Device.StartTimer |
Microsoft.Maui.Dispatching.DispatcherExtensions.StartTimer oppure Microsoft.Maui.Dispatching.Dispatcher.DispatchDelayed |
Modifiche mappa
In Xamarin.Formsil controllo e i Map tipi associati si trovano nello spazio dei Xamarin.Forms.Maps nomi . In .NET MAUI questa funzionalità è stata spostata negli Microsoft.Maui.Controls.Maps spazi dei nomi e Microsoft.Maui.Maps . Alcune proprietà sono state rinominate e alcuni tipi sono stati sostituiti con tipi equivalenti da Xamarin.Essentials.
La tabella seguente illustra le sostituzioni MAUI di .NET per la funzionalità nello spazio dei Xamarin.Forms.Maps nomi :
| Xamarin.FormsAPI | API MAUI .NET | Commento |
|---|---|---|
Xamarin.Forms.Maps.Map.HasScrollEnabled |
Microsoft.Maui.Controls.Maps.Map.IsScrollEnabled | |
Xamarin.Forms.Maps.Map.HasZoomEnabled |
Microsoft.Maui.Controls.Maps.Map.IsZoomEnabled | |
Xamarin.Forms.Maps.Map.TrafficEnabled |
Microsoft.Maui.Controls.Maps.Map.IsTrafficEnabled | |
Xamarin.Forms.Maps.Map.MoveToLastRegionOnLayoutChange |
Nessun equivalente di .NET MAUI. | |
Xamarin.Forms.Maps.Pin.Id |
Microsoft.Maui.Controls.Maps.Pin.MarkerId | |
Xamarin.Forms.Maps.Pin.Position |
Microsoft.Maui.Controls.Maps.Pin.Location | |
Xamarin.Forms.Maps.MapClickedEventArgs.Position |
Microsoft.Maui.Controls.Maps.MapClickedEventArgs.Location | |
Xamarin.Forms.Maps.Position |
Microsoft.Maui.Devices.Sensors.Location | I membri di tipo Xamarin.Forms.Maps.Position sono stati modificati nel Microsoft.Maui.Devices.Sensors.Location tipo . |
Xamarin.Forms.Maps.Geocoder |
Microsoft.Maui.Devices.Sensors.Geocoding | I membri di tipo Xamarin.Forms.Maps.Geocoder sono stati modificati nel Microsoft.Maui.Devices.Sensors.Geocoding tipo . |
.NET MAUI ha due Map tipi: Microsoft.Maui.Controls.Maps.Map e Microsoft.Maui.ApplicationModel.Map. Poiché lo Microsoft.Maui.ApplicationModel spazio dei nomi è una delle direttive MAUI di global using .NET, quando si usa il Microsoft.Maui.Controls.Maps.Map controllo dal codice è necessario qualificare Map completamente l'utilizzo o usare un alias using.
In XAML è necessario aggiungere una xmlns definizione dello spazio dei nomi per il Map controllo . Anche se non è necessario, impedisce una collisione tra i Polygon tipi e Polyline , che esistono sia negli spazi dei Microsoft.Maui.Controls.Maps Microsoft.Maui.Controls.Shapes nomi che negli spazi dei nomi . Per altre informazioni, vedere Visualizzare una mappa.
Altre modifiche
Un numero ridotto di altre API è stato consolidato nel passaggio da Xamarin.Forms a .NET MAUI. La tabella seguente mostra queste modifiche:
| Xamarin.FormsAPI | API MAUI .NET | Commenti |
|---|---|---|
Xamarin.Forms.Application.Properties |
Microsoft.Maui.Storage.Preferences | |
Xamarin.Forms.Button.Image |
Microsoft.Maui.Controls.Button.ImageSource | |
Xamarin.Forms.Frame.OutlineColor |
Microsoft.Maui.Controls.Frame.BorderColor | |
Xamarin.Forms.IQueryAttributable.ApplyQueryAttributes |
Microsoft.Maui.Controls.IQueryAttributable.ApplyQueryAttributes | In Xamarin.Formsil ApplyQueryAttributes metodo accetta un IDictionary<string, string> argomento. In .NET MAUI il ApplyQueryAttributes metodo accetta un IDictionary<string, object> argomento. |
Xamarin.Forms.MenuItem.Icon |
Microsoft.Maui.Controls.MenuItem.IconImageSource | Xamarin.Forms.MenuItem.Icon è la classe di base per Xamarin.Forms.ToolbarIteme quindi ToolbarItem.Icon diventa ToolbarItem.IconImageSource. |
Xamarin.Forms.OrientationStateTrigger.Orientation |
Microsoft.Maui.Controls.OrientationStateTrigger.Orientation | In Xamarin.Formsla OrientationStateTrigger.Orientation proprietà è di tipo Xamarin.Forms.Internals.DeviceOrientation. In .NET MAUI la OrientationStateTrigger.Orientation proprietà è di tipo DisplayOrientation. |
Xamarin.Forms.OSAppTheme |
Microsoft.Maui.ApplicationModel.AppTheme | |
Xamarin.Forms.Span.ForegroundColor |
Microsoft.Maui.Controls.Span.TextColor | |
Xamarin.Forms.ToolbarItem.Name |
Microsoft.Maui.Controls.MenuItem.Text | Microsoft.Maui.Controls.MenuItem.Text è la classe di base per Microsoft.Maui.Controls.ToolbarIteme quindi ToolbarItem.Name diventa ToolbarItem.Text. |
Inoltre, in Xamarin.Forms, l'override Page.OnAppearing viene chiamato in Android quando un'app è in background e quindi viene portata in primo piano. Tuttavia, questa sostituzione non viene chiamata in iOS e Windows nello stesso scenario. In .NET MAUI l'override OnAppearing() non viene chiamato in alcuna piattaforma quando un'app è in background e quindi viene portata in primo piano. È invece necessario restare in ascolto degli eventi del ciclo di vita su cui Window ricevere una notifica quando un'app torna in primo piano. Per altre informazioni, vedere Finestre MAUI .NET.
Modifiche ai moduli nativi
I moduli nativi in Xamarin.Forms sono diventati l'incorporamento nativo in .NET MAUI e usano un approccio di inizializzazione e metodi di estensione diversi per convertire i controlli multipiattaforma nei tipi nativi. Per altre informazioni, vedere Incorporamento nativo.
Eseguire il bootstrap dell'app migrata
Quando si aggiorna manualmente un'app Xamarin.Forms a .NET MAUI, è necessario abilitare il supporto MAUI .NET in ogni progetto di piattaforma, aggiornare la classe del punto di ingresso di ogni progetto di piattaforma e quindi configurare il bootstrap dell'app MAUI .NET.
Abilitare .NET MAUI nei progetti della piattaforma
Prima di aggiornare la classe del punto di ingresso di ogni progetto di piattaforma, è necessario abilitare il supporto di .NET MAUI. A tale scopo, impostare la proprietà di $(UseMaui) compilazione su true in ogni progetto di piattaforma:
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
...
<UseMaui>true</UseMaui>
</PropertyGroup>
</Project>
Importante
È necessario aggiungere <UseMaui>true</UseMaui> al file di progetto per abilitare il supporto DI MAUI .NET. Assicurarsi inoltre di aver aggiunto <EnableDefaultMauiItems>false</EnableDefaultMauiItems> al file di progetto WinUI. In questo modo si interrompe la ricezione di errori di compilazione relativi al InitializeComponent metodo già definito.
Aggiungere riferimenti ai pacchetti
In .NET 8, .NET MAUI viene fornito come carico di lavoro .NET e più pacchetti NuGet. Il vantaggio di questo approccio è che consente di aggiungere facilmente i progetti a versioni specifiche, consentendo allo stesso tempo di visualizzare facilmente l'anteprima di build non definitive o sperimentali.
È consigliabile aggiungere i seguenti riferimenti espliciti al pacchetto in un <ItemGroup> in ogni file di progetto:
<PackageReference Include="Microsoft.Maui.Controls" Version="$(MauiVersion)" />
<PackageReference Include="Microsoft.Maui.Controls.Compatibility" Version="$(MauiVersion)" />
Viene $(MauiVersion) fatto riferimento alla variabile dalla versione di .NET MAUI installata. È possibile eseguire l'override di questa operazione aggiungendo la proprietà di $(MauiVersion) compilazione a ogni file di progetto:
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<UseMaui>True</UseMaui>
<MauiVersion>8.0.3</MauiVersion>
</PropertyGroup>
</Project>
Configurazione del progetto Android
Nel progetto .NET MAUI Android aggiornare la MainApplication classe in modo che corrisponda al codice seguente:
using System;
using Android.App;
using Android.Runtime;
using Microsoft.Maui;
using Microsoft.Maui.Hosting;
using YOUR_MAUI_CLASS_LIB_HERE;
namespace YOUR_NAMESPACE_HERE.Droid
{
[Application]
public class MainApplication : MauiApplication
{
public MainApplication(IntPtr handle, JniHandleOwnership ownership) : base(handle, ownership)
{
}
protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
}
}
Aggiornare anche la MainActivity classe per ereditare da MauiAppCompatActivity:
using System;
using Microsoft.Maui;
using Android.App;
using Android.Content.PM;
using Android.Runtime;
using Android.OS;
namespace YOUR_NAMESPACE_HERE.Droid
{
[Activity(Label = "MyTitle", Icon = "@mipmap/icon", Theme = "@style/MainTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize)]
public class MainActivity : MauiAppCompatActivity
{
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
}
}
}
Aggiornare quindi il file manifesto per specificare che minSdKVersion è 21, ovvero la versione minima di Android SDK richiesta da .NET MAUI. A tale scopo, è possibile modificare il <uses-sdk /> nodo, che è un elemento figlio del <manifest> nodo:
<uses-sdk android:minSdkVersion="21" android:targetSdkVersion="32" />
Configurazione del progetto iOS
Nel progetto .NET MAUI iOS aggiornare la AppDelegate classe in modo che erediti da MauiUIApplicationDelegate:
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Maui;
using Foundation;
using UIKit;
using YOUR_MAUI_CLASS_LIB_HERE;
namespace YOUR_NAMESPACE_HERE.iOS
{
[Register("AppDelegate")]
public partial class AppDelegate : MauiUIApplicationDelegate
{
protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
}
}
Aggiornare quindi Info.plist in modo che MinimumOSVersion sia 11.0, ovvero la versione minima di iOS richiesta da .NET MAUI.
Configurazione del progetto UWP
Nel progetto .NET MAUI WinUI 3 aggiornare App.xaml in modo che corrisponda al codice seguente:
<?xml version="1.0" encoding="utf-8"?>
<maui:MauiWinUIApplication
x:Class="YOUR_NAMESPACE_HERE.WinUI.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:maui="using:Microsoft.Maui"
xmlns:local="using:YOUR_NAMESPACE_HERE.WinUI">
<maui:MauiWinUIApplication.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
<!-- Other merged dictionaries here -->
</ResourceDictionary.MergedDictionaries>
<!-- Other app resources here -->
</ResourceDictionary>
</maui:MauiWinUIApplication.Resources>
</maui:MauiWinUIApplication>
Nota
Se il progetto include risorse nel file App.xaml esistente, è necessario eseguirne la migrazione alla nuova versione del file.
Aggiornare anche App.xaml.cs in modo che corrisponda al codice seguente:
using Microsoft.Maui;
using Microsoft.Maui.Hosting;
using YOUR_MAUI_CLASS_LIB_HERE;
namespace YOUR_NAMESPACE_HERE.WinUI;
public partial class App : MauiWinUIApplication
{
public App()
{
InitializeComponent();
}
protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
}
Nota
Se il progetto include la logica di business in App.xaml.cs è necessario eseguire la migrazione di tale logica alla nuova versione del file.
Aggiungere quindi un file launchSettings.json alla cartella Properties del progetto e aggiungere il codice JSON seguente al file:
{
"profiles": {
"Windows Machine": {
"commandName": "MsixPackage",
"nativeDebugging": true
}
}
}
Punto di ingresso app
Le app MAUI .NET hanno un singolo punto di ingresso per app multipiattaforma. Ogni punto di ingresso della piattaforma chiama un CreateMauiApp metodo nella classe statica MauiProgram e restituisce un oggetto MauiApp.
Aggiungere quindi una nuova classe denominata MauiProgram contenente il codice seguente:
namespace YOUR_NAMESPACE_HERE;
public static class MauiProgram
{
public static MauiApp CreateMauiApp()
{
var builder = MauiApp.CreateBuilder();
builder
.UseMauiApp<App>();
return builder.Build();
}
}
Nota
Per Xamarin.Forms i progetti UWP, il App riferimento in builder.UseMauiApp<App>() è disponibile nel file MainPage.xaml.cs .
Se sono presenti servizi specifici della piattaforma di cui è necessario eseguire la migrazione a .NET MAUI, usare il AddTransient(IServiceCollection, Type) metodo per aggiungere un servizio temporaneo del tipo specificato all'oggetto specificato IServiceCollection.
Nota
È possibile aggiornare Xamarin.Forms rapidamente gli spazi dei nomi in Microsoft.Maui usando azioni rapide in Visual Studio, purché sia installato Upgrade Assistant .
Modifiche di AssemblyInfo
Le proprietà in genere impostate in un file AssemblyInfo.cs sono ora disponibili nel progetto in stile SDK. È consigliabile eseguirne la migrazione da AssemblyInfo.cs al file di progetto in ogni progetto e rimuovere il file AssemblyInfo.cs .
Facoltativamente, è possibile mantenere il file AssemblyInfo.cs e impostare la GenerateAssemblyInfo proprietà nel file di progetto su false:
<PropertyGroup>
<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
</PropertyGroup>
Per altre informazioni sulla GenerateAssemblyInfo proprietà, vedere GenerateAssemblyInfo.
Aggiornare le dipendenze delle app
In genere, Xamarin.Forms i pacchetti NuGet non sono compatibili con .NET 8 a meno che non siano stati ricompilati usando moniker del framework di destinazione .NET (TFMS). Tuttavia, le app Android possono usare pacchetti NuGet destinati ai monoandroid framework e monoandroidXX.X .
È possibile verificare che un pacchetto sia compatibile con .NET 8 esaminando la scheda Framework in NuGet per il pacchetto in uso e verificando che elenca uno dei framework compatibili illustrati nella tabella seguente:
| Framework compatibili | Framework incompatibili |
|---|---|
| net8.0-android, monoandroid, monoandroidXX.X | |
| net8.0-ios | monotouch, xamarinios, xamarinios10 |
| net8.0-macos | monomac, xamarinmac, xamarinmac20 |
| net8.0-tvos | xamarintvos |
| xamarinwatchos |
Nota
Le librerie .NET Standard che non hanno dipendenze dai framework incompatibili elencati in precedenza sono ancora compatibili con .NET 8.
Se un pacchetto in NuGet indica la compatibilità con uno dei framework compatibili precedenti, indipendentemente dall'inclusione anche di framework incompatibili, il pacchetto è compatibile. I pacchetti NuGet compatibili possono essere aggiunti al progetto di libreria MAUI .NET usando gestione pacchetti NuGet in Visual Studio.
Se non è possibile trovare una versione compatibile con .NET 8 di un pacchetto NuGet, è necessario:
- Ricompilare il pacchetto con i TFM .NET, se si è proprietari del codice.
- Cercare una versione di anteprima di una versione .NET 8 del pacchetto.
- Sostituire la dipendenza con un'alternativa compatibile con .NET 8.
Compilare e risolvere i problemi
Dopo aver risolto le dipendenze, è necessario compilare il progetto. Eventuali errori ti guideranno verso i passaggi successivi.
Suggerimento
- Eliminare tutte le cartelle bin e obj da tutti i progetti prima di aprire e compilare progetti in Visual Studio, in particolare quando si modificano le versioni di .NET.
- Eliminare il Resource.designer.cs file generato dal progetto Android.
La tabella seguente fornisce indicazioni per il superamento dei problemi comuni di compilazione o runtime:
| Problema | Suggerimento |
|---|---|
Xamarin.* lo spazio dei nomi non esiste. |
Aggiornare lo spazio dei nomi al relativo equivalente MAUI .NET. Per altre informazioni, vedere Modifiche dello spazio dei nomi. |
| L'API non esiste. | Aggiornare l'utilizzo dell'API all'equivalente MAUI .NET. Per altre informazioni, vedere Modifiche all'API. |
| L'app non verrà distribuita. | Assicurarsi che il progetto di piattaforma richiesto sia impostato per la distribuzione in Configuration Manager di Visual Studio. |
| L'app non verrà avviata. | Aggiornare la classe del punto di ingresso di ogni progetto della piattaforma e il punto di ingresso dell'app. Per altre informazioni, vedere Bootstrap dell'app migrata. |
| CollectionView non scorre. | Controllare il layout del contenitore e le dimensioni misurate di CollectionView. Per impostazione predefinita, il controllo occupa lo spazio consentito dal contenitore. Un Grid vincolo vincola gli elementi figlio alle proprie dimensioni. Tuttavia, un StackLayout consente agli elementi figlio di occupare spazio oltre i limiti. |
| Il popup viene visualizzato nella pagina in iOS. | In Xamarin.Formstutti i popup in iOS sono UIWindow istanze, ma nei popup .NET MAUI vengono visualizzati individuando la presentazione ViewController corrente e visualizzando il popup con PresentViewControllerAsync. Nei plug-in, ad esempio Mopups, per assicurarsi che i popup siano visualizzati correttamente, è necessario chiamare DisplayAlert, DisplayActionSheeto DisplayPromptAsync dall'oggetto ContentPage usato all'interno del Mopup popup. |
| BoxView non appare. | La dimensione predefinita di in BoxView Xamarin.Forms è 40x40. Le dimensioni predefinite di un BoxView oggetto in .NET MAUI sono 0x0. Impostare WidthRequest e HeightRequest su 40. |
| Il layout non contiene spaziatura interna, margine o spaziatura. | Aggiungere valori predefiniti al progetto in base alla risorsa di stile MAUI .NET. Per altre informazioni, vedere Modifiche del valore predefinito da Xamarin.Forms. |
| Il layout personalizzato non funziona. | Il codice di layout personalizzato deve essere aggiornato per funzionare in .NET MAUI. Per altre informazioni, vedere Modifiche al layout personalizzato. |
| Il renderer personalizzato non funziona. | Il codice renderer deve essere aggiornato per funzionare in .NET MAUI. Per altre informazioni, vedere Usare renderer personalizzati in .NET MAUI. |
| L'effetto non funziona. | Il codice effetto deve essere aggiornato per funzionare in .NET MAUI. Per altre informazioni, vedere Usare gli effetti in .NET MAUI. |
| SkiaSharp il codice non funziona. | SkiaSharp il codice richiede aggiornamenti secondari per funzionare in .NET MAUI. Per altre informazioni, vedere Riutilizzare SkiaSharp il codice in .NET MAUI. |
| Non è possibile accedere ai dati delle proprietà dell'app creati in precedenza. | Eseguire la migrazione dei dati delle proprietà dell'app alle preferenze MAUI .NET. Per altre informazioni, vedere Eseguire la migrazione dei dati dal dizionario delle proprietà dell'app Xamarin.Forms alle preferenze MAUI .NET. |
| Non è possibile accedere ai dati di archiviazione protetti creati in precedenza. | Eseguire la migrazione dei dati di archiviazione sicura a .NET MAUI. Per altre informazioni, vedere Eseguire la migrazione da Xamarin.Essentials una risorsa di archiviazione sicura a una risorsa di archiviazione sicura MAUI .NET. |
| Non è possibile accedere ai dati di rilevamento delle versioni creati in precedenza. | Eseguire la migrazione dei dati di rilevamento della versione a .NET MAUI. Per altre informazioni, vedere Eseguire la migrazione dei dati di rilevamento delle versioni da un'app Xamarin.Forms a un'app MAUI .NET. |
