Incorporamento nativo

Esplorare l'esempio

In genere, un'app .NET Multipiattaforma App UI (.NET MAUI) include pagine che contengono layout, ad esempio Grid, e che contengono visualizzazioni, ad esempio Button. Le pagine, i layout e le visualizzazioni derivano tutti da Element. L'incorporamento nativo consente l'uso di tutti i controlli MAUI .NET che derivano da Element da per usare in .NET per Android, .NET per iOS, .NET per Mac Catalyst e app native WinUI.

Il processo per l'utilizzo di un controllo MAUI .NET in un'app nativa è il seguente:

1. Creare un singolo progetto MAUI .NET che contiene l'interfaccia utente MAUI .NET e tutte le dipendenze. Per altre informazioni, vedere Creare un singolo progetto MAUI .NET.
2. Creare un'app nativa e abilitare il supporto di .NET MAUI. Per altre informazioni, vedere Abilitare il supporto MAUI di .NET.
3. Inizializzare .NET MAUI nel progetto di app nativa. Per altre informazioni, vedere Inizializzare .NET MAUI.
4. Creare l'interfaccia utente MAUI .NET e convertirla nel tipo nativo appropriato con il ToPlatformEmbedding metodo di estensione. Per altre informazioni, vedere Utilizzare controlli MAUI .NET.

Nota

Quando si usa l'incorporamento nativo, il motore di data binding di .NET MAUI funziona ancora. Tuttavia, lo spostamento tra le pagine deve essere eseguito usando l'API di spostamento nativa.

Creare un singolo progetto MAUI .NET

Prima di creare un'app nativa che utilizza controlli MAUI .NET, è necessario aggiungere un progetto di app MAUI .NET alla stessa soluzione del progetto di libreria di classi MAUI .NET creato in precedenza. Il progetto di app .NET MAUI archivierà l'interfaccia utente che intendi riutilizzare nell'app incorporata nativa. Dopo aver aggiunto un nuovo progetto di app MAUI .NET alla soluzione, seguire questa procedura:

1. Eliminare la cartella Proprietà dal progetto.

2. Eliminare la cartella Platforms dal progetto.

3. Eliminare la cartella Resources/AppIcon dal progetto.

4. Eliminare la cartella Resources/raw dal progetto.

5. Eliminare la cartella Resources/Splash dal progetto.

6. Eliminare la AppShell classe dal progetto.

7. Assicurarsi che la App classe non imposti la MainPage proprietà o sostituisci il CreateWindow metodo:

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

8. Eliminare la MainPage classe dal progetto.

9. Modificare il file di progetto in modo che la $(TargetFramework) proprietà di compilazione sia impostata su net9.0e che la $(OutputType) proprietà di compilazione venga rimossa:

   <PropertyGroup>
     <TargetFramework>net9.0</TargetFramework>
   
     <RootNamespace>MyMauiApp</RootNamespace>
     <UseMaui>true</UseMaui>
     <SingleProject>true</SingleProject>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   
     ...
   </PropertyGroup>
   

   Importante

   Assicurarsi di impostare la proprietà di $(TargetFramework) compilazione, non la proprietà di$(TargetFrameworks) compilazione.

10. MauiProgram Nella classe modificare il CreateMauiApp metodo per accettare un TApp argomento generico e accettare un argomento facoltativo richiamato Action<MauiAppBuilder> prima della restituzione del metodo. Modificare inoltre la chiamata da UseMauiApp<App> a UseMauiEmbeddedApp<TApp>:

    public static class MauiProgram
    {
        // Create a MauiApp using the specified application.
        public static MauiApp CreateMauiApp<TApp>(Action<MauiAppBuilder>? additional = null) where TApp : App
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiEmbeddedApp<TApp>()
                .ConfigureFonts(fonts =>
                {
                    fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                    fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
                });
    
            #if DEBUG
                builder.Logging.AddDebug();
            #endif
    
            additional?.Invoke(builder);
    
            return builder.Build();
        }
    }
    

11. MauiProgram Nella classe aggiungere un overload che accetta un CreateMauiApp argomento facoltativoAction<MauiAppBuilder>:

    public static class MauiProgram
    {
        ...
    
        // Create a MauiApp using the default application.
        public static MauiApp CreateMauiApp(Action<MauiAppBuilder>? additional = null) =>
            CreateMauiApp<App>(additional);
    }
    

