Utilizziamo i cookie per analisi, contenuti personalizzati e pubblicità.

Queste informazioni possono essere condivise con i nostri partner per fornire i servizi necessari.

Approfondisci

AccettoRifiuto

Dall'archivio articoli > WinRT 8.1

Introduzione a Caliburn.Micro 2.0 per WinRT

di Matteo TumiatiMatteo Tumiati, in WinRT 8.1,

Abbiamo già discusso in precedenti articoli di Caliburn, un famoso e potente framework per l'implementazione del pattern Model-View-View Model nelle nostre applicazioni Windows 8 e Windows Phone. Caliburn si è recentemente aggiornato alla versione 2.0 per supportare le Universal App presentate a //Build/ lo scorso Aprile, ed in questo articolo vedremo appunto come configurare Caliburn nelle nostre app universali.

Per chi non sapesse bene di cosa stiamo parlando, è bene sapere che MVVM è un pattern di scrittura del codice volto a semplificare il rapporto designer-sviluppatore, in quanto lo scopo di MVVM è separare la logica dell'applicazione da quella che invece è la parte grafica e l'interazione con l'utente.

Perché scegliere Caliburn? Perché a parte la configurazione iniziale (che è un po' complessa), è molto semplice scrivere una applicazione MVVM nascondendo molti dettagli della struttura, concentrandosi solamente sulla logica dell'applicazione. Sarà Caliburn stesso a fornirci gli aiuti necessari per il binding (attraverso le convenzioni dei nomi), per la navigazione, per il supporto alla ricerca e tutta la parte ALM. La parte di configurazione iniziale, ci permette inoltre di aggiungere i nostri helper, in modo da rendere Caliburn quasi totalmente personalizzabile secondo le nostre esigenze.

Tutta questa semplicità realizzativa un po' la si paga. Molti concetti vengono infatti nascosti dal framework stesso (tipo la navigazione) e diventa difficile per un estraneo leggere il codice e capire cosa sta effettivamente succedendo dietro le quinte.

Creazione del progetto e configurazione iniziale

La prima operazione da fare per provare Caliburn, è creare il progetto come Universal App.

Come possiamo notare, all'interno della soluzione troveremo più progetti: quello Windows 8.1, quello Windows 8.1 ed un terzo Shared che è direttamente collegato agli altri due.

Questo articolo esula dalla basi delle Universal Apps, quindi non vedremo tutta la struttura della soluzione, ci basta capire in questo momento che possiamo condividere tutta la logica delle applicazioni, e se riusciamo, anche la parte grafica (ma non è obbligatoria).A questo punto non dobbiamo fare altro che installare Caliburn.Micro direttamente da NuGet sui progetti Windows 8.1 e Windows Phone 8.1 per aggiungere il framework.

Poiché cercheremo di farla più universale possibile, eliminiamo la MainPage dalla applicazione di Windows Phone e spostiamo la stessa pagina da WinRT al progetto Shared. Facciamo la stessa cosa con la classe App. Questo ci permetterà di condividere al massimo il codice e le viste tra le due applicazioni attraverso il progetto Shared.

Ora dobbiamo fare il file di configurazione. Per chi è avvezzo a Caliburn, deve sapere che la parte di Windows Phone è stata eliminata, nel senso che non è più necessaria la configurazione tramite Bootstrapper, ma verrà implementata, come su WinRT, direttamente nel code behind della classe App.

Andiamo quindi nel code behind della classe App e cancelliamo tutto il contenuto, poiché tutti i metodi che sono implementati da Application (dalla quale App eredita) sono implementati attraverso Caliburn e quindi creerebbero dei problemi. Andiamo a sostituirlo con questa configurazione base:

public sealed partial class App
{
    private WinRTContainer _container;
        
    public App()
    {
        InitializeComponent();
    }

    protected override void Configure()
    {
        _container = new WinRTContainer();

        _container.RegisterWinRTServices();
        _container.PerRequest<MainPageViewModel>();
    }

    protected override void PrepareViewFirst(Frame rootFrame)
    {
        _container.RegisterNavigationService(rootFrame);
    }

    protected override void OnLaunched(LaunchActivatedEventArgs args)
    {
        DisplayRootView<MainPage>();
    }

    protected override object GetInstance(Type service, string key)
    {
        return _container.GetInstance(service, key);
    }

    protected override IEnumerable<object> GetAllInstances(Type service)
    {
        return _container.GetAllInstances(service);
    }

    protected override void BuildUp(object instance)
    {
        _container.BuildUp(instance);
    }
}

Tutta la configurazione viene fatta all'interno del metodo Configure (che è definito da Caliburn) e difatti è totalmente personalizzabile. Come per la parte di Windows 8.1 (d'altronde WP8.1 condivide molto di WinRT), bisogna creare un nuovo WinRTContainer e poi registrarne i servizi. Possiamo poi registrare di seguito tutti i ViewModel, come ad esempio il MainPageViewModel che è quello che useremo per mostrare dei dati nella MainPage. Tutti gli altri metodi sono standard, a meno di configurazioni particolari e a meno del metodo OnLaunched che mi permette di decidere dove navigare allo scatenarsi di quel metodo. In questo caso andremo a navigare alla MainPage.

