Partilhar via

Xamarin.Forms Classe de aplicativo

  • Artigo

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.