È quindi necessario aggiungere l'interfaccia utente MAUI .NET necessaria al progetto, incluse eventuali dipendenze e risorse, e assicurarsi che il progetto venga compilato correttamente.

Abilitare il supporto DI MAUI per .NET

Per utilizzare i controlli MAUI .NET che derivano da Element in un'app .NET per Android, .NET per iOS, .NET per Mac Catalyst o WinUI, è necessario aggiungere il progetto di app nativa alla stessa soluzione del progetto di libreria di classi .NET MAUI creato in precedenza. È quindi necessario abilitare il supporto MAUI .NET nel file di progetto dell'app nativa impostando le $(UseMaui) proprietà di compilazione e $(MauiEnablePlatformUsings) su true nel primo <PropertyGroup> nodo del file di progetto:

<PropertyGroup>
    ...
    <Nullable>enable</Nullable>
    <ImplicitUsings>true</ImplicitUsings>

    <UseMaui>true</UseMaui>
    <MauiEnablePlatformUsings>true</MauiEnablePlatformUsings>  
</PropertyGroup>

Per le app .NET per Mac Catalyst, è anche necessario impostare la $(SupportedOSPlatformVersion) proprietà di compilazione su almeno 15.0:

<PropertyGroup>
    ...
    <Nullable>enable</Nullable>
    <ImplicitUsings>true</ImplicitUsings>

    <SupportedOSPlatformVersion>15.0</SupportedOSPlatformVersion>
    <UseMaui>true</UseMaui>
    <MauiEnablePlatformUsings>true</MauiEnablePlatformUsings>  
</PropertyGroup>

Per le app WinUI, dovrai anche impostare la proprietà di $(EnableDefaultXamlItems) compilazione su false:

<PropertyGroup>
    ...
    <Nullable>enable</Nullable>
    <ImplicitUsings>true</ImplicitUsings>

    <UseMaui>true</UseMaui>
    <MauiEnablePlatformUsings>true</MauiEnablePlatformUsings>    
    <EnableDefaultXamlItems>false</EnableDefaultXamlItems>
</PropertyGroup>

In questo modo si interrompe la ricezione di errori di compilazione relativi al InitializeComponent metodo già definito.

Aggiungere quindi elementi di compilazione $(PackageReference) al file di progetto per il Microsoft.Maui.Controls pacchetto NuGet:

<ItemGroup>
    <PackageReference Include="Microsoft.Maui.Controls" Version="$(MauiVersion)" />
</ItemGroup>

Inizializzare .NET MAUI

.NET MAUI deve essere inizializzato prima che un progetto di app nativa possa costruire un controllo MAUI .NET. La scelta di quando inizializzarla dipende principalmente da quando è più conveniente nel flusso dell'app. È possibile eseguirla all'avvio o subito prima che venga costruito un controllo MAUI .NET. L'approccio descritto di seguito consiste nell'inizializzare .NET MAUI quando viene creata l'interfaccia utente iniziale dell'app.

L'incorporamento può essere eseguito in un contesto dell'app o in un contesto di finestra, ma per la massima compatibilità MAUI .NET deve essere eseguito in un contesto di finestra.

Contesto dell'app

L'incorporamento nativo può essere eseguito in un contesto dell'app, in cui l'app nativa non ha alcuna conoscenza di una finestra. Con questo approccio, l'inizializzazione dell'incorporamento nativo richiede di:

• Creare un oggetto MauiApp.
• Creare un MauiContext oggetto dall'oggetto MauiApp . L'oggetto MauiContext verrà usato per ottenere una visualizzazione nativa dalla vista MAUI .NET.

L'esempio seguente illustra questo approccio:

var mauiApp = MauiProgram.CreateMauiApp();
var context = new MauiContext(mauiApp.Services); // Activity also needs passing on Android

Una vista MAUI .NET può quindi essere creata e convertita in una visualizzazione nativa con il ToPlatformEmbedded metodo di estensione, che richiede l'oggetto MauiContext come argomento.

Questo approccio è adatto per scenari in cui un'app nativa deve incorporare una semplice interfaccia utente MAUI di .NET, ma non richiede l'accesso a tutte le funzionalità MAUI di .NET. Lo svantaggio di questo approccio è che gli strumenti come il ricaricamento rapido e alcune funzionalità MAUI di .NET non funzioneranno.

Suggerimento

