Osadzanie natywne

Przeglądanie przykładu

Zazwyczaj aplikacja interfejsu użytkownika aplikacji wieloplatformowej platformy .NET (.NET MAUI) zawiera strony zawierające układy, takie jak Grid, i zawierające widoki, takie jak Button. Wszystkie strony, układy i widoki pochodzą z elementu Element. Osadzanie natywne umożliwia korzystanie z dowolnych kontrolek MAUI platformy .NET, które pochodzą z Element platformy .NET dla systemów Android, .NET dla systemów iOS, .NET dla komputerów Mac Catalyst i WinUI natywnych.

Proces korzystania z kontrolki MAUI platformy .NET w aplikacji natywnej jest następujący:

1. Utwórz pojedynczy projekt MAUI platformy .NET, który zawiera interfejs użytkownika .NET MAUI i wszelkie zależności. Aby uzyskać więcej informacji, zobacz Create a .NET MAUI single project (Tworzenie pojedynczego projektu .NET MAUI).
2. Utwórz aplikację natywną i włącz w niej obsługę interfejsu MAUI platformy .NET. Aby uzyskać więcej informacji, zobacz Włączanie obsługi interfejsu MAUI platformy .NET.
3. Zainicjuj interfejs MAUI platformy .NET w projekcie aplikacji natywnej. Aby uzyskać więcej informacji, zobacz Inicjowanie interfejsu MAUI platformy .NET.
4. Utwórz interfejs użytkownika .NET MAUI i przekonwertuj go na odpowiedni typ natywny za ToPlatformEmbedding pomocą metody rozszerzenia. Aby uzyskać więcej informacji, zobacz Korzystanie z kontrolek MAUI platformy .NET.

Uwaga

W przypadku korzystania z natywnego osadzania aparat powiązania danych programu .NET MAUI nadal działa. Jednak nawigacja po stronie musi być wykonywana przy użyciu natywnego interfejsu API nawigacji.

Tworzenie pojedynczego projektu MAUI platformy .NET

Przed utworzeniem aplikacji natywnej, która korzysta z kontrolek MAUI platformy .NET, należy dodać projekt aplikacji .NET MAUI do tego samego rozwiązania co utworzony wcześniej projekt biblioteki klas .NET MAUI. Projekt aplikacji .NET MAUI będzie przechowywać interfejs użytkownika, który zamierzasz ponownie używać w natywnej aplikacji osadzonej. Po dodaniu nowego projektu aplikacji .NET MAUI do rozwiązania wykonaj następujące kroki:

1. Usuń folder Properties z projektu.

2. Usuń folder Platformy z projektu.

3. Usuń folder Resources/AppIcon z projektu.

4. Usuń folder Resources/raw z projektu.

5. Usuń folder Resources/Splash z projektu.

6. Usuń klasę AppShell z projektu.

7. Upewnij się, App że klasa nie ustawia MainPage właściwości ani nie zastępuje CreateWindow metody :

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

8. Usuń klasę MainPage z projektu.

9. Zmodyfikuj plik projektu, aby $(TargetFramework) właściwość kompilacji została ustawiona na net9.0, a właściwość kompilacji została usunięta $(OutputType) :

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

   Ważne

   Upewnij się, że ustawiono właściwość kompilacji $(TargetFramework) , a nie właściwość kompilacji$(TargetFrameworks) .

10. W klasie zmodyfikuj MauiProgram metodę TApp tak, aby akceptowała CreateMauiApp argument ogólny i zaakceptuj opcjonalny Action<MauiAppBuilder> argument wywoływany przed zwróceniem metody. Ponadto zmień wywołanie z UseMauiApp<App> na 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 W klasie dodaj CreateMauiApp przeciążenie, które akceptuje opcjonalny Action<MauiAppBuilder> argument:

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

Następnie należy dodać wymagany interfejs użytkownika .NET MAUI do projektu, w tym wszelkie zależności i zasoby, i upewnić się, że projekt jest kompilowany poprawnie.

Włączanie obsługi interfejsu MAUI platformy .NET

