Xamarin.Forms Classe de aplicativo

A classe base Application oferece os seguintes recursos, que são expostos na subclasse App padrão de seus projetos:

Uma propriedade MainPage, que é onde a página inicial do aplicativo deve ser definida.
Um dicionário de Properties persistente para armazenar valores simples durante alterações de estado do ciclo de vida.
Uma propriedade Current estática que contém uma referência ao objeto do aplicativo atual.

Ela também expõe Métodos de ciclo de vida como OnStart, OnSleep e OnResume, bem como eventos de navegação modal.

Dependendo do modelo escolhido, a classe App poderá ser definida de uma das duas maneiras:

C# ou
XAML e C#

Para criar uma classe App usando XAML, a classe App padrão deve ser substituída por uma classe App XAML e pelo code-behind associado, conforme mostrado no exemplo de código a seguir:

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

</Application>

O exemplo de código a seguir mostra o code-behind do associado:

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

Além de configurar a propriedade MainPage, o code-behind também deve chamar o método InitializeComponent para carregar e analisar o XAML associado.

Propriedade MainPage

A propriedade MainPage na classe Application define a página raiz do aplicativo.

Por exemplo, você pode criar a lógica em sua classe App para exibir uma página diferente se o usuário estiver conectado ou não.

A propriedade MainPage deve ser definida no construtor App,

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

Dicionário de propriedades

A subclasse Application tem um dicionário Properties estático que pode ser usado para armazenar dados, em particular para uso nos métodos OnStart, OnSleep e OnResume. Isso pode ser acessado de qualquer lugar em seu Xamarin.Forms código usando Application.Current.Properties.

O dicionário Properties usa uma chave string e armazena um valor de object.

Por exemplo, você poderia definir uma propriedade "id" persistente em qualquer lugar de seu código (quando um item é selecionado, no método OnDisappearing de uma página ou no método OnSleep), da seguinte forma:

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

Nos métodos OnStart ou OnResume, você pode usar esse valor para recriar a experiência do usuário de alguma forma. O dicionário Properties armazena objects, de modo que você precisa converter seu valor antes de usá-lo.

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

Sempre verifique a presença da chave antes de acessá-la para evitar erros inesperados.

Observação

O dicionário Properties pode serializar apenas tipos primitivos para armazenamento. Tentar armazenar outros tipos (como List<string>) pode falhar de modo silencioso.

Persistência

O dicionário Properties é salvo automaticamente no dispositivo. Dados adicionados ao dicionário estarão disponíveis quando o aplicativo voltar do segundo plano ou até mesmo após ser reiniciado.

Xamarin.Forms 1.4 introduziu um método adicional na Application classe - SavePropertiesAsync() - que pode ser chamado para persistir proativamente o Properties dicionário. A finalidade disso é permitir que você salve propriedades após atualizações importantes, em vez de correr o risco de que elas não sejam serializadas devido a uma falha ou a uma interrupção do sistema operacional.

Você pode encontrar referências ao uso do Properties dicionário no livro Criando aplicativos móveis com Xamarin.Forms (consulte os capítulos 6, 15 e 20) e nos exemplos associados.

A classe do aplicativo

Uma implementação completa da classe Application é mostrada abaixo para referência:

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

Em seguida, essa classe é instanciada em cada projeto específico da plataforma e passada para o método LoadApplication, em que o MainPage é carregado e exibido para o usuário. O código para cada plataforma é mostrado nas seções a seguir. Os modelos de solução mais recentes Xamarin.Forms já contêm todo esse código, pré-configurado para seu aplicativo.

Projeto do iOS

A classe AppDelegate do iOS herda de FormsApplicationDelegate. Ele deve:

Chamar LoadApplication com uma instância da classe App.
Sempre retorna 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);
    }
}

Projeto do Android

O MainActivity do Android herda de FormsAppCompatActivity. Na substituição OnCreate, o método LoadApplication é chamado com uma instância da 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
    }
}

UWP (Plataforma Universal do Windows) para Windows 10

A página principal no projeto da UWP deve herdar de WindowsPage:

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

O código C# por trás da construção deve chamar LoadApplication para criar uma instância do arquivo Xamarin.FormsApp. Observe que é uma boa prática usar explicitamente o namespace do aplicativo para qualificar o porque os App aplicativos UWP também têm sua própria App classe não relacionada ao Xamarin.Forms.

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

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

Observe que Forms.Init() precisa ser chamado por App.xaml.cs no projeto UWP.

Para obter mais informações, consulte Configurar projetos do Windows, que inclui etapas para adicionar um projeto UWP a uma solução existente Xamarin.Forms que não tem como destino a UWP.

Encontre mais vídeos sobre o Xamarin no Channel 9 e no YouTube.

Last updated on 2016-02-19

Compartilhar via