Partager via

Nouveautés de .NET MAUI pour .NET 9

  • Article

L’objectif de .NET Multi-Platform App UI (.NET MAUI) dans .NET 9 est d’améliorer la qualité des produits. Cela inclut l’extension de la couverture des tests, le test de scénario de bout en bout et la correction des bogues. Pour plus d’informations sur les améliorations de la qualité des produits dans .NET MAUI 9, consultez les notes de publication suivantes :

Important

En raison de l’utilisation de dépendances externes, comme Xcode ou Android SDK Tools, la stratégie de prise en charge de .NET MAUI diffère de la stratégie de prise en charge de .NET et .NET Core. Pour plus d’informations, consultez Stratégie de prise en charge de .NET.

Dans .NET 9, .NET MAUI est fourni sous la forme d’une charge de travail .NET et de plusieurs packages NuGet. L’avantage de cette approche est qu’elle vous permet d’épingler facilement vos projets à des versions spécifiques, tout en vous permettant d’avoir facilement un aperçu des builds non publiées ou expérimentales. Quand vous créez un projet .NET MAUI, les packages NuGet nécessaires sont automatiquement ajoutés au projet.

Cibles de déploiement minimales

.NET MAUI 9 nécessite les cibles de déploiement minimales iOS 12.2 et Mac Catalyst 15.0 (macOS 12.0). Les cibles de déploiement minimales Android et Windows restent identiques. Pour plus d’informations, consultez Plateformes prises en charge par les applications .NET MAUI.

Nouveaux contrôles

.NET MAUI 9 comprend deux nouveaux contrôles.

HybridWebView