Aby korzystać z kontrolek MAUI platformy .NET, które pochodzą z Element platformy .NET dla systemu Android, .NET dla systemów iOS, .NET dla komputerów Mac Catalyst lub aplikacji WinUI, należy dodać projekt aplikacji natywnej do tego samego rozwiązania co utworzony wcześniej projekt biblioteki klas .NET MAUI. Następnie należy włączyć obsługę .NET MAUI w pliku projektu aplikacji natywnej, ustawiając $(UseMaui) właściwości i $(MauiEnablePlatformUsings) kompilacji na true w pierwszym <PropertyGroup> węźle w pliku projektu:

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

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

W przypadku aplikacji .NET for Mac Catalyst należy również ustawić właściwość kompilacji $(SupportedOSPlatformVersion) na co najmniej 15.0:

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

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

W przypadku aplikacji WinUI należy również ustawić $(EnableDefaultXamlItems) właściwość build na :false

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

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

Spowoduje to zatrzymanie otrzymywania błędów kompilacji dotyczących już zdefiniowanej InitializeComponent metody.

Następnie dodaj $(PackageReference) elementy kompilacji do pliku projektu dla Microsoft.Maui.Controls pakietu NuGet:

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

Inicjowanie interfejsu MAUI platformy .NET

Aby projekt aplikacji natywnej mógł utworzyć kontrolkę .NET MAUI, należy zainicjować program .NET MAUI. Wybór, kiedy zainicjować go przede wszystkim zależy od tego, kiedy jest on najbardziej wygodny w przepływie aplikacji — może zostać wykonany podczas uruchamiania lub tuż przed skonstruowaniem kontrolki MAUI platformy .NET. Podejście opisane tutaj polega na zainicjowaniu interfejsu użytkownika platformy .NET MAUI podczas tworzenia początkowego interfejsu użytkownika aplikacji.

Osadzanie można wykonać w kontekście aplikacji lub w kontekście okna, ale w celu zapewnienia maksymalnej zgodności programu MAUI platformy .NET należy wykonać je w kontekście okna.

Kontekst aplikacji

Osadzanie natywne można wykonać w kontekście aplikacji, gdzie aplikacja natywna nie zna okna. W przypadku tego podejścia inicjowanie osadzania natywnego wymaga wykonania następujących czynności:

• Utwórz MauiApp obiekt.
• Utwórz MauiContext obiekt na MauiApp podstawie obiektu. Obiekt MauiContext zostanie użyty do uzyskania widoku natywnego z widoku MAUI platformy .NET.

W poniższym przykładzie przedstawiono to podejście:

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

Następnie można utworzyć i przekonwertować widok MAUI platformy .NET na widok macierzysty za pomocą ToPlatformEmbedded metody rozszerzenia, która wymaga MauiContext obiektu jako argumentu.

Takie podejście jest odpowiednie w scenariuszach, w których aplikacja natywna musi osadzić prosty interfejs użytkownika maui platformy .NET, ale nie wymaga dostępu do wszystkich funkcji maui platformy .NET. Wadą tego podejścia jest to, że narzędzia, takie jak przeładowywanie na gorąco, i niektóre funkcje programu .NET MAUI, nie będą działać.

Napiwek

MauiApp Tworzenie obiektu za każdym razem, gdy widok MAUI platformy .NET jest osadzony jako widok macierzysty, nie jest zalecany. Może to być problematyczne, jeśli widoki osadzone uzyskują dostęp do Application.Current właściwości. MauiApp Zamiast tego obiekt można utworzyć jako udostępnione wystąpienie statyczne:

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

Dzięki temu podejściu MauiApp można utworzyć wystąpienie obiektu na wczesnym etapie cyklu życia aplikacji, aby uniknąć małego opóźnienia podczas pierwszego osadzania widoku MAUI platformy .NET w aplikacji.

W systemie Android fragment reprezentuje część interfejsu użytkownika w ramach działania. Poniższy przykład kodu przedstawia zainicjowanie interfejsu MAUI platformy .NET w fragmencie:

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);

        ...
    }
}

W systemach iOS i Mac Catalyst należy zmodyfikować klasę w AppDelegate celu zwrócenia true przesłonięcia 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;
}