La creazione di un MauiApp oggetto ogni volta che una visualizzazione MAUI .NET viene incorporata come visualizzazione nativa non è consigliata. Questo problema può essere problematico se le visualizzazioni incorporate accedono alla Application.Current proprietà . L'oggetto MauiApp può invece essere creato come istanza statica condivisa:

public static class MyEmbeddedMauiApp
{
    static MauiApp? _shared;
    public static MauiApp Shared => _shared ??= MauiProgram.CreateMauiApp();
}

Con questo approccio, è possibile creare un'istanza dell'oggetto MauiApp all'inizio del ciclo di vita dell'app per evitare un piccolo ritardo la prima volta che si incorpora una visualizzazione MAUI .NET nell'app.

In Android un frammento rappresenta una parte dell'interfaccia utente all'interno di un'attività. L'esempio di codice seguente mostra l'inizializzazione di .NET MAUI in un frammento:

using Android.Runtime;
using Android.Views;
using AndroidX.Navigation.Fragment;
using Microsoft.Maui.Controls.Embedding;
using Fragment = AndroidX.Fragment.App.Fragment;
using View = Android.Views.View;

namespace MyNativeEmbeddedApp.Droid;

[Register("com.companyname.nativeembeddingdemo." + nameof(FirstFragment))]
public class FirstFragment : Fragment
{
    public override View? OnCreateView(LayoutInflater inflater, ViewGroup? container, Bundle? savedInstanceState) =>
        inflater.Inflate(Resource.Layout.fragment_first, container, false);

    public override void OnViewCreated(View view, Bundle? savedInstanceState)
    {
        base.OnViewCreated(view, savedInstanceState);

        // Ensure .NET MAUI app is built before creating .NET MAUI views
        var mauiApp = MyEmbeddedMauiApp.Shared;

        // Create .NET MAUI context
        var context = new MauiContext(mauiApp.Services, Activity);

        ...
    }
}

In iOS e Mac Catalyst, la AppDelegate classe deve essere modificata in modo da restituire true per l'override FinishedLaunching :

namespace MyNativeEmbeddedApp.iOS;

[Register("AppDelegate")]
public class AppDelegate : UIApplicationDelegate
{
    public override UIWindow? Window { get; set; }

    public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions) => true;
}

Il WillConnect metodo nella SceneDelegate classe deve quindi essere modificato per creare il controller di visualizzazione principale e impostarlo come visualizzazione di UINavigationController:

namespace MyNativeEmbeddedApp.iOS;

[Register("SceneDelegate")]
public class SceneDelegate : UIResponder, IUIWindowSceneDelegate
{
    [Export("window")]
    public UIWindow? Window { get; set; }

    [Export("scene:willConnectToSession:options:")]
    public void WillConnect(UIScene scene, UISceneSession session, UISceneConnectionOptions connectionOptions)
    {
        if (scene is not UIWindowScene windowScene)
            return;

        Window = new UIWindow(windowScene);

        var mainVC = new MainViewController();
        var navigationController = new UINavigationController(mainVC);
        navigationController.NavigationBar.PrefersLargeTitles = true;

        Window.RootViewController = navigationController;
        Window.MakeKeyAndVisible();
    }

    ...
}

Quindi, nell'editor XML aprire il file Info.plist e aggiungere il codice XML seguente alla fine del file:

<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationSupportsMultipleScenes</key>
  <true/>
  <key>UISceneConfigurations</key>
  <dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>Default Configuration</string>
        <key>UISceneDelegateClassName</key>
        <string>SceneDelegate</string>
      </dict>
    </array>
  </dict>
</dict>

.NET MAUI può quindi essere inizializzato nel ViewDidLoad metodo nel controller di visualizzazione principale:

using Microsoft.Maui.Controls.Embedding;

namespace MyNativeEmbeddedApp.iOS;

public class MainViewController : UIViewController
{
    public override void ViewDidLoad()
    {
        base.ViewDidLoad();

        // Ensure .NET MAUI app is built before creating .NET MAUI views
        var mauiApp = MyEmbeddedMauiApp.Shared;

        // Create .NET MAUI context
        var context = new MauiContext(mauiApp.Services);

        ...
    }
}

In Windows la MainWindow classe è in genere la posizione in cui eseguire attività di avvio dell'app correlate all'interfaccia utente:

