Udostępnij za pośrednictwem

Xamarin.Forms Klasa aplikacji

  • Artykuł

Klasa Application bazowa oferuje następujące funkcje, które są widoczne w domyślnej App podklasie projektów:

  • Właściwość MainPage , w której należy ustawić stronę początkową aplikacji.
  • Trwały Properties słownik do przechowywania prostych wartości w ramach zmian stanu cyklu życia.
  • Właściwość statyczna Current zawierająca odwołanie do bieżącego obiektu aplikacji.

Uwidacznia również metody cyklu życia, takie jak OnStart, OnSleepi OnResume oraz zdarzenia nawigacji modalnej.

W zależności od wybranego App szablonu klasę można zdefiniować na jeden z dwóch sposobów:

  • C#, lub
  • XAML i C#

Aby utworzyć klasę aplikacji przy użyciu języka XAML, domyślna klasa aplikacji musi zostać zastąpiona klasą aplikacji XAML i skojarzonym kodem, jak pokazano w poniższym przykładzie kodu:

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

</Application>

W poniższym przykładzie kodu pokazano skojarzony kod za:

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

Oprócz ustawiania MainPage właściwości kod-behind musi również wywołać metodę InitializeComponent w celu załadowania i przeanalizowania skojarzonego kodu XAML.

Właściwość MainPage

Właściwość MainPage w Application klasie ustawia stronę główną aplikacji.

Możesz na przykład utworzyć logikę w App klasie, aby wyświetlić inną stronę w zależności od tego, czy użytkownik jest zalogowany, czy nie.

Właściwość powinna być ustawiona MainPage w konstruktorze App .

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

Słownik właściwości

Podklasa Application ma słownik statyczny Properties , który może służyć do przechowywania danych, w szczególności do użycia w metodach OnStart, OnSleepi OnResume . Dostęp do tego można uzyskać z dowolnego miejsca w Xamarin.Forms kodzie przy użyciu polecenia Application.Current.Properties.

Słownik Properties używa string klucza i przechowuje object wartość.

Można na przykład ustawić właściwość trwałą "id" w dowolnym miejscu w kodzie (po wybraniu elementu w metodzie strony OnDisappearing lub metodzie OnSleep ) w następujący sposób:

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

W metodach OnStart lub OnResume możesz użyć tej wartości, aby odtworzyć środowisko użytkownika w jakiś sposób. Słownik Properties przechowuje objectwartości, więc należy rzutować jej wartość przed użyciem.

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

Zawsze sprawdzaj obecność klucza przed uzyskaniem do niego dostępu, aby zapobiec nieoczekiwanym błędom.

Uwaga

Słownik Properties może serializować tylko typy pierwotne magazynu. Próba przechowywania innych typów (takich jak List<string>) może zakończyć się niepowodzeniem w trybie dyskretnym.

Trwałość

Słownik Properties jest zapisywany automatycznie na urządzeniu. Dane dodane do słownika będą dostępne, gdy aplikacja wróci z tła, a nawet po ponownym uruchomieniu.

Xamarin.Forms 1.4 wprowadzono dodatkową metodę w Application klasie — SavePropertiesAsync() którą można wywołać w celu proaktywnego utrwalania słownika Properties . Ma to na celu zapisanie właściwości po ważnych aktualizacjach, a nie ryzyko ich serializacji z powodu awarii lub zabicia przez system operacyjny.

Odwołania do używania słownika można znaleźć w podręczniku Properties Tworzenie aplikacji Xamarin.Formsmobilnych (zobacz rozdziały 6, 15 i 20) oraz w skojarzonych przykładach.

klasa aplikacji

Application Kompletna implementacja klasy jest pokazana poniżej w celu uzyskania informacji referencyjnych:

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

Ta klasa jest następnie tworzone w każdym projekcie specyficznym dla platformy i przekazywane do LoadApplication metody, w której MainPage element jest ładowany i wyświetlany użytkownikowi. Kod dla każdej platformy jest wyświetlany w poniższych sekcjach. Najnowsze Xamarin.Forms szablony rozwiązań zawierają już cały ten kod, wstępnie skonfigurowany dla aplikacji.

Projekt systemu iOS

Klasa systemu iOS AppDelegate dziedziczy z FormsApplicationDelegateklasy . Powinien on:

  • Wywołaj LoadApplication metodę za pomocą wystąpienia App klasy .

  • Zawsze zwracaj wartość 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);
    }
}

Projekt systemu Android

System Android MainActivity dziedziczy z elementu FormsAppCompatActivity. W przesłonięć OnCreate metodę LoadApplication jest wywoływana z wystąpieniem App klasy.

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

Projekt uniwersalny systemu Windows (UWP) dla systemu Windows 10

Strona główna w projekcie platformy UWP powinna dziedziczyć z WindowsPageelementu :

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

Kod języka C# stojący za konstrukcją musi wywołać LoadApplication metodę , aby utworzyć wystąpienie obiektu Xamarin.FormsApp. Należy pamiętać, że dobrym rozwiązaniem jest jawne użycie przestrzeni nazw aplikacji w celu zakwalifikowania App jej, ponieważ aplikacje platformy UWP mają również własną App klasę niepowiązaną Xamarin.Formsz klasą .

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

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

Należy pamiętać, że Forms.Init() należy wywołać z App.xaml.cs w projekcie platformy UWP.

Aby uzyskać więcej informacji, zobacz Konfigurowanie projektów systemu Windows, w tym kroki dodawania projektu platformy UWP do istniejącego Xamarin.Forms rozwiązania, które nie jest przeznaczone dla platformy UWP.

Więcej filmów na platformie Xamarin można znaleźć w witrynach Channel 9 i YouTube.