WillConnect Następnie należy zmodyfikować metodę w SceneDelegate klasie w celu utworzenia głównego kontrolera widoku i ustawić ją jako widok elementu 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();
    }

    ...
}

Następnie w edytorze XML otwórz plik Info.plist i dodaj następujący kod XML na końcu pliku:

<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>

Program .NET MAUI można następnie zainicjować w metodzie ViewDidLoad w głównym kontrolerze widoku:

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);

        ...
    }
}

W systemie Windows MainWindow klasa jest zazwyczaj miejscem do wykonywania zadań uruchamiania aplikacji związanych z interfejsem użytkownika:

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);

        ...
    }
}

W tym przykładzie MauiApp obiekt jest tworzony jako udostępnione wystąpienie statyczne. Po utworzeniu tego obiektu jest wywoływany, MauiProgram.CreateMauiApp który z kolei wywołuje metodę UseMauiEmbedding rozszerzenia w MauiAppBuilder obiekcie. W związku z tym projekt aplikacji natywnej powinien zawierać odwołanie do utworzonego projektu biblioteki klas .NET MAUI zawierającego MauiProgram klasę i interfejs użytkownika maui platformy .NET. Następnie MauiContext obiekt jest tworzony na podstawie MauiApp obiektu, który jest o określonym zakresie do MauiApp obiektu. Obiekt MauiContext będzie używany podczas konwertowania kontrolek MAUI platformy .NET na typy natywne.

Kontekst okna

Osadzanie natywne można wykonać w kontekście okna, w którym aplikacja natywna ma wiedzę na temat okna. W niektórych scenariuszach widoki MAUI platformy .NET wymagają dostępu do okna w celu poprawnego działania. Na przykład wyzwalacze adaptacyjne wymagają dostępu do okna widoku, a jeśli nie ma okna, nie działają.

W przypadku tego podejścia inicjowanie osadzania natywnego wymaga wykonania następujących czynności:

• Utwórz MauiApp obiekt.
• MauiContext Utwórz obiekt za pomocą CreateEmbeddedWindowContext metody . Obiekt MauiContext zostanie użyty do uzyskania widoku natywnego z widoku MAUI platformy .NET.

Metoda CreateEmbeddedWindowContext tworzy kontekst okna, który wiąże okno natywne z oknem .NET MAUI:

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

Następnie można utworzyć i przekonwertować widok MAUI platformy .NET na widok macierzysty za pomocą ToPlatformEmbedded metody rozszerzenia, która wymaga MauiContext obiektu jako argumentu.

Uwaga

Metoda ToPlatformEmbedded rozszerzenia ma przeciążenie, które dodaje widok MAUI platformy .NET do okna osadzonego.

Zaletą tego podejścia jest to, że istnieje jedno okno MAUI platformy .NET dla każdego okna natywnego, interfejsy API związane z oknem będą działać poprawnie, a narzędzia, takie jak ponowne ładowanie na gorąco, działa poprawnie.

Napiwek

MauiApp Tworzenie obiektu za każdym razem, gdy widok MAUI platformy .NET jest osadzony jako widok macierzysty, nie jest zalecany. Może to być problematyczne, jeśli widoki osadzone uzyskują dostęp do Application.Current właściwości. MauiApp Zamiast tego obiekt można utworzyć jako udostępnione wystąpienie statyczne:

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

Dzięki temu podejściu MauiApp można utworzyć wystąpienie obiektu na wczesnym etapie cyklu życia aplikacji, aby uniknąć małego opóźnienia podczas pierwszego osadzania widoku MAUI platformy .NET w aplikacji.

W systemie Android fragment reprezentuje część interfejsu użytkownika w ramach działania. Poniższy przykład kodu przedstawia zainicjowanie interfejsu MAUI platformy .NET w fragmencie:

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;

        ...
    }
}

W systemach iOS i Mac Catalyst należy zmodyfikować klasę w AppDelegate celu zwrócenia true przesłonięcia 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;
}

WillConnect Następnie należy zmodyfikować metodę w SceneDelegate klasie w celu utworzenia głównego kontrolera widoku i ustawić ją jako widok elementu 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();
    }

    ...
}

Następnie w edytorze XML otwórz plik Info.plist i dodaj następujący kod XML na końcu pliku:

<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>

Program .NET MAUI można następnie zainicjować w metodzie ViewDidLoad w głównym kontrolerze widoku:

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;

        ...
    }
}

W systemie Windows MainWindow klasa jest zazwyczaj miejscem do wykonywania zadań uruchamiania aplikacji związanych z interfejsem użytkownika:

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;

        ...
    }
}

W tym przykładzie MauiApp obiekt jest tworzony jako udostępnione wystąpienie statyczne. Po utworzeniu tego obiektu jest wywoływany, MauiProgram.CreateMauiApp który z kolei wywołuje metodę UseMauiEmbedding rozszerzenia w MauiAppBuilder obiekcie. W związku z tym projekt aplikacji natywnej powinien zawierać odwołanie do utworzonego projektu biblioteki klas .NET MAUI zawierającego MauiProgram klasę i interfejs użytkownika maui platformy .NET. Następnie MauiContext obiekt jest tworzony za CreateEmbeddedWindowContext pomocą metody , która jest ograniczona do okna. Obiekt MauiContext będzie używany podczas konwertowania kontrolek MAUI platformy .NET na typy natywne.

Korzystanie z kontrolek MAUI platformy .NET

Po zainicjowaniu interfejsu użytkownika .NET MAUI w aplikacji natywnej możesz dodać interfejs użytkownika maui platformy .NET do układu aplikacji natywnej. Można to osiągnąć, tworząc wystąpienie interfejsu użytkownika i konwertując go na odpowiedni typ natywny za ToPlatformEmbedded pomocą metody rozszerzenia.

W systemie Android ToPlatformEmbedded metoda rozszerzenia konwertuje kontrolkę .NET MAUI na obiekt systemu Android View :

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

W tym przykładzie ContentViewobiekt pochodny jest konwertowany na obiekt systemu Android View .

Uwaga

Metoda ToPlatformEmbedded rozszerzenia znajduje się w Microsoft.Maui.Controls.Embedding przestrzeni nazw. W związku z tym projekt aplikacji natywnej powinien zawierać instrukcję using dla tej przestrzeni nazw.

Obiekt View można następnie dodać do układu w aplikacji natywnej:

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

W systemach iOS i Mac Catalyst ToPlatformEmbedded metoda rozszerzenia konwertuje kontrolkę UIView .NET MAUI na obiekt:

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

W tym przykładzie ContentViewobiekt pochodny jest konwertowany na UIView obiekt.

Uwaga

Metoda ToPlatformEmbedded rozszerzenia znajduje się w Microsoft.Maui.Controls.Embedding przestrzeni nazw. W związku z tym projekt aplikacji natywnej powinien zawierać instrukcję using dla tej przestrzeni nazw.

Obiekt UIView można następnie dodać do widoku na kontrolerze widoku:

stackView.AddArrangedSubView(new ContainerView(nativeView));

ContainerView jest typem niestandardowym, który opakowuje widok MAUI platformy .NET, aby upewnić się, że rozmiar jest poprawny. Jest to osiągane przez przekierowanie IntrinsicContentSize do widoku .NET MAUI:SizeThatFits

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();
    }
}

Ponadto ToUIViewController można użyć metody rozszerzenia w programie .NET MAUI w celu przekonwertowania strony .NET MAUI na :UIViewController

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

W tym przykładzie ContentPageobiekt -pochodny jest konwertowany na UIViewControllerobiekt .

W systemie Windows ToPlatformEmbedded metoda rozszerzenia konwertuje kontrolkę FrameworkElement .NET MAUI na obiekt:

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

W tym przykładzie ContentViewobiekt pochodny jest konwertowany na FrameworkElement obiekt. Następnie FrameworkElement obiekt można ustawić jako zawartość strony WinUI.

Uwaga

Metoda ToPlatformEmbedded rozszerzenia znajduje się w Microsoft.Maui.Controls.Embedding przestrzeni nazw. W związku z tym projekt aplikacji natywnej powinien zawierać instrukcję using dla tej przestrzeni nazw.

Obiekt FrameworkElement można następnie dodać do układu w aplikacji natywnej:

stackPanel.Children.Add(nativeView);