using Microsoft.Maui.Controls.Embedding;
using Microsoft.UI.Xaml;

namespace MyNativeEmbeddedApp.WinUI;

public sealed partial class MainWindow : Microsoft.UI.Xaml.Window
{
    public MainWindow()
    {
        this.InitializeComponent();
    }

    private async void OnRootLayoutLoaded(object? sender, RoutedEventArgs e)
    {
        await Task.Yield();

        // Ensure .NET MAUI app is built before creating .NET MAUI views
        var mauiApp = MyEmbeddedMauiApp.Shared;

        // Create .NET MAUI context
        var context = new MauiContext(mauiApp.Services);

        ...
    }
}

In questo esempio l'oggetto MauiApp viene creato come istanza statica condivisa. Quando questo oggetto viene creato, MauiProgram.CreateMauiApp viene chiamato che a sua volta chiama il UseMauiEmbedding metodo di estensione sull'oggetto MauiAppBuilder . Di conseguenza, il progetto di app nativa deve includere un riferimento al progetto di libreria di classi MAUI .NET creato che contiene la MauiProgram classe e l'interfaccia utente MAUI .NET. Viene MauiContext quindi creato un oggetto dall'oggetto MauiApp , con ambito all'oggetto MauiApp . L'oggetto MauiContext verrà usato durante la conversione dei controlli MAUI .NET in tipi nativi.

Contesto finestra

L'incorporamento nativo può essere eseguito in un contesto di finestra, in cui l'app nativa ha una conoscenza di una finestra. In alcuni scenari, le viste MAUI .NET richiedono l'accesso a una finestra per funzionare correttamente. Ad esempio, i trigger adattivi richiedono l'accesso alla finestra di una visualizzazione e, se non sono presenti finestre, non funzionano.

Con questo approccio, l'inizializzazione dell'incorporamento nativo richiede di:

• Creare un oggetto MauiApp.
• Creare un MauiContext oggetto con il CreateEmbeddedWindowContext metodo . L'oggetto MauiContext verrà usato per ottenere una visualizzazione nativa dalla vista MAUI .NET.

Il CreateEmbeddedWindowContext metodo crea un contesto di finestra che correla una finestra nativa a una finestra MAUI .NET:

var mauiApp = MauiProgram.CreateMauiApp();
var context = mauiApp.CreateEmbeddedWindowContext(this);

Una vista MAUI .NET può quindi essere creata e convertita in una visualizzazione nativa con il ToPlatformEmbedded metodo di estensione, che richiede l'oggetto MauiContext come argomento.

Nota

Il ToPlatformEmbedded metodo di estensione dispone di un overload che aggiunge una visualizzazione MAUI .NET a una finestra incorporata.

Il vantaggio di questo approccio è che è disponibile una singola finestra MAUI .NET per ogni finestra nativa, le API correlate alla finestra funzioneranno correttamente e gli strumenti come il ricaricamento rapido funzionano correttamente.

Suggerimento

La creazione di un MauiApp oggetto ogni volta che una visualizzazione MAUI .NET viene incorporata come visualizzazione nativa non è consigliata. Questo problema può essere problematico se le visualizzazioni incorporate accedono alla Application.Current proprietà . L'oggetto MauiApp può invece essere creato come istanza statica condivisa:

public static class MyEmbeddedMauiApp
{
    static MauiApp? _shared;
    public static MauiApp Shared => _shared ??= MauiProgram.CreateMauiApp();
}

Con questo approccio, è possibile creare un'istanza dell'oggetto MauiApp all'inizio del ciclo di vita dell'app per evitare un piccolo ritardo la prima volta che si incorpora una visualizzazione MAUI .NET nell'app.

In Android un frammento rappresenta una parte dell'interfaccia utente all'interno di un'attività. L'esempio di codice seguente mostra l'inizializzazione di .NET MAUI in un frammento:

using Android.Runtime;
using Android.Views;
using AndroidX.Navigation.Fragment;
using Microsoft.Maui.Controls.Embedding;
using Fragment = AndroidX.Fragment.App.Fragment;
using View = Android.Views.View;

namespace MyNativeEmbeddedApp.Droid;

[Register("com.companyname.nativeembeddingdemo." + nameof(FirstFragment))]
public class FirstFragment : Fragment
{
    Activity? _window;
    IMauiContext? _windowContext;

