Condividi tramite

Richiamare il codice della piattaforma

  • Articolo

Esplorare l'esempio. Esplorare l'esempio

In situazioni in cui l'interfaccia utente dell'app multipiattaforma .NET (.NET MAUI) non fornisce API per accedere a API di piattaforma specifiche, è possibile scrivere il proprio codice per accedere alle API della piattaforma necessarie. Ciò richiede la conoscenza delle API iOS e MacCatalyst di Apple, delle API Android di Google e delle API di Microsoft SDK per app di Windows.

Il codice della piattaforma può essere richiamato dal codice multipiattaforma usando la compilazione condizionale o usando classi parziali e metodi parziali.

Compilazione condizionale

Il codice della piattaforma può essere richiamato dal codice multipiattaforma usando la compilazione condizionale per indirizzare piattaforme diverse.

Nell'esempio seguente viene illustrata l'enumerazione, che verrà usata per specificare l'orientamento DeviceOrientation del dispositivo:

namespace InvokePlatformCodeDemos.Services
{
    public enum DeviceOrientation
    {
        Undefined,
        Landscape,
        Portrait
    }
}

Il recupero dell'orientamento del dispositivo richiede la scrittura del codice della piattaforma. Questa operazione può essere eseguita scrivendo un metodo che usa la compilazione condizionale per indirizzare piattaforme diverse:

#if ANDROID
using Android.Content;
using Android.Views;
using Android.Runtime;
#elif IOS
using UIKit;
#endif

using InvokePlatformCodeDemos.Services;

namespace InvokePlatformCodeDemos.Services.ConditionalCompilation
{
    public class DeviceOrientationService
    {
        public DeviceOrientation GetOrientation()
        {
#if ANDROID
            IWindowManager windowManager = Android.App.Application.Context.GetSystemService(Context.WindowService).JavaCast<IWindowManager>();
            SurfaceOrientation orientation = windowManager.DefaultDisplay.Rotation;
            bool isLandscape = orientation == SurfaceOrientation.Rotation90 || orientation == SurfaceOrientation.Rotation270;
            return isLandscape ? DeviceOrientation.Landscape : DeviceOrientation.Portrait;
#elif IOS
            UIInterfaceOrientation orientation = UIApplication.SharedApplication.StatusBarOrientation;
            bool isPortrait = orientation == UIInterfaceOrientation.Portrait || orientation == UIInterfaceOrientation.PortraitUpsideDown;
            return isPortrait ? DeviceOrientation.Portrait : DeviceOrientation.Landscape;
#else
            return DeviceOrientation.Undefined;
#endif
        }
    }
}

In questo esempio vengono fornite implementazioni della piattaforma del GetOrientation metodo per Android e iOS. In altre piattaforme viene DeviceOrientation.Undefined restituito. In alternativa, invece di restituire DeviceOrientation.Undefined è possibile generare un PlatformNotSupportedException oggetto che specifica le piattaforme per cui vengono fornite le implementazioni:

throw new PlatformNotSupportedException("GetOrientation is only supported on Android and iOS.");

Il DeviceOrientationService.GetOrientation metodo può quindi essere richiamato dal codice multipiattaforma creando un'istanza dell'oggetto e richiamandone l'operazione:

using InvokePlatformCodeDemos.Services;
using InvokePlatformCodeDemos.Services.ConditionalCompilation;
...

DeviceOrientationService deviceOrientationService = new DeviceOrientationService();
DeviceOrientation orientation = deviceOrientationService.GetOrientation();

In fase di compilazione il sistema di compilazione usa la compilazione condizionale per indirizzare il codice della piattaforma Android e iOS alla piattaforma corretta.

Per altre informazioni sulla compilazione condizionale, vedere Compilazione condizionale.

Classi e metodi parziali

Un progetto di app .NET MAUI contiene una cartella Platform , con ogni cartella figlio che rappresenta una piattaforma a cui .NET MAUI può essere destinato:

Screenshot delle cartelle della piattaforma.

Le cartelle per ogni piattaforma di destinazione contengono codice specifico della piattaforma che avvia l'app in ogni piattaforma, oltre a qualsiasi codice aggiuntivo della piattaforma aggiunto. In fase di compilazione, il sistema di compilazione include solo il codice di ogni cartella durante la compilazione per tale piattaforma specifica. Ad esempio, quando si compila per Android i file nella cartella PlatformAndroid verranno incorporati nel pacchetto dell'app, ma i file nelle altre cartelle Piattaforme> non saranno. Questo approccio usa una funzionalità denominata multi-targeting per la destinazione di più piattaforme da un singolo progetto.

Il multi-targeting può essere combinato con classi parziali e metodi parziali per richiamare la funzionalità della piattaforma dal codice multipiattaforma. Il processo per eseguire questa operazione consiste nel:

  1. Definire l'API multipiattaforma come classe parziale che definisce firme di metodo parziali per tutte le operazioni che si desidera richiamare in ogni piattaforma. Per altre informazioni, vedere Definire l'API multipiattaforma.
  2. Implementare l'API multipiattaforma per piattaforma, definendo la stessa classe parziale e le stesse firme parziali del metodo, fornendo anche le implementazioni del metodo. Per altre informazioni, vedere Implementare l'API per piattaforma.
  3. Richiamare l'API multipiattaforma creando un'istanza della classe parziale e richiamandone i metodi in base alle esigenze. Per altre informazioni, vedere Richiamare l'API multipiattaforma.

Definire l'API multipiattaforma

