PCL (Bibliotecas de classe portáteis)

Um componente-chave da criação de aplicativos de plataforma cruzada é ser capaz de compartilhar código em vários projetos específicos da plataforma. No entanto, isso é complicado pelo fato de que plataformas diferentes geralmente usam um subconjunto diferente da BCL (Biblioteca de Classes Base) do .NET e, portanto, são criadas para um Perfil de Biblioteca do .NET Core diferente. Isso significa que cada plataforma só pode usar bibliotecas de classes direcionadas ao mesmo perfil, portanto, elas parecem exigir projetos de biblioteca de classes separados para cada plataforma.

Há três abordagens principais para o compartilhamento de código que abordam esse problema: projetos do .NET Standard, projetos de ativos compartilhados e projetos de biblioteca de classes portátil (PCL).

• Projetos do .NET Standard são a abordagem preferida para compartilhar código .NET, leia mais sobre projetos do .NET Standard e Xamarin.
• Projetos de ativos compartilhados usam um único conjunto de arquivos e oferecem uma maneira rápida e simples de compartilhar código dentro de uma solução e geralmente empregam diretivas de compilação condicional para especificar caminhos de código para várias plataformas que o usarão (para obter mais informações, consulte o artigo Projetos compartilhados).
• Os projetos PCL destinam-se a perfis específicos que oferecem suporte a um conjunto conhecido de classes/recursos BCL. No entanto, a desvantagem da PCL é que elas geralmente exigem esforço arquitetônico extra para separar o código específico do perfil em suas próprias bibliotecas.

Esta página explica como criar um projeto PCL direcionado a um perfil específico, que pode ser referenciado por vários projetos específicos da plataforma.

O que é uma Biblioteca de Classes Portátil?

Quando você cria um projeto de aplicativo ou um projeto de biblioteca, a DLL resultante é restrita a trabalhar na plataforma específica para a qual foi criada. Isso impede que você escreva um assembly para um aplicativo do Windows e, em seguida, reutilize-o no Xamarin.iOS e Xamarin.Android.

No entanto, ao criar uma Biblioteca de Classes Portátil, você pode escolher uma combinação de plataformas nas quais deseja que seu código seja executado. As opções de compatibilidade feitas ao criar uma Biblioteca de Classes Portátil são convertidas em um identificador "Perfil", que descreve quais plataformas a biblioteca suporta.

A tabela abaixo mostra alguns dos recursos que variam de acordo com a plataforma .NET. Para escrever um assembly PCL que é garantido para executar em dispositivos/plataformas específicos, basta escolher qual suporte é necessário ao criar o projeto.

A coluna Xamarin reflete o fato de que o Xamarin.iOS e o Xamarin.Android oferecem suporte a todos os perfis fornecidos com o Visual Studio, e a disponibilidade de recursos em quaisquer bibliotecas criadas será limitada apenas pelas outras plataformas que você escolher suportar.

Isso inclui perfis que são combinações de:

• .NET 4 ou .NET 4.5
• Silverlight 5
• Windows Phone 8
• Aplicativos UWP

Você pode ler mais sobre os recursos dos diferentes perfis no site da Microsoft e ver o resumo do perfil PCL de outro membro da comunidade, que inclui informações de estrutura com suporte e outras notas.

Benefícios

1. Compartilhamento centralizado de código – escreva e teste código em um único projeto que pode ser consumido por outras bibliotecas ou aplicativos.
2. As operações de refatoração afetarão todo o código carregado na solução (a Biblioteca de Classes Portátil e os projetos específicos da plataforma).
3. O projeto PCL pode ser facilmente referenciado por outros projetos em uma solução, ou o assembly de saída pode ser compartilhado para que outros façam referência em suas soluções.

Desvantagens

1. Como a mesma Biblioteca de Classes Portátil é compartilhada entre vários aplicativos, bibliotecas específicas da plataforma não podem ser referenciadas (por exemplo. Comunidade.CsharpSqlite.WP7).
2. O subconjunto Biblioteca de classes portátil pode não incluir classes que, de outra forma, estariam disponíveis no MonoTouch e no Mono para Android (como DllImport ou System.IO.File).

Até certo ponto, ambas as desvantagens podem ser contornadas usando o padrão Provider ou Dependency Injection para codificar a implementação real nos projetos de plataforma em relação a uma interface ou classe base definida na Biblioteca de Classes Portátil.