HybridWebView permet d’héberger du contenu HTML/JS/CSS arbitraire dans une vue web et permet une communication entre le code de la vue web (JavaScript) et le code qui héberge la vue web (C#/.NET). Par exemple, si vous disposez d’une application JS React existante, vous pouvez l’héberger dans une application .NET MAUI native multiplateforme et générer le back-end de l’application à l’aide de C# et .NET.

Pour générer une application .NET MAUI avec HybridWebView vous avez besoin des éléments suivants :

  • Le contenu web de l’application, qui se compose de HTML statique, de JavaScript, de CSS, d’images et autres fichiers.
  • Un contrôle HybridWebView faisant partie de l’interface utilisateur de l’application. Pour ce faire, référencez-le dans le code XAML de l’application.
  • Du code dans le contenu web, ainsi que dans C#/.NET, qui utilise les API HybridWebView pour envoyer des messages entre les deux composants.

L’ensemble de l’application, y compris le contenu web, est empaqueté et s’exécute localement sur un appareil et peut être publié dans les magasins d’applications applicables. Le contenu web est hébergé dans un contrôle de vue web natif et s’exécute dans le contexte de l’application. Toute partie de l’application peut accéder aux services web externes, mais n’y est pas obligée.

Pour plus d’informations, consultez HybridWebView.

Titlebar pour Windows

Le contrôle TitleBar permet d’ajouter une barre de titre personnalisée à votre application sur Windows :

Vue d’ensemble de la barre de titre .NET MAUI.

Un TitleBar peut être défini comme valeur de la propriété Window.TitleBar sur n’importe quel Window :

<Window.TitleBar>
    <TitleBar x:Name="TeamsTitleBar"
              Title="Hello World"
              Icon="appicon.png"
              HeightRequest="46">
        <TitleBar.Content>
            <Entry x:Name="SearchTitleBar"
                   Placeholder="Search"
                   VerticalOptions="Center"
                   MinimumWidthRequest="300"
                   MaximumWidthRequest="450"
                   HeightRequest="32"/>
        </TitleBar.Content>
    </TitleBar>
</Window.TitleBar>

Voici un exemple d’utilisation en C# :

Window.TitleBar = new TitleBar
{
    Title = "MAUI App",
    Icon = "appicon.png",
    HeightRequest = 46,
    LeadingContent = new AvatarButton()
};

Un TitleBar est hautement personnalisable via ses propriétés Content, LeadingContent et TrailingContent :

<TitleBar Title="My App"
          BackgroundColor="#512BD4"
          HeightRequest="48">
    <TitleBar.Content>
        <SearchBar Placeholder="Search"
                   MaximumWidthRequest="300"
                   HorizontalOptions="FillAndExpand"
                   VerticalOptions="Center" />
    </TitleBar.Content>
    <TitleBar.TrailingContent>
        <ImageButton HeightRequest="36"
                     WidthRequest="36"
                     BorderWidth="0"
                     Background="Transparent">
            <ImageButton.Source>
                <FontImageSource Size="16"
                                 Glyph="&#xE713;"
                                 FontFamily="SegoeMDL2"/>
            </ImageButton.Source>
        </ImageButton>
    </TitleBar.TrailingContent>
</TitleBar>

La capture d’écran suivante montre l’apparence ainsi obtenue :

Capture d’écran de la barre de titre .NET MAUI.

Remarque

La prise en charge de Mac Catalyst pour le contrôle TitleBar sera ajoutée dans une version ultérieure.

Améliorations apportées aux contrôles

.NET MAUI 9 inclut également des améliorations de contrôle.

Mode de liaison BackButtonBehavior OneWay

Le mode de liaison pour IsVisible et IsEnabled sur une application Shell BackButtonBehavior est maintenant BindingMode.OneWay au lieu de BindingMode.OneTime . Cela vous permet de contrôler plus facilement le comportement du bouton « Précédent » au moment de l’exécution, avec les liaisons de données :

<ContentPage ...>    
    <Shell.BackButtonBehavior>
        <BackButtonBehavior Command="{Binding BackCommand}"
                            IsVisible="{Binding IsBackButtonVisible}"
                            IconOverride="back.png" />   
    </Shell.BackButtonBehavior>
    ...
</ContentPage>

BlazorWebView

Sous iOS et Mac Catalyst 18, .NET MAUI 9 modifie le comportement par défaut pour l’hébergement de contenu dans un BlazorWebView et le fait passer sur localhost. L’adresse interne 0.0.0.0 utilisée pour héberger le contenu ne fonctionne plus et le BlazorWebView ne charge plus de contenu et est rendu sous la forme d’un rectangle vide.

Pour choisir d’utiliser l’adresse 0.0.0.0, ajoutez le code suivant à la méthode CreateMauiApp dans MauiProgram.cs :

// Set this switch to use the LEGACY behavior of always using 0.0.0.0 to host BlazorWebView
AppContext.SetSwitch("BlazorWebView.AppHostAddressAlways0000", true);

Si vous rencontrez des blocages sur Android avec BlazorWebView, vous devez activer un commutateur AppContext dans la méthode CreateMauiApp de votre classe MauiProgram :

AppContext.SetSwitch("BlazorWebView.AndroidFireAndForgetAsync", true);

Ce commutateur permet à BlazorWebView de déclencher et d’oublier la suppression asynchrone qui se produit, et par conséquent corrige la majorité des interblocages de suppression qui se produisent sur Android. Pour plus d’informations, consultez Corriger les interblocages de suppression sur Android.

CollectionView et CarouselView

.NET MAUI 9 inclut deux nouveaux gestionnaires facultatifs sur iOS et Mac Catalyst qui apportent des améliorations de performances et de stabilité à CollectionView et CarouselView. Ces gestionnaires sont basés sur des API UICollectionView.

Pour choisir d’utiliser ces gestionnaires, ajoutez le code suivant à votre classe MauiProgram :

#if IOS || MACCATALYST
builder.ConfigureMauiHandlers(handlers =>
{
    handlers.AddHandler<Microsoft.Maui.Controls.CollectionView, Microsoft.Maui.Controls.Handlers.Items2.CollectionViewHandler2>();
    handlers.AddHandler<Microsoft.Maui.Controls.CarouselView, Microsoft.Maui.Controls.Handlers.Items2.CarouselViewHandler2>();
});
#endif

ContentPage

Dans .NET MAUI 9, la propriété HideSoftInputOnTapped est également prise en charge sur Mac Catalyst, ainsi que sur Android et iOS.

Prise en charge des entrées de clavier logiciel

.NET MAUI 9 ajoute une nouvelle prise en charge des entrées de clavier logiciel pour Password, Date et Time. Celles-ci peuvent être activées sur des contrôles Editor et Entry :

<Entry Keyboard="Date" />

Alignement de texte

L’énumération TextAlignment ajoute un membre Justify qui peut être utilisé pour aligner du texte dans les contrôles de texte. Par exemple, vous pouvez aligner horizontalement du texte dans un Label avec HorizontalTextAlignment.Justify :

<Label Text="Lorem ipsum dolor sit amet, consectetur adipiscing elit. In facilisis nulla eu felis fringilla vulputate."
       HorizontalTextAlignment="Justify"/>

TimePicker

TimePicker obtient un événement TimeSelected, qui est déclenché lorsque l’heure sélectionnée change. L’objet TimeChangedEventArgs qui accompagne l’évènement TimeSelected a les propriétés NewTime et OldTime, qui spécifient respectivement la nouvelle et l’ancienne heure.

WebView

WebView ajoute un événement ProcessTerminated qui est déclenché lorsqu’un processus WebView se termine de façon inattendue. L’objet WebViewProcessTerminatedEventArgs qui accompagne cet événement définit des propriétés spécifiques à la plateforme qui indiquent pourquoi le processus a échoué.

Cycle de vie de l’application

.NET MAUI 9 ajoute les méthodes de cycle de vie de notification à distance suivantes sur iOS et Mac Catalyst :

  • RegisteredForRemoteNotifications, qui est appelé lorsque l’application a correctement accepté les notifications à distance.
  • ReceivedRemoteNotifications, qui est appelé lorsqu’une notification à distance est reçue.

L’exemple suivant montre comment employer ces méthodes de cycle de vie :

using Microsoft.Maui.LifecycleEvents;

namespace PlatformLifecycleDemo;

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();
        builder
            .UseMauiApp<App>()
            .ConfigureLifecycleEvents(events =>
            {
#if IOS || MACCATALYST
                events.AddiOS(ios => ios
                    .ReceivedRemoteNotifications((app, dictionary) => LogEvent(nameof(iOSLifecycle.OnReceivedRemoteNotifications)))
                    .RegisteredForRemoteNotifications((app, data) => LogEvent(nameof(iOSLifecycle.OnRegisteredForRemoteNotifications)));
#endif
                static bool LogEvent(string eventName, string type = null)
                {
                    System.Diagnostics.Debug.WriteLine($"Lifecycle event: {eventName}{(type == null ? string.Empty : $" ({type})")}");
                    return true;
                }
            });

        return builder.Build();
    }
}

