Librerie di classi portabili

Un componente chiave della compilazione di applicazioni multipiattaforma è in grado di condividere il codice in vari progetti specifici della piattaforma. Tuttavia, questo è complicato dal fatto che le diverse piattaforme usano spesso un sottoinsieme diverso della libreria di classi di base .NET (BCL) e quindi vengono effettivamente compilate in un profilo di libreria .NET Core diverso. Ciò significa che ogni piattaforma può usare solo librerie di classi destinate allo stesso profilo in modo che sembrino richiedere progetti di libreria di classi separati per ogni piattaforma.

Esistono tre approcci principali alla condivisione del codice che risolva questo problema: progetti .NET Standard, progetti di asset condivisi e progetti PCL (Portable Class Library).

• I progetti .NET Standard sono l'approccio preferito per la condivisione del codice .NET, altre informazioni sui progetti .NET Standard e Xamarin.
• I progetti di asset condivisi usano un singolo set di file e offrono un modo rapido e semplice in cui condividere il codice all'interno di una soluzione e in genere usa direttive di compilazione condizionale per specificare i percorsi di codice per varie piattaforme che lo useranno (per altre informazioni vedere l'articolo Progetti condivisi).
• I progetti PCL hanno come destinazione profili specifici che supportano un set noto di classi/funzionalità BCL. Tuttavia, il lato inferiore della libreria di classi portabile è che spesso richiedono un'architettura aggiuntiva per separare codice specifico del profilo nelle proprie librerie.

Questa pagina illustra come creare un progetto PCL destinato a un profilo specifico, a cui possono quindi fare riferimento più progetti specifici della piattaforma.

Che cos'è una libreria di classi portabile?

Quando si crea un progetto di applicazione o un progetto di libreria, la DLL risultante è limitata all'uso della piattaforma specifica per cui viene creata. In questo modo si impedisce di scrivere un assembly per un'app di Windows e quindi di usarlo di nuovo in Xamarin.iOS e Xamarin.Android.

Quando si crea una libreria di classi portabile, tuttavia, è possibile scegliere una combinazione di piattaforme in cui si vuole eseguire il codice. Le scelte di compatibilità effettuate durante la creazione di una libreria di classi portabile vengono convertite in un identificatore "Profilo", che descrive le piattaforme supportate dalla libreria.

La tabella seguente illustra alcune delle funzionalità che variano in base alla piattaforma .NET. Per scrivere un assembly PCL che garantisce l'esecuzione su dispositivi/piattaforme specifici, è sufficiente scegliere il supporto necessario quando si crea il progetto.

La colonna Xamarin riflette il fatto che Xamarin.iOS e Xamarin.Android supportano tutti i profili forniti con Visual Studio e la disponibilità di funzionalità in tutte le librerie create sarà limitata solo dalle altre piattaforme che si sceglie di supportare.

Sono inclusi i profili che sono combinazioni di:

• .NET 4 o .NET 4.5
• Silverlight 5
• Windows Phone 8
• App UWP

Per altre informazioni sulle funzionalità dei diversi profili, vedere il riepilogo del profilo PCL di un altro membro della community che include informazioni sul framework supportate e altre note.

Vantaggi

1. Condivisione centralizzata del codice: scrivere e testare il codice in un singolo progetto che può essere utilizzato da altre librerie o applicazioni.
2. Le operazioni di refactoring influiscono su tutto il codice caricato nella soluzione (la libreria di classi portabile e i progetti specifici della piattaforma).
3. Il progetto PCL può essere facilmente referenziato da altri progetti in una soluzione oppure l'assembly di output può essere condiviso per altri utenti a cui fare riferimento nelle proprie soluzioni.

Svantaggi

1. Poiché la stessa libreria di classi portabile è condivisa tra più applicazioni, non è possibile fare riferimento a librerie specifiche della piattaforma ( ad esempio. Community.CsharpSqlite.WP7).
2. Il sottoinsieme libreria di classi portabile potrebbe non includere classi che altrimenti sarebbero disponibili sia in MonoTouch che in Mono per Android (ad esempio DllImport o System.IO.File).

In alcuni casi, entrambi gli svantaggi possono essere aggirati usando il modello provider o l'inserimento delle dipendenze per codificare l'implementazione effettiva nei progetti di piattaforma in base a un'interfaccia o a una classe di base definita nella libreria di classi portabile.

Questo diagramma illustra l'architettura di un'applicazione multipiattaforma che usa una libreria di classi portabile per condividere il codice, ma anche l'uso dell'inserimento delle dipendenze per passare le funzionalità dipendenti dalla piattaforma:

Esempio di libreria di classi portabile

L'applicazione di esempio TaskyPortable illustra come usare una libreria di classi portabile con Xamarin. Ecco alcuni screenshot delle app risultanti in esecuzione in iOS e Android:

Condivide una serie di classi di dati e logica puramente portabili e illustra anche come incorporare requisiti specifici della piattaforma usando l'inserimento delle dipendenze per l'implementazione del database SQLite.

La struttura della soluzione è illustrata di seguito (rispettivamente in Visual Studio per Mac e Visual Studio):

Poiché il codice SQLite-NET include parti specifiche della piattaforma (per lavorare con le implementazioni SQLite in ogni sistema operativo diverso) a scopo dimostrativo è stato eseguito il refactoring in una classe astratta che può essere compilata in una libreria di classi portabile e il codice effettivo implementato come sottoclassi nei progetti iOS e Android.

TaskyPortableLibrary

La libreria di classi portabile è limitata nelle funzionalità .NET che può supportare. Poiché viene compilato per l'esecuzione su più piattaforme, non può usare [DllImport] le funzionalità usate in SQLite-NET. SQLite-NET viene invece implementato come classe astratta e quindi viene fatto riferimento al resto del codice condiviso. Di seguito è riportato un estratto dell'API astratta:

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();

}

Il resto del codice condiviso usa la classe astratta per "archiviare" e "recuperare" oggetti dal database. In qualsiasi applicazione che usa questa classe astratta è necessario passare un'implementazione completa che fornisce la funzionalità effettiva del database.

TaskyAndroid e TaskyiOS

I progetti di applicazione iOS e Android contengono l'interfaccia utente e altro codice specifico della piattaforma usato per collegare il codice condiviso nella libreria di classi portabile.

Questi progetti contengono anche un'implementazione dell'API di database astratta che funziona su tale piattaforma. In iOS e Android il motore di database Sqlite è integrato nel sistema operativo, quindi l'implementazione può essere usata [DllImport] come illustrato per fornire l'implementazione concreta della connettività del database. Di seguito è riportato un estratto del codice di implementazione specifico della piattaforma:

[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);

L'implementazione completa può essere visualizzata nel codice di esempio.

Riepilogo

Questo articolo ha brevemente illustrato i vantaggi e le insidie delle librerie di classi portabili, ha illustrato come creare e utilizzare ICL dall'interno di Visual Studio per Mac e Visual Studio e infine ha introdotto un'applicazione di esempio completa, TaskyPortable, che mostra un PCL in azione.

Collegamenti correlati

• Creazione di applicazioni multipiattaforma
• Visual Basic portabile
• Progetti condivisi
• Opzioni di condivisione del codice
• Sviluppo multipiattaforma con .NET Framework (Microsoft)