C# : Utilizzo del framework Caliburn in WPF

In questo articolo vedremo come creare una semplice applicazioni in WPF (Windows Presentation Foundation) con il linguaggio C# per rilevare il testo digitato in una casella di testo, utilizzeremo come ambiente di sviluppo “Visual Studio 2017 Community”.
Il Framework Caliburn, qui il sito ufficiale http://caliburnmicro.com/ permette la stesura di applicazioni utilizzando un pattern simile a MVC, nel quale dividere in più classi ( file) ciò che riguarda la visualizzazione, la gestione degli eventi (codice) e il modello.
Un modo per semplificare la stesura di codice scalabile.

Stesura del codice

Si crea un nuovo progetto di tipo “Windows presentation Foundation” selezionando la categoria “Desktop Classico per Windows” nei modelli quello con la voce “app WPF (.Net Framework)”, a questo punto nel progetto che verrà creato, eliminare il file “MainWindow.xaml”.
Aggiungiamo al progetto il framewok “Caliburn” dal menu “Strumenti” selezioniamo la voce “Gestione Pacchetti Nuget” e poi il sottomenu “Gestisci pacchetti Nuget per la soluzione”.
Nella finestra che viene aperta, scriviamo nella casella “Caliburn” a questo punto selezioniamo la versione più recente della voce “Caliburn.Micro” .
In questo modo verranno aggiunti i riferimenti e nel progetto possiamo utilizzare tale Framework.
Ora andremo a creare nel progetto alcune classi che ci permetteranno di utilizzare tale Framework.
Selezioniamo dalla finestra “Esplora soluzione” il progetto, e dal menu di scelta rapida, selezioniamo dal menu “Aggiungi” il sottomenu “Classe”.”
Il nome che daremo al file ed alla classe sarà “AppViewModel” questa classe avrà il compito di gestire gli eventi, ossia notifiche che si verificano nella parte grafica della nostra applicazione, il comportamento su cui eseguire determinate azioni.
La classe eredita dalla classe “PropertyChangedBase” che controllo e notifica tutti i cambiamenti che avvengono alle proprietà che abbiamo realizzato.
Una proprietà avrà il compito di rilevare il testo, mentre un'altra, avrà solo la particolarità di restituire il testo.
Ma vediamo in dettaglio meglio questa classe per poi esaminarla in dettaglio.

using Caliburn.Micro;
using System.Windows;
namespace WpfTest
{
public class AppViewModel : PropertyChangedBase
{
string testo;
public string Testo {
get { return testo; }
set {
testo = value;
NotifyOfPropertyChange(() => Testo);
NotifyOfPropertyChange(() => OttieniTesto);
}
}
public string OttieniTesto {
get { return "Testo Inserito: " + testo; }
}
}
}

Come si vede dal frammento di codice precedente, abbiamo creato una classe che eredita dalla classe "PropertyChangedBase" presente nello spazio dei nomi "Caliburn.Micro" come visibile in alto sopra ad ogni dichiarazione.
In questa classe abbiamo due proprietà, una che restituisce il testo, ed è quella denominata "OttieniTesto" mentre un’altra avrà verifica il cambiamento della proprietà "Testo" per Notificarlo, o meglio aggiornare costantemente la proprietà denominata "OttieniTesto".
Questo avviene tramite la parola chiave "NotifyOfPropertyChange().
A questo punto dobbiamo creare un’altra classe.
Si crea un nuova classe con la quale andremo a gestire questa appena creata.
Il nome che daremo al file è alla classe sarà "AppBootstrapper" che eredita dalla classe "BootstrapperBase".
Qui di seguito si riporta la classe, nel quale tramite l’evento "OnStartUp" avrà il compito di avviare ed eseguire la classe di tipo "ViewModel" per la visualizzazione della nostra applicazione.
Si riporta il codice completo di tale classe.


C#


using Caliburn.Micro;
using System.Windows;
namespace WpfTest
{
public class AppBootstrapper : BootstrapperBase
{
public AppBootstrapper()
{
Initialize();
}
protected override void OnStartup(object sender, StartupEventArgs e)
{
DisplayRootViewFor<AppViewModel>();
}
}
}

A questo punto dobbiamo creare il terzo elemento, dopo la gestione del codice, quella della vista ora dobbiamo creare la parte grafica, dove saranno presenti i controlli.
Sempre dalla finestra di “Esplora risorse” si seleziona la voce “Nuovo” nel sottomenu, selezioniamo “Controllo Utente”.
Assegniamo come nome “AppView”.
Nella parte XAML inseriamo due controlli, uno di tipo “TextBlock” e l’altro di tipo “Textbox” .
Per il controllo “TextBlock” impostiamo nella proprietà “Name” il valore “OttieniTesto”, mentre per il controllo “TextBox” impostiamo nella proprietà “Name” il valore “Testo”.
Qui di seguito riportiamo il codice completo.

<UserControl x:Class="WpfTest.AppView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006">
<Grid Width="738" Height="356" Background="LightBlue">
<TextBlock Name="OttieniTesto" HorizontalAlignment="Left" Margin="309,172,0,0" TextWrapping="Wrap" Text="TextBlock" VerticalAlignment="Top" Height="51" Width="180"/>
<TextBox Name="Testo" HorizontalAlignment="Left" Height="23" Margin="219,247,0,0" TextWrapping="Wrap" Text="TextBox" VerticalAlignment="Top" Width="120"/>
</Grid>
</UserControl>

Mentre nel file di tipo ".cs" inizializziamo i controlli.

public partial class AppView : UserControl
{
public AppView()
{
InitializeComponent();
}
}

Siamo giunti quasi alla fine del nostro applicativo.
Prima di procedere all’esecuzione dobbiamo apportare alcune modifiche al file "App.Xaml" con il quale indicare il file da eseguire.
Qui di seguito si riporta il codice completo del file "XAML" da notare l’attributo local che indica lo spazio dei nomi presenti nei vari file.
Mentre all’interno del nodo "ResourceDictionary", il nodo Local riporta il nome della classe bootstrapper.

<Application x:Class="WpfTest.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:local="clr-namespace:WpfTest"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary>
<local:AppBootstrapper x:Key="bootstrapper" />
</ResourceDictionary>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>

Qui di seguito si riporta il codice .cs

public partial class App : Application
{
public App()
{
InitializeComponent();
}
}

Ora non ci resta che eseguire il nostro applicativo e scrivere nella casella di testo un valore per mettere in pratica quanto scritto nelle varie classi.

Conclusioni

L’articolo ha voluto fornire una semplice tecnica di utilizzo del Framework Caliburn.Micro, per avvicinare il lettore a questo modo di scrivere applicazioni in ambito Windows Presentazione Foundation utilizzando il patern MVC.

Tanti i Framework che permettono una valida gestione delle interfaccie di tipo WPF ma questo risulta molto valido.

Commenti

Lascia una Risposta
captcha