Liaisons compilées dans le code

Les liaisons écrites dans le code utilisent généralement des chemins de chaîne résolus au moment du runtime avec réflexion, et la surcharge de cette opération varie d’une plateforme à l’autre. .NET MAUI 9 introduit une méthode d’extension SetBinding supplémentaire qui définit des liaisons à l’aide d’un argument Func au lieu d’un chemin d’accès de chaîne :

// in .NET 8
MyLabel.SetBinding(Label.TextProperty, "Text");

// in .NET 9
MyLabel.SetBinding(Label.TextProperty, static (Entry entry) => entry.Text);

Cette approche de liaison compilée offre les avantages suivants :

  • Amélioration des performances de liaisons de données en résolvant les expressions de liaison au moment de la compilation plutôt qu’au moment du runtime
  • Meilleure expérience de résolution de problèmes pour les développeurs, car les liaisons non valides sont signalées comme erreurs de build
  • IntelliSense lors de la modification

Toutes les méthodes ne peuvent pas être utilisées pour définir une liaison compilée. L’expression doit être une expression d’accès aux propriétés simple. Les exemples suivants montrent des expressions de liaison valides et non valides :

// Valid: Property access
static (PersonViewModel vm) => vm.Name;
static (PersonViewModel vm) => vm.Address?.Street;