Per richiamare il codice della piattaforma dal codice multipiattaforma, il primo passaggio consiste nel definire l'API multipiattaforma come classe parziale che definisce le firme del metodo parziale per tutte le operazioni che si desidera richiamare in ogni piattaforma.

Nell'esempio seguente viene illustrata l'enumerazione, che verrà usata per specificare l'orientamento DeviceOrientation del dispositivo:

namespace InvokePlatformCodeDemos.Services
{
    public enum DeviceOrientation
    {
        Undefined,
        Landscape,
        Portrait
    }
}

Nell'esempio seguente viene illustrata un'API multipiattaforma che può essere usata per recuperare l'orientamento di un dispositivo:

namespace InvokePlatformCodeDemos.Services.PartialMethods
{
    public partial class DeviceOrientationService
    {
        public partial DeviceOrientation GetOrientation();
    }
}

La classe parziale è denominata DeviceOrientationService, che include un metodo parziale denominato GetOrientation. Il file di codice per questa classe deve essere esterno alla cartella Platform :

Classe DeviceOrientationService nella schermata della cartella Services.

Implementare l'API per piattaforma

Dopo aver definito l'API multipiattaforma, deve essere implementata in tutte le piattaforme destinate definendo la stessa classe parziale e le stesse firme del metodo parziale, fornendo anche le implementazioni del metodo.

Le implementazioni della piattaforma devono essere inserite nelle cartelle figlio di Piattaforme corrette per garantire che il sistema di compilazione tenti solo di compilare il codice della piattaforma durante la compilazione per la piattaforma specifica. Nella tabella seguente sono elencati i percorsi predefiniti delle cartelle per le implementazioni della piattaforma:

Piattaforma Cartella
Android Piattaforme>Android
iOS Piattaforme>Ios
MacCatalyst Piattaforme>MacCatalyst
Tizen Piattaforme>Tizen
Windows Piattaforme>Finestre

Importante

Le implementazioni della piattaforma devono trovarsi nello stesso spazio dei nomi e nella stessa classe in cui è stata definita l'API multipiattaforma.

Lo screenshot seguente mostra le DeviceOrientationService classi nelle cartelle Android e iOS :

Classi DeviceOrientationService nello screenshot della cartella Platform.

In alternativa, è possibile eseguire multi-targeting in base ai propri criteri di nome file e cartelle anziché usare le cartelle Piattaforme . Per altre informazioni, vedere Configurare multi-targeting.

Android

Nell'esempio seguente viene illustrata l'implementazione del GetOrientation metodo in Android:

using Android.Content;
using Android.Runtime;
using Android.Views;

namespace InvokePlatformCodeDemos.Services.PartialMethods;

public partial class DeviceOrientationService
{
    public partial DeviceOrientation GetOrientation()
    {
        IWindowManager windowManager = Android.App.Application.Context.GetSystemService(Context.WindowService).JavaCast<IWindowManager>();
        SurfaceOrientation orientation = windowManager.DefaultDisplay.Rotation;
        bool isLandscape = orientation == SurfaceOrientation.Rotation90 || orientation == SurfaceOrientation.Rotation270;
        return isLandscape ? DeviceOrientation.Landscape : DeviceOrientation.Portrait;
    }
}

iOS

Nell'esempio GetOrientation seguente viene illustrata l'implementazione del metodo in iOS:

using UIKit;

namespace InvokePlatformCodeDemos.Services.PartialMethods;

public partial class DeviceOrientationService
{
    public partial DeviceOrientation GetOrientation()
    {
        UIInterfaceOrientation orientation = UIApplication.SharedApplication.StatusBarOrientation;
        bool isPortrait = orientation == UIInterfaceOrientation.Portrait || orientation == UIInterfaceOrientation.PortraitUpsideDown;
        return isPortrait ? DeviceOrientation.Portrait : DeviceOrientation.Landscape;
    }
}

Richiamare l'API multipiattaforma

Dopo aver fornito le implementazioni della piattaforma, l'API può essere richiamata dal codice multipiattaforma creando un'istanza dell'oggetto e richiamandone l'operazione:

using InvokePlatformCodeDemos.Services;
using InvokePlatformCodeDemos.Services.PartialMethods;
...

DeviceOrientationService deviceOrientationService = new DeviceOrientationService();
DeviceOrientation orientation = deviceOrientationService.GetOrientation();

Al momento della compilazione, il sistema di compilazione userà più target per combinare la classe parziale multipiattaforma con la classe parziale per la piattaforma di destinazione e compilarla nel pacchetto dell'app.

Configurare multi-targeting

Le app .NET MAUI possono anche essere multi-destinazione in base ai propri criteri di nome file e cartelle. Ciò consente di strutturare il progetto di app .NET MAUI in modo che non sia necessario inserire il codice della piattaforma nelle cartelle figlio della cartella Platform .

Ad esempio, un modello di multi-destinazione standard consiste nell'includere la piattaforma come estensione nel nome file per il codice della piattaforma. Il sistema di compilazione può essere configurato per combinare classi parziali multipiattaforma con classi parziali della piattaforma in base a questo modello:

Classi DeviceOrientationService che usano il multi-targeting basato su nome file.

Un altro modello di multi-destinazione standard consiste nell'includere la piattaforma come nome della cartella. Il sistema di compilazione può essere configurato per combinare classi parziali multipiattaforma con classi parziali della piattaforma in base a questo modello:

Classi DeviceOrientationService che usano il multi-targeting basato su cartelle.

Per altre informazioni, vedere Configurare multi-targeting.