Este diagrama mostra a arquitetura de um aplicativo de plataforma cruzada usando uma Biblioteca de Classes Portátil para compartilhar código, mas também usando a Injeção de Dependência para passar recursos dependentes da plataforma:

Exemplo de PCL

O aplicativo de exemplo TaskyPortable demonstra como uma biblioteca de classes portátil pode ser usada com o Xamarin. Aqui estão algumas capturas de tela dos aplicativos resultantes em execução no iOS e Android:

Ele compartilha uma série de dados e classes lógicas que são código puramente portátil e também demonstra como incorporar requisitos específicos da plataforma usando injeção de dependência para a implementação do banco de dados SQLite.

A estrutura da solução é mostrada abaixo (no Visual Studio para Mac e Visual Studio, respectivamente):

Como o código SQLite-NET tem partes específicas da plataforma (para trabalhar com as implementações SQLite em cada sistema operacional diferente) para fins de demonstração, ele foi refatorado em uma classe abstrata que pode ser compilada em uma Biblioteca de Classes Portátil e o código real implementado como subclasses nos projetos iOS e Android.

TaskyPortableLibrary

A Biblioteca de Classes Portátil é limitada nos recursos do .NET que ela pode suportar. Como ele é compilado para ser executado em várias plataformas, ele não pode fazer uso da [DllImport] funcionalidade que é usada no SQLite-NET. Em vez disso, SQLite-NET é implementado como uma classe abstrata e, em seguida, referenciado através do resto do código compartilhado. Um extrato da API abstrata é mostrado abaixo:

public abstract class SQLiteConnection : IDisposable {

    public string DatabasePath { get; private set; }
    public bool TimeExecution { get; set; }
    public bool Trace { get; set; }
    public SQLiteConnection(string databasePath) {
         DatabasePath = databasePath;
    }
    public abstract int CreateTable<T>();
    public abstract SQLiteCommand CreateCommand(string cmdText, params object[] ps);
    public abstract int Execute(string query, params object[] args);
    public abstract List<T> Query<T>(string query, params object[] args) where T : new();
    public abstract TableQuery<T> Table<T>() where T : new();
    public abstract T Get<T>(object pk) where T : new();
    public bool IsInTransaction { get; protected set; }
    public abstract void BeginTransaction();
    public abstract void Rollback();
    public abstract void Commit();
    public abstract void RunInTransaction(Action action);
    public abstract int Insert(object obj);
    public abstract int Update(object obj);
    public abstract int Delete<T>(T obj);

    public void Dispose()
    {
        Close();
    }
    public abstract void Close();

}

O restante do código compartilhado usa a classe abstrata para "armazenar" e "recuperar" objetos do banco de dados. Em qualquer aplicativo que usa essa classe abstrata, devemos passar uma implementação completa que forneça a funcionalidade real do banco de dados.

TaskyAndroid e TaskyiOS

Os projetos de aplicativos iOS e Android contêm a interface do usuário e outro código específico da plataforma usado para conectar o código compartilhado na PCL.

Esses projetos também contêm uma implementação da API de banco de dados abstrato que funciona nessa plataforma. No iOS e Android, o mecanismo de banco de dados Sqlite é integrado ao sistema operacional, de modo que a implementação pode ser usada [DllImport] como mostrado para fornecer a implementação concreta da conectividade do banco de dados. Um trecho do código de implementação específico da plataforma é mostrado aqui:

[DllImport("sqlite3", EntryPoint = "sqlite3_open")]
public static extern Result Open(string filename, out IntPtr db);

[DllImport("sqlite3", EntryPoint = "sqlite3_close")]
public static extern Result Close(IntPtr db);

A implementação completa pode ser vista no código de exemplo.

Resumo

Este artigo discutiu brevemente os benefícios e as armadilhas das bibliotecas de classes portáteis, demonstrou como criar e consumir PCLs de dentro do Visual Studio para Mac e Visual Studio; e, finalmente, introduziu um aplicativo de amostra completo – TaskyPortable – que mostra uma PCL em ação.

Links relacionados

• Compilar aplicativos de plataforma cruzada
• Visual Basic portátil
• Projetos compartilhados
• Opções de código de compartilhamento
• Desenvolvimento entre plataformas com o .NET Framework (Microsoft)