// Valid: Array and indexer access
static (PersonViewModel vm) => vm.PhoneNumbers[0];
static (PersonViewModel vm) => vm.Config["Font"];

// Valid: Casts
static (Label label) => (label.BindingContext as PersonViewModel).Name;
static (Label label) => ((PersonViewModel)label.BindingContext).Name;

// Invalid: Method calls
static (PersonViewModel vm) => vm.GetAddress();
static (PersonViewModel vm) => vm.Address?.ToString();

// Invalid: Complex expressions
static (PersonViewModel vm) => vm.Address?.Street + " " + vm.Address?.City;
static (PersonViewModel vm) => $"Name: {vm.Name}";

En outre, .NET MAUI 9 ajoute une méthode Binding.Create qui définit la liaison directement sur l’objet avec un Func, et retourne l’instance de l’objet de liaison :

// in .NET 8
myEntry.SetBinding(Entry.TextProperty, new MultiBinding
{
    Bindings = new Collection<BindingBase>
    {
        new Binding(nameof(Entry.FontFamily), source: RelativeBindingSource.Self),
        new Binding(nameof(Entry.FontSize), source: RelativeBindingSource.Self),
        new Binding(nameof(Entry.FontAttributes), source: RelativeBindingSource.Self),
    },
    Converter = new StringConcatenationConverter()
});

// in .NET 9
myEntry.SetBinding(Entry.TextProperty, new MultiBinding
{
    Bindings = new Collection<BindingBase>
    {
        Binding.Create(static (Entry entry) => entry.FontFamily, source: RelativeBindingSource.Self),
        Binding.Create(static (Entry entry) => entry.FontSize, source: RelativeBindingSource.Self),
        Binding.Create(static (Entry entry) => entry.FontAttributes, source: RelativeBindingSource.Self),
    },
    Converter = new StringConcatenationConverter()
});

Important

Les liaisons compilées sont requises au lieu de liaisons basées sur des chaînes dans les applications NativeAOT, et dans les applications où le découpage complet est activé.

Liaisons compilées dans XAML

Dans .NET MAUI 8, les liaisons compilées sont désactivées pour toutes les expressions de liaison XAML qui définissent la propriété Source, et elles ne sont pas prises en charge pour les liaisons multiples. Ces restrictions ont été supprimées dans .NET MAUI 9.

Par défaut, .NET MAUI ne génère pas d’avertissements de build pour les liaisons qui n’utilisent pas de liaisons compilées, sauf si vous avez activé NativeAOT pour votre application. Toutefois, vous pouvez opter pour les avertissements de liaisons compilées générés en définissant la propriété $(MauiStrictXamlCompilation) de build sur true dans le fichier projet de votre application (*.csproj) :

<MauiStrictXamlCompilation>true</MauiStrictXamlCompilation>

Déconnexion de gestionnaire

Lors de l’implémentation d’un contrôle personnalisé à l’aide de gestionnaires, chaque implémentation de gestionnaire de plateforme est requise pour implémenter la méthode DisconnectHandler, afin d’effectuer tout nettoyage de vue native, comme une désinscription des événements. Toutefois, avant .NET MAUI 9, l’implémentation DisconnectHandler n’est intentionnellement pas appelée par .NET MAUI. À la place, vous devez l’appeler vous-même lorsque vous choisissez de nettoyer un contrôle, par exemple lors d’un retour en arrière au sein d’une application.

