Ciao,
sono disponibili e quindi scaribili i loghi ufficiali per il Windows Store.
– Windows Badge
– Windows Tile
– Tablet e Laptop device chassis
Qui trovate tutte le indicazioni del caso!!!
Maurizio
Ciao,
sono disponibili e quindi scaribili i loghi ufficiali per il Windows Store.
– Windows Badge
– Windows Tile
– Tablet e Laptop device chassis
Qui trovate tutte le indicazioni del caso!!!
Maurizio
Are you interested in keeping up to date and discussing topics about Windows 8, Windows 8 Store App,WinRT,XAML?
Don’t forget to join the new “Windows 8 App Developer” Group on Linkedin!!!!
Vuoi rimanere aggiornato e discutere su tematiche che riguardano Windows 8, Windows 8 Store App,WinRT,XAML?
Unisciti al gruppo “Windows 8 App Developer” su Linkedin!!
Maurizio
Ciao,
giusto in questi giorni durante la fase di realizzazione di un App per Windows 8, mi sono imbattuto nell’utilizzo di una delle novità del Framework 4.5, haimè poco pubblicizzate, ma che ritengo di notevole interesse, costituita dalla possibilità di manipolare archivi compressi con l’algoritmo Zip classico.
Stiamo parlando di un’aggiunta al già esistente namespace System.IO.Compression che ora viene incontro all’esigenza della gestione di archivi compressi.
Dopo questa prima sperimentazione posso assolutamente dire che questo nuovo namespace è un pò spartano, ma comunque un buon supporto se non abbiamo esigenze particolari, se invece abbiamo la necessità di usare funzionalità avanzate SharpZipLib e DotNetZip rimangono le library di riferimento. 🙂
Ad ampliare System.IO.Compression.dll ora abbiamo a disposizione il namespace System.IO.Compression.FileSystem.dll dove mettiamo in evidenza le classi:
System.IO.Compression.FileSystem.ZipFile
System.IO.Compression.FileSystem.ZipArchive
Partiamo con la classe ZipFile dove troviamo 2 metodi principali:
– CreateFromDirectory
– ExtractToDirectory
I due metodi ci permettono di zippare/upzippare un archivio in una determinata destinazione, vedi esempio qui sotto:
ZipFile.CreateFromDirectory("", "", CompressionLevel.Optimal, true)
ZipFile.ExtractToDirectory("", "")
Il nuovo namespace mette a disposizione due classi chiamate ZipArchive e ZipArchiveEntry, le quali rappresentano, rispettivamente, un archivio Zip e una entry, cioè un singolo elemento dello Zip/Archivio.
La classe ZipFile, vista in precedenza, espone un metodo Open che restituisce un’istanza di ZipArchive.
E’ quindi possibile leggere il contenuto dell’archivio eseguendo una semplice interazione della collezione Entries che risulta essere una ReadOnlyCollection vedi esempio:
using(ZipArchive zip = ZipFile.Open("", ZipArchiveMode.Read))
{
foreach(var item in zip.Entries)
{
Console.WriteLine("FileName: {0} ", item.FullName)
}
}
Ecco le proprietà della classe ZipArchiveEntry:
– FullName (che identifica il path completo del file)
– CompressedLength (dimensione in bytes da compresso)
– Length (la dimensione originaria del file)
– Name (nome senza il path)
– LastWriteTime (data/ora dell’ultima modifica)
Creazione di un Archivio compresso:
using(ZipArchive zip = ZipFile.Open("", ZipArchiveMode.Create))
{
zip.CreateEntry("", CompressionLevel.Optimal)
}
Modificare un archivio Zip esistente aggiungendo o rimuovendo file:
using(ZipArchive zip = ZipFile.Open("", ZipArchiveMode.Update))
{
zip.CreateEntry("", CompressionLevel.Fastest)
ZipArchiveEntry zipEntry = zip.GetEntry("")
zipEntry.Delete()
}
Vista la semplicità di utilizzo non mi soffermerei troppo sulle varie implementazioni mostrate, ma aggiugeree qualche considerazione:
– La classe ZipArchive implementa l’interfaccia IDisposable quindi è consigliato l’utilizzo nel blocco using.
– Durante la creazione di un archivio compresso i file elencati verranno aggiunti allo Zip solo quando il blocco using sarà finalizzato.
– Nella fase di Update di un archivio compresso, le modifiche saranno applicate solo quanto il blocco using sarà finalizzato.
Bene, credo di avervi raccontato tutta la mia esperienza sull’argomento, come accennato prima, il nuovo utilissimo namespace è ancora un pò spartano viste le poche funzionalità a disposizione, ma è comunque un inizio è un buon supporto nell’attesa di una sua estensione nelle prossime versioni del Framework.
Maurizio 🙂
Ciao,
vediamo come utilizzare il controllo SettingFlyout messo a disposizione dalla Callisto Library per la nostra Settings Charm.
Partendo dal post precedente dove abbiamo parlato e visto come scaricare la Callisto Library ora proviamo ad utilizzarla per realizzare una
Settings Charm per le nostre Windows 8 Apps.
Qui ci mettiamo in ascolto sulla richiesta da parte dell’utente della Setting Pane:
protected override void OnNavigatedTo(NavigationEventArgs e)
{
SettingsPane.GetForCurrentView().CommandsRequested += OnSettingsPane_CommandsRequested;
base.OnNavigatedTo(e);
}
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
SettingsPane.GetForCurrentView().CommandsRequested -= OnSettingsPane_CommandsRequested;
base.OnNavigatedFrom(e);
}
Nel delegato andiamo a definire la nostra SettingFlyout:
private void OnSettingsPane_CommandsRequested(SettingsPane sender,SettingsPaneCommandsRequestedEventArgs args)
{
SettingsCommand cmd = new SettingsCommand("", "", (x) =>
{
//nuova SettingsFlyout - CallistoLibrary
SettingsFlyout settings = new SettingsFlyout();
//Configurazione
settings.FlyoutWidth = Callisto.Controls.SettingsFlyout.SettingsFlyoutWidth.Wide;
settings.HeaderBrush = new SolidColorBrush(Color.FromArgb(255, 139, 69, 19));
settings.HeaderText = "
settings.Background = new ImageBrush { ImageSource = new BitmapImage(new Uri(@"ms-appx:/Assets/BackgroundImage.png")) };
//Contenuto della SettingsFlyout
settings.Content = new SettingContent();
settings.IsOpen = true;
});
args.Request.ApplicationCommands.Add(cmd);
}
Molto rapidamente abbiamo configurato la nostra Settings Charm creando un nuovo SettingsCommand e definendo al suo interno una SettingsFlyout parte della Callisto Library.
In aggiunta come esempio ho creato una page di contenuto dedicata SettingContent fatta in questo modo:
<Page
x:Class=".SettingContent"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">
<TextBlock Text="" FontSize="28" Margin="10,0,0,0" />
<TextBox x:Name="" Width="400"
HorizontalAlignment="Left" Margin="10,0,0,0" />
Ecco il risultato finale:
Ciao a tutti,
per esperienza personale pubblico questo POST!!!! 😦
Se state sviluppando un App per Windows 8 o siete pronti per la fase si Certificazione a parte ricordarvi di leggere tutti i “requirements” necessari per l’approvazione vi ricordo vivamente la Privacy.
La “Privacy” deve apparire in due step:
– Description Page pagina di dettaglio del prodotto sullo Store, qui deve comparire un rimando alla Privacy and Policy.
– Settings Charm anche qui deve comparire un rimando alla stessa Privacy.
Tutto queste è necessario se la Vostra App utilizza in qualche informazioni personali, condivisione, memorizzazione, etc etc …
Vi ricordo questo, prima di ricevere un bel “Reject” dell’App dopo l’attesa di 7 giorni.
Maurizio 🙂
Ciao a tutti,
per tutti quelli che hanno vogliono imparare a sviluppare App per Windows 8 eccovi un paio di link utili:
– Download Windows 8 Camp in a Box!
Risorse risorse per imparare a conoscere Windows 8, WinRT, HTML5, XAML, etc etc …. 🙂
Maurizio
Ciao a tutti,
devo obbligatoriamente segnalare (per chi non fosse a conoscenza) e dopo aver lavorato direttamente con questo toolkit, che arriva in soccorso per lo sviluppo delle nostre Win 8 Apps.
Callisto è un appunto una library scaricabile liberamente da github oppure tramite NuGET.
Al suo interno troveremo oltre alla demo, diversi controlli, helper, converter, nati per semplificarci la vita … 🙂
Un breve elenco delle features presenti:
– Flyout (a primitive that includes positioning and ‘light dismiss’ logic)
– Menu (primarily to be used from AppBar, contains the base for providing, well, a Menu)
– MenuItem (an item for a menu, including separators and contains the command point for the menu item)
– SettingsFlyout (an item to create a custom settings pane UI)
– Rating (a ratings control for Metro UI)
– LiveTile (an in-app tile experience to give you animated or ‘live’ tiles)
– Tilt (an effect to provide the tilt experience when clicked on edges/corners)
– OAuth helpers (a set of helpers to create OAuth 1.0 signatures/headers for those sites that hate OAuth 2.0)
– BooleanToVisibilityConverter
– LengthToBooleanConverter
– RelativeTimeConverter
– Extensions
Onori agli sviluppatori di questo toolkit: Tim Heuer and Morten Nielsen.
Buon Win 8 App a tutti 🙂
Maurizio
Ciao a tutti,
prima di riprendere con gli articoli legati all’uso del Pattern MVVM sulle Windows 8 Apps, parleremo di come manipolare i settings localmente.
La prima cosa che balza all’occhio quando si è davanti ad un progetto Windows 8 Store App e che non abbiamo più a disposizione il file App.Config, ormai storico compagno da anni 🙂 (che nel bene o nel male ci permetteva di salvare parti di configurazione in modo molto rapido)
Quindi la domanda successiva è: Come posso gestire i miei Settings?
WinRT ci fornisce diverse nuove API pronte all’uso che ci rendono il lavoro molto più semplice è veloce per manipolare, caricare, memorizzare i nostri dati.
Facciamo un passo indietro, prima di vedere come è possibile manipolare dei dati in locale dobbiamo conoscere cosa avviene dietro le quinte durante un Deploy piuttosto che un Download/Installazione dallo Store.
Windows 8 crea per noi una folder dove risiede il nostro Package (App) e una cartella sotto il path: user/appdata/local/packages/ dove possiamo liberamente andare a scrivere, leggere, creare cartelle, manipolare dati.
<code
//Qui la struttura di esempio dopo un Deploy
MyAppFolder
– (installazione dell'App e Folder Dedicata)
// Qui AppDataFolder per MyAppFolder
user/appdata/local/packages/
– LocalState
– RoamingState
– TempState
– Settings
Ecco come accedere alle rispettive Folder/Settings sopra descritte:
//Roaming
Windows.Storage.ApplicationData.Current.RoamingFolder
Windows.Storage.ApplicationData.Current.RoamingSettings
//Local
Windows.Storage.ApplicationData.Current.LocalFolder
Windows.Storage.ApplicationData.Current.LocalSettings
//Temp
Windows.Storage.ApplicationData.Current.TemporaryFolder
– Settings: semplici settaggi accessibili dalla “Settings Charm” che possono essere sincronizzati tra macchine (Roaming)
– LocalSettings: dati persistenti tra le sessioni di un App
– Temporary: dati in cache temporanea utilizzata come area di lavoro, garantiscono ottime prestazioni.
Qui il <link> per il download degli esempi.
Un breve esempio di come scrivere i nostri Settings, l’accesso e tramite IDictionary quindi i tipi base a disposizione in WinRT:
//RoamingSettings
Windows.Storage.ApplicationData.Current.RoamingSettings.Values[“MyRoamingSetting] = MyRoamingValue;
//LocalSettings
Windows.Storage.ApplicationData.Current.LocalSettings.Values[“MyLocalSetting] = MyLocalValue;
Quando usiamo i RoamingSettings è perchè abbiamo pensato ad una possibile installazione dell’App su più Device che accedono con la stessa utenza, a questo punto Windows 8 sincronizzerà per noi il contenuto.
Ora vi mostro un esempio di classe in grado di gestire dei Settings:
// SettingsHelper
public static class SettingsHelper
{
public static ApplicationDataContainer SettingsContainer { get; set; }
static SettingsStore()
{
SettingsContainer = ApplicationData.Current.LocalSettings;
/* SettingsContainer = ApplicationData.Current.RoamingSettings; */
}
///
public static string AppName
{
get { return SettingsContainer.Values["AppName"] as string; }
set { SettingsContainer.Values["AppName"] = value; }
}
///
public static string RootFolder
{
get { return SettingsContainer.Values["RootFolder"] as string; }
set { SettingsContainer.Values["RootFolder"] = value; }
}
}
Come possiamo notare, molto velocemente siamo in grado di cambiare il settings su cui andremo a leggere/scrivere senza modificare la rimanenza del codice.
Questo esempio di classe è utilizzabile con la SettingsCharm, chiaro dovremo aggiungere 2 funzionalità per fare il Load/Save dei dati. 🙂
Buon Windows 8 App a tutti!!! 🙂
Maurizio
Ciao a tutti,
oggi inizieremo con una serie di post/articoli che parleranno di come applicare MVVM alle Windows 8 Apps.
Chi viene dallo sviluppo di Applicazioni per Windows Phone si sarà già imbattuto e quindi saprà bene come risolvere il problema del NavigationService.
Il NavigationService è quella classe che ci permette di effettuare la navigazione in stile browser nelle nostre applicazioni Windows 8 e Windows Phone (per maggiori dettagli sulla classe visitate il link su MSDN).
Normalmente utilizzeremo il NavigationService quando abbiamo la necessità di cambiare pagina magari al variare di una Proprietà piuttosto che sull’azione associata ad un determinato comando.
L’unico problema che salta subito all’occhio è che il NavigationService è accessibile solo tramite il Code Behind della pagina e quindi non accessibile dal nostro ViewModel.
Per risolvere questo problema ci sono diverse soluzioni, la più elegante è quella di implementare un wrapper del NavigationService… ecco qui un snippet di esempio:
//Interfaccia INavigationService
public interface INavigationService
{
void GoBack();
void GoForward();
bool Navigate(object parameter = null);
bool Navigate(Type source, object parameter = null);
}
//NavigationHelper
public class NavigationService : INavigationService
{
private Frame rootFrame { get; set; }
//Qui passeremo come parametro il Frame initializzato nel App.cs
public NavigationHelper(Frame rootFrame)
{
this.rootFrame = rootFrame;
}
public void GoBack()
{
this.rootFrame.GoBack();
}
public void GoForward()
{
this.rootFrame.GoForward();
}
public bool Navigate(object parameter = null)
{
return this.rootFrame.Navigate(typeof(T), parameter);
}
public bool Navigate(Type source, object parameter = null)
{
return this.Navigate(source, parameter);
}
}
Quindi, abbiamo definito un’interfaccia che in sostanza espone le stesse funzionalità di navigazione che avremmo a disposizione nel NavigationService presente nel Code Behind e di seguito la sua implementazione.
Ora non ci rimane che inizializzare il nostro NavigationService nell’App.xaml.cs tramite Dependency Injection (IOC).
Per quanto rigurda IOC possiamo utilizzare qualsiasi soluzione compatibile con WinRT, io come sempre consiglio Galasoft Toolkit di Laurent Bugnion.
protected override void OnLaunched(LaunchActivatedEventArgs args)
{
var rootFrame = new Frame();
if (args.PreviousExecutionState == ApplicationExecutionState.Running)
{
Window.Current.Activate();
return;
}
if (args.PreviousExecutionState == ApplicationExecutionState.Terminated || args.PreviousExecutionState==ApplicationExecutionState.NotRunning)
{
SimpleIoc.Default.Register(typeof (INavigationService), new NavigationService(rootFrame));
}
if (!rootFrame.Navigate(typeof(MainPage)))
{
throw new Exception("Failed to create initial page");
}
// Place the frame in the current Window and ensure that it is active
Window.Current.Content = rootFrame;
Window.Current.Activate();
}
Nell’esempio andiamo a registrare l’istanza del NavigationService nel momento in cui l’App si trova diciamo “In Stato di Fermo” 😀
“SimpleIoc” fa riferimento all’utilizzo del Galasoft Toolkit dove di “default” introduce il ViewModelLocator con un’implementazione di IOC chiamata appunto SimpleIoc.
Nei nostri ViewModel avremo così a disposizione il nostro NavigationService:
protected INavigationService navigationService;
public MyViewModel(INavigationService navigationService)
{
this.navigationService = navigationService;
}
A questo punto non vi rimane che divertirvi con i vostri ViewModel e le vostre Apps di Windows 8 😀
Credo di aver raccontato tutto 😀
Buon Windows 8 Apps!!!
Maurizio

E’ ufficialmente pubblicata la nuova major release di MetroNote, l’Applicazione che permette la completa gestione dei vostri Post-it/Memo che ora è diventata GRATUITA.
Quali sono le nuove funzionalità? MetroNote consentirà di:
– cambiare tema (“metal” o “wood”) dello sfondo
– cambiare il colore delle note
– inserire un mark sulle note più importanti
– condividere le note tramite la Share Charm
– aggiungere le note alla Start
… e altro ancora! Aspettate e vedrete!
Ecco il link per vederla sul Windows Store: MetroNote
Maurizio