Condividi tramite

Xamarin.Forms Classe App

  • Articolo

La classe di base Application offre le funzionalità seguenti, che vengono esposte nella sottoclasse predefinita App del progetto:

  • Una proprietà MainPage, dove deve essere impostata la pagina iniziale per l'app.
  • Un dizionario Properties persistente per archiviare valori semplici per tutte le modifiche di stato del ciclo di vita.
  • Una proprietà Current statica che contiene un riferimento all'oggetto applicazione corrente.

Espone inoltre metodi del ciclo di vita, ad esempio OnStart, OnSleep e OnResume, nonché eventi di navigazione modale.

A seconda del modello scelto, la classe App può essere definita in uno dei due modi seguenti:

  • C# o
  • XAML e C#

Per creare una classe App usando XAML, è necessario sostituire la classe App predefinita con una classe App XAML e il code-behind associato, come illustrato nell'esempio di codice seguente:

<Application xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="Photos.App">

</Application>

L'esempio di codice seguente illustra il code-behind associato:

public partial class App : Application
{
    public App ()
    {
        InitializeComponent ();
        MainPage = new HomePage ();
    }
    ...
}

Oltre a impostare la proprietà MainPage, il code-behind deve anche chiamare il metodo InitializeComponent per caricare e analizzare il codice XAML associato.

Proprietà MainPage

La proprietà MainPage della classe Application imposta la pagina radice dell'applicazione.

Ad esempio, è possibile creare nella classe App la logica che consente di visualizzare una pagina diversa in base al fatto che l'utente abbia eseguito o meno l'accesso.

La proprietà MainPage deve essere impostata nel costruttore App,

public class App : Xamarin.Forms.Application
{
    public App ()
    {
        MainPage = new ContentPage { Title = "App Lifecycle Sample" }; // your page here
    }
}

Dizionario delle proprietà

La sottoclasse Application ha un dizionario Properties statico che può essere usato per archiviare i dati, in particolare per l'uso nei metodi OnStart, OnSleep e OnResume. È possibile accedervi da qualsiasi punto del Xamarin.Forms codice usando Application.Current.Properties.

Il dizionario Properties usa una chiave string e archivia un valore object.

Ad esempio, è possibile impostare una proprietà "id" persistente in qualsiasi punto del codice (quando è selezionato un elemento, nel metodo OnDisappearing di una pagina o nel metodo OnSleep) come illustrato di seguito:

Application.Current.Properties ["id"] = someClass.ID;

Nel metodo OnStart o OnResume è quindi possibile usare questo valore per ricreare l'esperienza dell'utente in qualche modo. Il dizionario Properties archivia elementi object quindi è necessario eseguire il cast del relativo valore prima di usarlo.

if (Application.Current.Properties.ContainsKey("id"))
{
    var id = Application.Current.Properties ["id"] as int;
    // do something with id
}

Verificare sempre la presenza della chiave prima di accedervi in modo da evitare errori imprevisti.

Nota

Il dizionario Properties può serializzare solo i tipi primitivi per l'archiviazione. Il tentativo di archiviare altri tipi, ad esempio List<string>, può avere esito negativo senza che appaiano avvisi.

Persistenza

Il dizionario Properties viene salvato automaticamente nel dispositivo. I dati aggiunti al dizionario saranno disponibili quando l'applicazione torna dall'esecuzione in background o viene riavviata.

Xamarin.Forms 1.4 ha introdotto un metodo aggiuntivo nella Application classe , SavePropertiesAsync() che può essere chiamato per rendere permanente in modo proattivo il Properties dizionario. Questo consente di salvare le proprietà dopo gli aggiornamenti importanti senza rischiare che non vengano serializzate a causa di un arresto anomalo o terminate dal sistema operativo.

È possibile trovare riferimenti all'uso del Properties dizionario nel libro Creazione di app Xamarin.Forms per dispositivi mobili (vedere i capitoli 6, 15 e 20) e negli esempi associati.

Classe Application

Un'implementazione completa della classe Application è illustrata di seguito per riferimento:

public class App : Xamarin.Forms.Application
{
    public App ()
    {
        MainPage = new ContentPage { Title = "App Lifecycle Sample" }; // your page here
    }

    protected override void OnStart()
    {
        // Handle when your app starts
        Debug.WriteLine ("OnStart");
    }

    protected override void OnSleep()
    {
        // Handle when your app sleeps
        Debug.WriteLine ("OnSleep");
    }

    protected override void OnResume()
    {
        // Handle when your app resumes
        Debug.WriteLine ("OnResume");
    }
}

Un'istanza di questa classe viene creata in ogni progetto specifico della piattaforma e passata al metodo LoadApplication, che rappresenta la posizione in cui l'elemento MainPage viene caricato e visualizzato all'utente. Nelle sezioni seguenti viene illustrato il codice per ogni piattaforma. I modelli di soluzione più recenti Xamarin.Forms contengono già tutto questo codice preconfigurato per l'app.

Progetto iOS

La classe AppDelegate di iOS eredita da FormsApplicationDelegate. Deve:

  • Chiamare LoadApplication con un'istanza della classe App.

  • Restituire sempre base.FinishedLaunching (app, options);.

[Register ("AppDelegate")]
public partial class AppDelegate :
    global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate // superclass new in 1.3
{
    public override bool FinishedLaunching (UIApplication app, NSDictionary options)
    {
        global::Xamarin.Forms.Forms.Init ();

        LoadApplication (new App ());  // method is new in 1.3

        return base.FinishedLaunching (app, options);
    }
}

Progetto Android

L'elemento MainActivity di Android eredita da FormsAppCompatActivity. Nell'override di OnCreate il metodo LoadApplication viene chiamato con un'istanza della classe App.

[Activity (Label = "App Lifecycle Sample", Icon = "@drawable/icon", Theme = "@style/MainTheme", MainLauncher = true,
    ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
public class MainActivity : FormsAppCompatActivity
{
    protected override void OnCreate (Bundle bundle)
    {
        base.OnCreate (bundle);

        global::Xamarin.Forms.Forms.Init (this, bundle);

        LoadApplication (new App ()); // method is new in 1.3
    }
}

Progetto UWP (Universal Windows Platform) per Windows 10

La pagina principale nel progetto UWP deve ereditare da WindowsPage:

<forms:WindowsPage
   ...
   xmlns:forms="using:Xamarin.Forms.Platform.UWP"
   ...>
</forms:WindowsPage>

La costruzione del code-behind C# deve chiamare LoadApplication per creare un'istanza di Xamarin.FormsApp. Si noti che è consigliabile usare in modo esplicito lo spazio dei nomi dell'applicazione per qualificare perché App anche le applicazioni UWP hanno una propria App classe non correlata a Xamarin.Forms.

public sealed partial class MainPage
{
    public MainPage()
    {
        InitializeComponent();

        LoadApplication(new YOUR_NAMESPACE.App());
    }
 }

Si noti che Forms.Init() deve essere chiamato da App.xaml.cs nel progetto UWP.

Per altre informazioni, vedi Configurare progetti Windows, che include i passaggi per aggiungere un progetto UWP a una soluzione esistente Xamarin.Forms che non è destinata alla piattaforma UWP.

Altri video di Xamarin sono disponibili su Channel 9 e YouTube.