Dans .NET MAUI 9, les gestionnaires se déconnectent automatiquement de leurs contrôles lorsque cela est possible, par exemple lors d’un retour en arrière au sein d’une application. Dans certains scénarios, ce comportement n’est pas souhaitable. Par conséquent, .NET MAUI 9 ajoute une propriété jointe HandlerProperties.DisconnectPolicy pour ajuster le moment où les gestionnaires sont déconnectés de leurs contrôles. Cette propriété nécessite un argument HandlerDisconnectPolicy, avec l’énumération HandlerDisconnectPolicy définissant les valeurs suivantes :

  • Automatic, qui indique que les gestionnaires seront déconnectés automatiquement. Ceci est la valeur par défaut de la propriété jointe HandlerProperties.DisconnectPolicy.
  • Manual, qui indique que les gestionnaires devront être déconnectés manuellement en appelant l’implémentation DisconnectHandler.

L’exemple suivant montre comment définir la propriété jointe HandlerProperties.DisconnectPolicy :

<controls:Video x:Name="video"
                HandlerProperties.DisconnectPolicy="Manual"
                Source="video.mp4"
                AutoPlay="False" />

Le code C# équivalent est :

Video video = new Video
{
    Source = "video.mp4",
    AutoPlay = false
};
HandlerProperties.SetDisconnectPolicy(video, HandlerDisconnectPolicy.Manual);

En outre, il existe une méthode d’extension DisconnectHandlers qui déconnecte les gestionnaires d’un élément IView donné :

video.DisconnectHandlers();

Lors d’une déconnexion, la méthode DisconnectHandlers se propage dans l’arborescence de contrôle jusqu’à ce qu’elle se termine ou qu’elle atteigne un contrôle qui a défini une stratégie manuelle.

Prise en charge de plusieurs fenêtres

.NET MAUI 9 ajoute la possibilité d’amener une fenêtre spécifique au premier plan sur Mac Catalyst et Windows avec la méthode Application.Current.ActivateWindow :

Application.Current?.ActivateWindow(windowToActivate);

Incorporation native

.NET MAUI 9 inclut des API complètes pour les scénarios d’incorporation natifs, qui devaient auparavant être ajoutés manuellement à votre projet :

var mauiApp = MauiProgram.CreateMauiApp();

#if ANDROID
var mauiContext = new MauiContext(mauiApp.Services, window);
#else
var mauiContext = new MauiContext(mauiApp.Services);
#endif

var mauiView = new MyMauiContent();
var nativeView = mauiView.ToPlatform(mauiContext);

Vous pouvez également utiliser la méthode ToPlatformEmbedded, en passant par la Window de la plateforme sur laquelle l’application s’exécute :

var mauiApp = MauiProgram.CreateMauiApp();
var mauiView = new MyMauiContent();
var nativeView = mauiView.ToPlatformEmbedded(mauiApp, window);

Dans les deux exemples, nativeView est une version spécifique à la plateforme de mauiView.

Pour démarrer une application incorporée native dans .NET MAUI 9, appelez la méthode d’extension UseMauiEmbeddedApp sur votre objet MauiAppBuilder :

public static class MauiProgram
{
    public static MauiApp CreateMauiApp()
    {
        var builder = MauiApp.CreateBuilder();

        builder
            .UseMauiEmbeddedApp<App>();

        return builder.Build();
    }
}

Modèles de projet

.NET MAUI 9 ajoute un modèle de projet Application web .NET MAUI Blazor Hybrid à Visual Studio qui crée une solution avec une application .NET MAUI Blazor Hybrid avec une application web Blazor, qui partagent du code commun dans un projet de bibliothèque de classes Razor.

Le modèle peut également être utilisé à partir de dotnew new :

dotnet new maui-blazor-web -n AllTheTargets

Dictionnaires de ressources

Dans .NET MAUI 9, un code XAML ResourceDictionary autonome (qui n’est pas sauvegardé par un fichier code-behind) est compilé par défaut en XAML. Pour désactiver ce comportement, spécifiez <?xaml-comp compile="false" ?> après l’en-tête XML.

Découpage des commutateurs de fonctionnalités

Plusieurs zones de .NET MAUI sont fournies avec des directives de découpage, appelées commutateurs de fonctionnalités, qui permettent de supprimer le code des fonctionnalités désactivées lorsque TrimMode=full, ainsi que celui de NativeAOT :