    public IMauiContext WindowContext =>
        _windowContext ??= MyEmbeddedMauiApp.Shared.CreateEmbeddedWindowContext(_window ?? throw new InvalidOperationException());

    public override View? OnCreateView(LayoutInflater inflater, ViewGroup? container, Bundle? savedInstanceState) =>
        inflater.Inflate(Resource.Layout.fragment_first, container, false);

    public override void OnViewCreated(View view, Bundle? savedInstanceState)
    {
        base.OnViewCreated(view, savedInstanceState);

        _window ??= Activity;

        // Create MAUI embedded window context
        var context = WindowContext;

        ...
    }
}

In iOS e Mac Catalyst, la AppDelegate classe deve essere modificata in modo da restituire true per l'override FinishedLaunching :

namespace MyNativeEmbeddedApp.iOS;

[Register("AppDelegate")]
public class AppDelegate : UIApplicationDelegate
{
    public override UIWindow? Window { get; set; }

    public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions) => true;
}

Il WillConnect metodo nella SceneDelegate classe deve quindi essere modificato per creare il controller di visualizzazione principale e impostarlo come visualizzazione di UINavigationController:

namespace MyNativeEmbeddedApp.iOS;

[Register("SceneDelegate")]
public class SceneDelegate : UIResponder, IUIWindowSceneDelegate
{
    [Export("window")]
    public UIWindow? Window { get; set; }

    [Export("scene:willConnectToSession:options:")]
    public void WillConnect(UIScene scene, UISceneSession session, UISceneConnectionOptions connectionOptions)
    {
        if (scene is not UIWindowScene windowScene)
            return;

        Window = new UIWindow(windowScene);

        var mainVC = new MainViewController();
        var navigationController = new UINavigationController(mainVC);
        navigationController.NavigationBar.PrefersLargeTitles = true;

        Window.RootViewController = navigationController;
        Window.MakeKeyAndVisible();
    }

    ...
}

Quindi, nell'editor XML aprire il file Info.plist e aggiungere il codice XML seguente alla fine del file:

<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationSupportsMultipleScenes</key>
  <true/>
  <key>UISceneConfigurations</key>
  <dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>Default Configuration</string>
        <key>UISceneDelegateClassName</key>
        <string>SceneDelegate</string>
      </dict>
    </array>
  </dict>
</dict>

.NET MAUI può quindi essere inizializzato nel ViewDidLoad metodo nel controller di visualizzazione principale:

using Microsoft.Maui.Controls.Embedding;

namespace MyNativeEmbeddedApp.iOS;

public class MainViewController : UIViewController
{
    UIKit.UIWindow? _window;
    IMauiContext? _windowContext;

    public IMauiContext WindowContext =>
        _windowContext ??= MyEmbeddedMauiApp.Shared.CreateEmbeddedWindowContext(_window ?? throw new InvalidOperationException());

    public override void ViewDidLoad()
    {
        base.ViewDidLoad();

        _window ??= ParentViewController!.View!.Window;

        // Create MAUI embedded window context
        var context = WindowContext;

        ...
    }
}

In Windows la MainWindow classe è in genere la posizione in cui eseguire attività di avvio dell'app correlate all'interfaccia utente:

using Microsoft.Maui.Controls.Embedding;
using Microsoft.UI.Xaml;

namespace MyNativeEmbeddedApp.WinUI;

public sealed partial class MainWindow : Microsoft.UI.Xaml.Window
{
    Microsoft.UI.Xaml.Window? _window;
    IMauiContext? _windowContext;

    public IMauiContext WindowContext =>
        _windowContext ??= MyEmbeddedMauiApp.Shared.CreateEmbeddedWindowContext(_window ?? throw new InvalidOperationException());

    public MainWindow()
    {
        this.InitializeComponent();
        _window ??= this;
    }

    private async void OnRootLayoutLoaded(object? sender, RoutedEventArgs e)
    {
        await Task.Yield();

        // Create MAUI embedded window context
        var context = WindowContext;

        ...
    }
}

In questo esempio l'oggetto MauiApp viene creato come istanza statica condivisa. Quando questo oggetto viene creato, MauiProgram.CreateMauiApp viene chiamato che a sua volta chiama il UseMauiEmbedding metodo di estensione sull'oggetto MauiAppBuilder . Di conseguenza, il progetto di app nativa deve includere un riferimento al progetto di libreria di classi MAUI .NET creato che contiene la MauiProgram classe e l'interfaccia utente MAUI .NET. Viene MauiContext quindi creato un oggetto con il CreateEmbeddedWindowContext metodo , che ha come ambito la finestra. L'oggetto MauiContext verrà usato durante la conversione dei controlli MAUI .NET in tipi nativi.

