Alessandro Del Sole's Blog

{ A programming space about Microsoft® .NET® }
posts - 1908, comments - 2047, trackbacks - 352

My Links

News

Your host

This is me! Questo spazio è dedicato a Microsoft® .NET®, di cui sono molto appassionato :-)

Cookie e Privacy

Disabilita cookie ShinyStat

Microsoft MVP

My MVP Profile

Microsoft Certified Professional

Microsoft Specialist

Xamarin Certified Mobile Developer

Il mio libro su VB 2015!

Pre-ordina il mio libro su VB 2015 Pre-ordina il mio libro "Visual Basic 2015 Unleashed". Clicca sulla copertina per informazioni!

Il mio libro su WPF 4.5.1!

Clicca sulla copertina per informazioni! E' uscito il mio libro "Programmare con WPF 4.5.1". Clicca sulla copertina per informazioni!

These postings are provided 'AS IS' for entertainment purposes only with absolutely no warranty expressed or implied and confer no rights.
If you're not an Italian user, please visit my English blog

Le vostre visite

I'm a VB!

Guarda la mia intervista a Seattle

Follow me on Twitter!

Altri spazi

GitHub
I miei progetti open-source su GitHub

Article Categories

Archives

Post Categories

Image Galleries

Privacy Policy

WPF: fondamenti sulla localizzazione con Visual Basic

La localizzazione delle applicazioni è diventata, al giorno d’oggi, una pratica molto importante e, in molti casi, addirittura essenziale. Windows Presentation Foundation offre la possibilità allo sviluppatore .NET di localizzare le applicazioni in modo piuttosto diverso da quello che avevamo conosciuto in Windows Forms.

 

Partiamo con la nota dolente: allo stato attuale la localizzazione di applicazioni WPF si ottiene attraverso una serie di operazioni manuali, utilizzando un tool a riga di comando. Non c’è, quindi, alcun supporto visuale o del designer di Visual Studio 2008.

La nota positiva: la logica di organizzazione delle risorse è, a mio avviso, migliore perché si sfruttano assembly “satellite”.

 

Cosa occorre

 

Il primo strumento di cui abbiamo necessità per localizzare un’applicazione WPF si chiama LocBaml ed è uno strumento che funziona dalla riga di comando. Tra l’altro, non viene distribuito in forma eseguibile ma come progetto in formato sorgente attraverso la MSDN Library.

Detto questo, fate clic su questo collegamento. Nella pagina della MSDN Library che si aprirà, troverete il link per scaricare il progetto sorgente in C# relativo a LocBaml. Aprite il progetto appena scaricato in Visual Studio 2008 e compilatelo semplicemente. Se volete, potete copiare il file LocBaml.exe così generato dalla cartella Bin\Debug o Bin\Release in un’altra cartella di più semplice reperimento.

 

Fondamenti sulla localizzazione

 

Il gioco della localizzazione, in WPF, si svolge attraverso le risorse. In parole molto povere, le risorse definite nello XAML vengono, in fase di compilazione, convertite in file .Baml (particolari file più efficienti nel parsing) ciascuno dei quali è definito come risorsa nell’assembly eseguibile. Da qui, il tool di cui sopra prende il nome di LocBaml.

 