Propriété MSBuild Description
MauiEnableVisualAssemblyScanning Lorsque la valeur est true, .NET MAUI recherche dans les assemblys les types implémentant les attributs IVisual et [assembly:Visual(...)], et enregistre ces types. Par défaut, cette propriété de build est définie sur false.
MauiShellSearchResultsRendererDisplayMemberNameSupported Lorsqu’elle est définie sur false, la valeur de SearchHandler.DisplayMemberName est ignorée. Au lieu de cela, vous devez fournir un ItemTemplate pour définir l’apparence des résultats SearchHandler. Par défaut, cette propriété de build est définie sur true.
MauiQueryPropertyAttributeSupport Lorsqu’ils sont définis sur false, les attributs [QueryProperty(...)] ne sont pas utilisés pour définir les valeurs des propriétés lors de la navigation. Au lieu de cela, vous devez implémenter l’interface IQueryAttributable pour accepter les paramètres de requête. Par défaut, cette propriété de build est définie sur true.
MauiImplicitCastOperatorsUsageViaReflectionSupport Lorsque la valeur est false, .NET MAUI ne recherche pas d’opérateurs de cast implicites lors de la conversion de valeurs d’un type à un autre. Cela peut affecter les liaisons entre des propriétés de types différents et la définition de la valeur d’une propriété d’un objet pouvant être lié avec une valeur d’un type différent. Au lieu de cela, vous devez définir un TypeConverter pour votre type et l’attacher au type à l’aide de l’attribut [TypeConverter(typeof(MyTypeConverter))]. Par défaut, cette propriété de build est définie sur true.
_MauiBindingInterceptorsSupport Lorsque la valeur est false, .NET MAUI n’intercepte pas les appels aux méthodes SetBinding et n’essaie pas de les compiler. Par défaut, cette propriété de build est définie sur true.

Pour utiliser un commutateur de fonctionnalités, vous devez placer la propriété MSBuild correspondante dans le fichier de projet de votre application (*.csproj), ce qui entraîne l’élimination du code correspondant des assemblys .NET MAUI. La désactivation des fonctions dont une application n’a pas besoin peut contribuer à réduire la taille de l’application lorsqu’elle est combinée au mode de découpage Full.

XAML

Toutes les classes qui implémentent IMarkupExtension, IMarkupExtension<T>, IValueProvider, et IExtendedTypeConverter doivent être annotées avec les attributs RequireServiceAttribute ou AcceptEmptyServiceProviderAttribute. Cela est nécessaire en raison d’une optimisation du compilateur XAML introduite dans .NET MAUI 9 qui permet de générer un code plus efficace, ce qui contribue à réduire la taille de l’application et à améliorer les performances de runtime.

Pour plus d’informations sur l’annotation des extensions de balisage avec ces attributs, consultez Fournisseurs de services.

Synchronisation Xcode

.NET MAUI 9 inclut la synchronisation Xcode (xcsync), un outil qui vous permet d’utiliser Xcode pour gérer des fichiers spécifiques à Apple avec des projets .NET, notamment des catalogues de ressources, des fichiers plist, des storyboards et des fichiers XIB. L’outil a deux commandes principales permettant pour la première de générer un projet Xcode temporaire à partir d’un projet .NET, et pour la seconde de synchroniser les modifications apportées aux fichiers Xcode avec votre projet .NET.

Utilisez dotnet build avec la commande xcsync-generate ou xcsync-sync pour générer ou synchroniser ces fichiers et transmettre un fichier projet et des arguments supplémentaires :

dotnet build /t:xcsync-generate
    /p:xcSyncProjectFile=<PROJECT>
    /p:xcSyncXcodeFolder=<TARGET_XCODE_DIRECTORY>
    /p:xcSyncTargetFrameworkMoniker=<FRAMEWORK>
    /p:xcSyncVerbosity=<LEVEL>

Pour en savoir plus, consultez Synchronisation Xcode.

API déconseillées

.NET MAUI 9 déprécie certaines API, qui seront complètement supprimées dans une prochaine version.