Utilizzare controlli MAUI .NET

Dopo l'inizializzazione di .NET MAUI nell'app nativa, è possibile aggiungere l'interfaccia utente MAUI .NET al layout dell'app nativa. A tale scopo, è possibile creare un'istanza dell'interfaccia utente e convertirla nel tipo nativo appropriato con il ToPlatformEmbedded metodo di estensione.

In Android, il ToPlatformEmbedded metodo di estensione converte il controllo MAUI .NET in un oggetto Android View :

var mauiView = new MyMauiContent();
Android.Views.View nativeView = mauiView.ToPlatformEmbedded(context);

In questo esempio un ContentViewoggetto derivato da viene convertito in un oggetto Android View .

Nota

Il ToPlatformEmbedded metodo di estensione si trova nello spazio dei Microsoft.Maui.Controls.Embedding nomi . Di conseguenza, il progetto di app nativa deve includere un'istruzione using per tale spazio dei nomi.

L'oggetto View può quindi essere aggiunto a un layout nell'app nativa:

rootLayout.AddView(nativeView, new LinearLayout.LayoutParams(MatchParent, WrapContent));

In iOS e Mac Catalyst il ToPlatformEmbedded metodo di estensione converte il controllo MAUI .NET in un UIView oggetto :

var mauiView = new MyMauiContent();
UIView nativeView = mauiView.ToPlatformEmbedded(context);

In questo esempio un ContentViewoggetto derivato da viene convertito in un UIView oggetto .

Nota

Il ToPlatformEmbedded metodo di estensione si trova nello spazio dei Microsoft.Maui.Controls.Embedding nomi . Di conseguenza, il progetto di app nativa deve includere un'istruzione using per tale spazio dei nomi.

L'oggetto UIView può quindi essere aggiunto a una visualizzazione nel controller di visualizzazione:

stackView.AddArrangedSubView(new ContainerView(nativeView));

ContainerView è un tipo personalizzato che esegue il wrapping della visualizzazione MAUI .NET per assicurarsi che venga ridimensionato correttamente. A tale scopo, si esegue il reindirizzamento IntrinsicContentSize alla vista MAUI di SizeThatFits.NET:

class ContainerView : UIView
{
    public ContainerView(UIView view)
    {
        AddSubview(view);
    }

    public override CGSize IntrinsicContentSize =>
        SizeThatFits(new CGSize(nfloat.MaxValue, nfloat.MaxValue));

    public override CGSize SizeThatFits(CGSize size) =>
        Subviews?.FirstOrDefault()?.SizeThatFits(size) ?? CGSize.Empty;

    public override void LayoutSubviews()
    {
        if (Subviews?.FirstOrDefault() is { } view)
            view.Frame = Bounds;
    }

    public override void SetNeedsLayout()
    {
        base.SetNeedsLayout();
          InvalidateIntrinsicContentSize();
    }
}

È anche possibile usare un ToUIViewController metodo di estensione in .NET MAUI per convertire una pagina MAUI .NET in :UIViewController

MyMauiPage myMauiPage = new MyMauiPage();
UIViewController myPageController = myMauiPage.ToUIViewController(context);

In questo esempio un ContentPageoggetto derivato da viene convertito in un oggetto UIViewController.

In Windows il ToPlatformEmbedded metodo di estensione converte il controllo MAUI .NET in un FrameworkElement oggetto :

var mauiView = new MyMauiContent();
FrameworkElement nativeView = myMauiPage.ToPlatformEmbedded(context);

In questo esempio un ContentViewoggetto derivato da viene convertito in un FrameworkElement oggetto . L'oggetto FrameworkElement può quindi essere impostato come contenuto di una pagina WinUI.

Nota

Il ToPlatformEmbedded metodo di estensione si trova nello spazio dei Microsoft.Maui.Controls.Embedding nomi . Di conseguenza, il progetto di app nativa deve includere un'istruzione using per tale spazio dei nomi.

L'oggetto FrameworkElement può quindi essere aggiunto a un layout nell'app nativa:

stackPanel.Children.Add(nativeView);