Dobbiamo ancora cambiare la parte di "view" della classe App, in quanto dobbiamo sostituire il codice esistente con questo:

<micro:CaliburnApplication
    x:Class="CaliburnApp.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:CaliburnApp"
    xmlns:micro="using:Caliburn.Micro">
</micro:CaliburnApplication>

Andiamo solamente a definire che l'intero progetto userà Caliburn.

La configurazione è quasi terminata: dobbiamo solo sfruttare le convenzioni di Caliburn per i percorsi dei file. Caliburn si aspetta infatti che tutte le view siano nel namespace che termina per Views e che tutti i ViewModel siano nel namespace che termina per ViewModels (a meno di una configurazione vostra differente). Questo è facilmente risolvibile creando le cartelle Views e ViewModels in quanto sarà Visual Studio a dare automaticamente il namespace corretto alle classi create.

Andiamo quindi a spostare la nostra MainPage all'interno della cartella Views e ci creiamo la MainPageViewModel, una classe che ci farà da ViewModel. Anche in questo caso Caliburn ci aiuta con le convenzioni dei nomi: basterà infatti dare al ViewModel lo stesso nome della view con l'aggiunta della parola "ViewModel" perché si incarichi di fare il binding automatico, levando del lavoro allo sviluppatore.

Per il primo avvio ci accontentiamo di mostrare una stringa a schermo. Per farlo usiamo le MessageDialog e il codice lo andiamo a scrivere all'interno del ViewModel (stiamo usando Caliburn per non avere più code behind, ricordate?).

public class MainPageViewModel : Screen
{
    protected override async void OnActivate()
    {
        base.OnActivate();

        var dialog = new MessageDialog("Benvenuti nella MainPage!");
        await dialog.ShowAsync();
    }
}

Il metodo OnActivate è semplicemente l'override offerto da Caliburn del metodo OnNavigatedTo alla quale siamo già abituati. Mostriamo quindi il messaggio e verifichiamo che funzioni su entrambi i dispositivi.

3 pagine in totale: 1 2 3
Contenuti dell'articolo

Commenti

Visualizza/aggiungi commenti

| Condividi su: Twitter, Facebook, LinkedIn
Aggiorna

Per inserire un commento, devi avere un account.

Fai il login e torna a questa pagina, oppure registrati alla nostra community.

Approfondimenti

Top Ten Articoli

Articoli via e-mail

Iscriviti alla nostra newsletter nuoviarticoli per ricevere via e-mail le notifiche!

In primo piano

.NET Conference Italia 2024 - Milano

.NET Conference Italia 2023 - Milano e Online

Le novità di .NET 7 e C# 11

Le novità in ASP.NET Core e Blazor con .NET 7

I più letti di oggi

In evidenza

Misc