Frame

Le contrôle Frame est marqué comme obsolète dans .NET MAUI 9 et sera complètement supprimé dans une version ultérieure. Le contrôle Border doit être utilisé à sa place. Pour en savoir plus, consultez Bordure.

MainPage

Au lieu de définir la première page de votre application à l’aide de la propriété MainPage sur un objet Application, vous devriez définir la propriété Page sur Window dans la première page de votre application. C’est exactement ce qui se passe au sein de NET MAUI lorsque vous définissez la propriété MainPage. Le fait que la propriété MainPage soit marquée comme obsolète n’entraîne ainsi aucune modification de comportement.

L’exemple de code suivant montre la définition de la propriété Page sur Window via la commande de remplacement CreateWindow :

public partial class App : Application
{
    public App()
    {
        InitializeComponent();
    }

    protected override Window CreateWindow(IActivationState? activationState)
    {
        return new Window(new AppShell());
    }
}

La propriété MainPage est conservée dans .NET MAUI 9, mais sera complètement supprimée dans une version ultérieure.

Dispositions de compatibilité

Les classes de disposition de compatibilité dans l’espace de noms Microsoft.Maui.Controls.Compatibility ont été rendues obsolètes.

Appels de mesure hérités

Les méthodes de mesure héritées VisualElement suivantes ont été rendues obsolètes :

  • protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint).
  • public virtual SizeRequest Measure(double widthConstraint, double heightConstraint, MeasureFlags flags = MeasureFlags.None) de VisualElement.

En remplacement, la méthode suivante a été introduite :

  • public size Measure(double widthConstraint, double heightConstraint)

La méthode Measure renvoie la taille minimale requise pour qu’un élément s’affiche sur un appareil. Les marges sont exclues de la mesure, mais sont renvoyées en plus de la taille. Il s’agit de la méthode privilégiée à appeler lors de la mesure d’une vue.

En outre, le struct Microsoft.Maui.SizeRequest est obsolète. À la place, utilisez Microsoft.Maui.Size.

.NET pour Android

.NET pour Android 9, qui ajoute une prise en charge de l’API 35, inclut un travail visant à réduire les temps de génération et à améliorer le découpage des applications pour réduire leur taille et améliorer leurs performances. Pour plus d’informations sur .NET pour Android 9, consultez les notes de publication suivantes :

Packs de ressources

.NET pour Android 9 introduit la possibilité de placer des ressources dans un package distinct appelé pack de ressources. Vous pouvez ainsi charger des jeux et des applications qui dépassent normalement la taille de package de base autorisée par Google Play. En plaçant ces ressources dans un package distinct, vous pouvez charger un package dont la taille peut atteindre 2 Go (contre 200 Mo pour un package de base).

Important

Les packs de ressources ne peuvent contenir que des ressources. Pour .NET pour Android, il s’agit des éléments associés à l’action de génération AndroidAsset.

Les applications .NET MAUI définissent des ressources via l’action de génération MauiAsset. Vous pouvez spécifier un pack de ressources à l’aide de l’attribut AssetPack :

<MauiAsset
    Include="Resources\Raw\**"
    LogicalName="%(RecursiveDir)%(Filename)%(Extension)"
    AssetPack="myassetpack" />

Remarque

Les métadonnées supplémentaires sont ignorées par d’autres plateformes.

Si vous souhaitez placer des éléments spécifiques dans un pack de ressources, vous pouvez utiliser l’attribut Update pour définir les métadonnées AssetPack :

<MauiAsset Update="Resources\Raw\MyLargeAsset.txt" AssetPack="myassetpack" />