Il primo passaggio da eseguire per rendere localizzabile un’applicazione WPF consiste nella modifica del file di progetto, quindi quello con estensione .VbProj (.CsProj in C#). Supponendo di aver creato un progetto WPF vuoto in Visual Basic 2008, aprite questo file con un qualunque editor (anche il Notepad va bene). Come probabilmente sapete, si tratta di un file Xml che contiene le informazioni relative a ciò che costituisce il nostro progetto. All’interno di una delle sezioni chiamate PropertyGroup, aggiungete la seguente riga:

 

    <UICulture>it-IT</UICulture>

 

In questo modo stiamo specificando quale oggetto Culture debba connotare l’interfaccia della nostra applicazione, in questo caso la localizzazione italiana. Fatto questo, si può passare a stabilire quali elementi dell’interfaccia debbano essere localizzati. E’ infatti possibile specificare singoli elementi e/o controlli da localizzare.

 

Localizzare gli elementi dell’interfaccia

 

Supponiamo di avere il seguente, banalissimo XAML che definisce una finestra con un pulsante e un TextBlock:

 

<Window x:Class="Window1"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    Title="Test localizzazione WPF" Height="300" Width="300">

   

    <StackPanel>

        <TextBlock Text="Testo inutile" Name="WelcomeTextBlock" />

       

        <Button Name="TestButton" Content="Clicca qui" Width="100"/>

    </StackPanel>

</Window>

 

Ipotizziamo di voler rendere localizzabili il titolo della finestra, il testo contenuto nel TextBlock e il contenuto del pulsante. Ciascun elemento che vogliamo rendere localizzabile dev’essere contrassegnato da un attributo x:Uid, il cui valore è un identificatore che richiami il nome assegnato al controllo (è richiesto da MSBuild.exe). Modifichiamo quindi i singoli elementi come di seguito:

 

<Window x:Class="Window1" x:Uid="Window_1"

 

        <TextBlock Text="Testo inutile" Name="WelcomeTextBlock" x:Uid="Welcome_TextBlock"/>

       

        <Button Name="TestButton" x:Uid="Test_Button" Content="Clicca qui" Width="100"/>

 

Ora provate ad avviare l’applicazione. All’apparenza non c’è nulla di diverso, infatti il risultato ottenuto è il seguente:

 

 

 

Se però andate a curiosare nella sottocartella Bin\Debug, troverete una sorpresa. C’è infatti una cartella chiamata it-IT, contenente un assembly il cui nome è quello del vostro progetto seguito dalla dicitura resources.dll. Tale assembly contiene, fra le varie cose, le risorse che noi abbiamo definito come localizzabili. Si tratta quindi di un assembly satellite che viene caricato all’avvio dell’applicazione proprio con fini di localizzazione.

 

Forse si inizia a capire qualcosa in più: seguendo la logica di definizione delle Culture (es. it-IT, en-US, en-GB, fr-FR) è necessario creare tante sottocartelle quante sono le Culture di nostro interesse e produrre tanti assembly localizzati quante sono le Culture stesse. Questo procedimento non è complesso, ma è un tantino macchinoso dovendo essere eseguito manualmente. Vediamo ora come fare.

 

Utilizzare LocBaml e Microsoft Excel

 

Per prima cosa, copiamo LocBaml.exe nella cartella dove risiede l’eseguibile della nostra applicazione, ad esempio nella cartella Bin\Debug. Dobbiamo estrarre il contenuto localizzabile dal nostro assembly e lo possiamo fare utilizzando la seguente riga di comando:

 

LocBaml.exe /parse it-IT\MyApplication.exe

 

Dove MyApplication.exe è il nome dell’eseguibile della nostra applicazione. LocBaml genera un file .Csv, quindi con campi separati da virgola, all’interno del quale sono definite le varie risorse tra cui quelle localizzabili. Il nome del file .Csv diventa, nell’esempio proposto, MyApplication.Resources.Csv. Proviamo ad aprire il file .Csv con Microsoft Excel. Come si può vedere dalla seguente figura, ci sono le risorse che noi abbiamo indicato come localizzabili:

 

 

 

Ci sono anche altre proprietà per i vari oggetti, che però non discuteremo in questo post. Vi rimando, al proposito, alla libreria MSDN. Ipotizziamo di voler generare una localizzazione della nostra applicazione per la lingua inglese, basata sulla Culture “en-US”, quindi Inglese (Stati Uniti). Modifichiamo il file .Csv come segue:

 

 

 

Salviamo le modifiche assegnando al file un altro nome, ad esempio MyApplication.Resources.enUS.Csv. Ora possiamo compilare il nostro assembly satellite per la localizzazione inglese.

 

Compilare l’assembly satellite

 

Riprendiamo LocBaml e digitiamo la seguente riga di comando:

 

LocBaml.exe /generate it-IT\MyApplication.Resources.dll /trans:MyApplication.Resources.enUS.csv /cul:en-US /out:en-US

 

Tale riga di comando indica a LocBaml di prendere a base l’assembly satellite precedente (/generate), di tradurre il contenuto del nuovo file .csv (/trans), la Culture di destinazione (/cul) e la folder che conterrà l’assembly satellite (/out).

 

Ora ci sarà una nuova cartella chiamata en-US che conterrà un assembly chiamato MyApplication.Resources.dll (quindi identico a quello originario) che però contiene le informazioni localizzate.

 

Test dell’applicazione

 

Proviamo a simulare la Culture di tipo en-US per la nostra applicazione. Andiamo nel file Application.xaml.vb e all’interno del costruttore della classe Application digitiamo la seguente riga di codice:

 

        System.Threading.Thread.CurrentThread.CurrentUICulture = New Globalization.CultureInfo("en-US")

 

La riga in questione assegna la Culture “en-US” al thread che rappresenta l’interfaccia. Avviando l’applicazione, questo è il risultato:

 

 

 

Ovviamente la localizzazione è un procedimento tendenzialmente più complesso, dove ad esempio può essere necessario localizzare e richiamare file esterni. In ogni caso abbiamo iniziato a capire come funziona il discorso, mentre la MSDN Library ci viene in aiuto con la documentazione ufficiale in merito alla trattazione. Documenti di interesse possono essere questo e questo.

 

Il progetto sorgente che ho utilizzato in questo post, comprensivo dei file .Csv, è scaricabile da questo indirizzo dell’area Download di Visual Basic Tips & Tricks.

 

Alessandro

Print | posted on martedì 5 maggio 2009 01:42 | Filed Under [ Visual Basic Windows Presentation Foundation ]

Powered by:
Powered By Subtext Powered By ASP.NET