Les packs de ressources peuvent avoir différentes options de livraison qui contrôlent quand vos ressources sont installées sur l’appareil :

  • Les packs au moment de l’installation sont installés en même temps que l’application. La taille maximale de ce type de pack est de 1 Go Mo, mais vous ne pouvez en avoir qu’un seul. Ce type de livraison est spécifié avec les métadonnées InstallTime.
  • Les packs de suivi rapide sont installés peu de temps après la fin de l’installation de l’application. L’application pouvant démarrer pendant l’installation de ce type de pack, vous devez vérifier que son installation est terminée avant d’essayer d’utiliser les ressources. La taille maximale de ce type de pack de ressources est de 512 Mo. Ce type de livraison est spécifié avec les métadonnées FastFollow.
  • Les packs à la demande ne sont jamais téléchargés sur l’appareil, sauf si l’application le demande spécifiquement. La taille totale de tous vos packs de ressources ne peut pas dépasser 2 Go, et vous pouvez avoir jusqu’à 50 packs de ressources distincts. Ce type de livraison est spécifié avec les métadonnées OnDemand.

Dans les applications .NET MAUI, vous pouvez spécifier le type de livraison avec l’attribut DeliveryType sur MauiAsset :

<MauiAsset Update="Resources\Raw\myvideo.mp4" AssetPack="myassetpack" DeliveryType="FastFollow" />

Pour plus d’informations sur les packs de ressources Android, consultez Packs de ressources Android.

Prise en charge d’Android 15

.NET pour Android 9 ajoute des liaisons .NET pour Android 15 (API 35). Pour créer pour ces API, mettez à jour l’infrastructure cible de votre projet :

<TargetFramework>net9.0-android35</TargetFramework>

Méthodes marshalées LLVM

Les méthodes marshalées LLVM (Low-Level Virtual Machine) sont désormais activées par défaut dans .NET pour Android 9 dans les applications non Blazor. Cela a entraîné une amélioration d’environ 10 % des performances dans une application de test.

Les méthodes marshalées LLVM peuvent être désactivées dans votre fichier projet (.csproj) :

<PropertyGroup Condition="'$(TargetFramework)' == 'net9.0-android'">
    <AndroidEnableLLVM>false</AndroidEnableLLVM>
    <AndroidEnableLLVMOptimizations>false</AndroidEnableLLVMOptimizations>
</PropertyGroup>

Améliorations du découpage

.NET pour Android 9 inclut des correctifs pour l’utilisation du découpage complet pour réduire la taille de l’application. Le découpage complet est généralement activé uniquement pour les builds de mise en production de votre application et peut être configuré dans votre fichier projet (.csproj) :

<PropertyGroup Condition="'$(Configuration)' == 'Release' And '$(TargetFramework)' == 'net9.0-android'">
    <TrimMode>Full</TrimMode>
</PropertyGroup>

.NET pour iOS

.NET 9 sur iOS, tvOS, Mac Catalyst et macOS utilisent Xcode 15.4 pour les versions de plateforme suivantes :

  • iOS : 17.5
  • tvOS : 17.5
  • Mac Catalyst : 17.5
  • macOS : 14.5

Pour plus d’informations sur .NET 9 sur iOS, tvOS, Mac Catalyst et macOS, consultez les notes de publication suivantes :

Liaisons

.NET pour iOS 9 introduit la possibilité d’avoir plusieurs versions cibles de .NET pour les liaisons iOS. Par exemple, il peut être nécessaire de générer un projet de bibliothèque pour deux versions d’iOS distinctes :

<TargetFrameworks>net9.0-ios17.0;net9.0-ios17.2</TargetFrameworks>

Cela produit deux bibliothèques : l’une utilisant des liaisons iOS 17.0 et l’autre des liaisons iOS 17.2.

Important

Un projet d’application doit toujours cibler le dernier Kit de développement logiciel (SDK) iOS.

AOT natif pour iOS &Mac Catalyst

Dans .NET pour iOS 9, la compilation anticipée (AOT) native pour iOS et Mac Catalyst tire parti d’un découpage complet pour réduire la taille du package et les performances de démarrage de votre application. Il s’agit d’une fonctionnalité de publication que vous pouvez utiliser lorsque vous êtes prêt à envoyer votre application.

Important

Votre application et ses dépendances doivent être entièrement découpables afin d’utiliser cette fonctionnalité.

Voir aussi