Introduzione
Vedremo, come gestire le informazioni di un video gioco (livello e punteggio) tramite la tecnica dello storage, ossia archiviare i dati per la relativa lettura e scrittura, utilizzando l’architettura e le classi messe a disposizione dalla piattaforma XNA.
Di norma gli oggetti ed i file (multimediali, suoni, ecc) vengono gestiti nelle pipeline dei contenuti (illustrato in un precedente articolo), ma in questo articolo vedremo come gestire un file xml, tramite lo storage di XNA per gestire informazioni come punteggio e livello.
Creazione del file XML
Si riporta la creazione di un file xml, da inserire nel progetto.
Tramite la finestra esplora soluzione, fate click con il tasto destro sul nome del progetto, selezionate come categoria “Data” mentre come modello “File XML”.
Qui di seguito si riporta il file xml.
Il file lo rinominiamo in Dati.Dat.
Spazio dei nomi
Aggiungiamo al progetto i seguenti spazio dei nomi per gestire la serializzazione, i file e lo storage.
Qui di seguito si riporta un esempio di codice
using Microsoft.Xna.Framework.Storage;
using System.IO;
using System.Xml.Serialization;
using System.Diagnostics;
Creazione della classe
Prima di procedere alla stesura di codice, sempre nel file Games1.cs, nella classe games, si crea una classe, che dovrà gestire le informazioni.
Qui di seguito, si riporta la classe per la gestione delle informazioni.
public class InfoGioco
{
public int livello { get; set; }
public int punteggio { get; set; }
}
Stesura del codice
Passiamo alla classe del gioco, creando gli opportuni oggetti.
Dichiariamo a livello di classe, gli oggetti da utilizzare nel video gioco.
Gli oggetti che servono, sono relativi alla gestione del gioco, la gestione della tastiera, la gestione dello storage, la gestione delle attività, tramtie un oggetti interfaccia, per il risultato della sincronizzazione, un oggetto relatvo storegaontainer.
Oggetti che ci servono per gestire i file, cartelle, informazioni e lo stato delle varie operazioni.
Qui di seguito si riporta tali dichiarazioni a livello di classe.
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
KeyboardState keyState;
GamePadState padState;
StorageDevice storageDevice;
IAsyncResult asyncResult;
PlayerIndex playerIndex = PlayerIndex.One;
StorageContainer storageContainer;
string filename = "Dati.dat";
InfoGioco SalvataggioDati;
InfoGioco AperturaDati;
Nell’evento “initilize”, impostiamo alcuni oggetti, ed in particoliare inizializziamo gli oggetti relativi alle informazioni della classe creata in precedenza, ossia InfoGioco.
Si riporta il codice completo dell'event Inizitialize.
protected override void Initialize()
{
// TODO: Add your initialization logic here
AperturaDati = new InfoGioco();
SalvataggioDati = new InfoGioco();
base.Initialize();
}
Salvataggio dei dati
Si crea la funzione per il salvataggio dei dati.
La funzione accetta due parametri di tipo intero, relativi a punteggio e livello.
Tramite il metodo EndShowSelector, gestiamo lo storage.
Una volta ottenuto un oggetto di tipo “storageDevice” tramite il metodo “BeginOpenContainer” indicando il nome dello storage (sarà una cartella chiamata che verrà generata sul pc) , mentre il metodo EndOpenContainer, avrà il compito di creare un oggetto per gestire il contenuto dello storage, in modo che possiamo generare un oggetto di tipo “storagecontainer” . Tramite la serializzazione si crea il file con i valori.
Si riporta qui di seguito la funzione SalvaDati, per il salvataggio dei dati
private void SalvaDati(int punteggio, int livello)
{
//inizializzo l'oggetto per la gestione dello storage in questo modo possiamo gestire la sincronizzazione
storageDevice = StorageDevice.EndShowSelector(asyncResult);
//salvo i dati
SalvataggioDati = new InfoGioco();
SalvataggioDati.punteggio = punteggio;
SalvataggioDati.livello = livello;
AperturaDati = null;
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
// attende l'esecuzione
asyncResult.AsyncWaitHandle.WaitOne();
storageContainer = storageDevice.EndOpenContainer(asyncResult);
//chiudo la sincronizzazione
asyncResult.AsyncWaitHandle.Close();
try
{
//se il file esiste lo cancello
if (storageContainer.FileExists(filename))
{
storageContainer.DeleteFile(filename);
}
//salvo il file nuovo
using (Stream stream = storageContainer.CreateFile(filename))
{
XmlSerializer serializer = new XmlSerializer(
typeof(InfoGioco));
serializer.Serialize(stream, SalvataggioDati);
//libero la memoria
stream.Close();
}
}
catch (IOException e)
{
//errore
Debug.WriteLine(e.Message);
}
finally
{
//libero la memoria
storageContainer.Dispose();
}
}
Nell’evento update, scriviamo il codice che permette di invocare tale funzione, nel caso che viene digitato il tasto "A"
Qui di seguito si riporta il codice che invoca la funzione precedentemente creata.
//A per salvare i dati
if (
keyState.IsKeyDown(Keys.A))
{
asyncResult = StorageDevice.BeginShowSelector(playerIndex, null, null);
SalvaDati(5, 5);
}
Lettura dei dati
La funzione carica dati, ha il compito di visualizzare (utilizzeremo Debug.writeline) le informazioni relative al file.
Questa funziona accetta un solo parametro, in particolare un'interfaccia di tipo “IAsyncResult” che verrà generato da un oggetto di tipo StorageDevice, anche in questa funzione, come in altre, andremo a creare oggetti di tipo per la gestione dello storage, il tutto tramite un oggetto di tipo “StorageContainer”.
Anche in questo caso, tramtie la serializzazione del file Dati.dat, che ricordiamo è un file xml, andremo a leggere il contenuto del file.
Si riporta il codice completo di tale funzione.
private void caricaDati(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
// attende l'esecuzione
result.AsyncWaitHandle.WaitOne();
storageContainer = storageDevice.EndOpenContainer(asyncResult);
//chiudo la sincronizzazione
asyncResult.AsyncWaitHandle.Close();
//se il file non esiste, esco e libero la memotira
if (!storageContainer.FileExists(filename))
{
//libero la memoria
storageContainer.Dispose();
return;
}
// Apro il file e serializzo
using (Stream stream = storageContainer.OpenFile(filename, FileMode.Open, FileAccess.Read))
{
XmlSerializer serializer = new XmlSerializer(typeof(InfoGioco));
AperturaDati = (InfoGioco)serializer.Deserialize(stream);
}
//libero la memoria
storageContainer.Dispose();
storageContainer = null;
Debug.WriteLine("Livello: " + AperturaDati.livello.ToString());
Debug.WriteLine("Score: " + AperturaDati.punteggio.ToString());
}
Nell'evento "Update" scriviamo il codice che invoca tale funzione, nel caso che si digita il pulsante "B" viene invocata tale funzione, l’oggetto “object” passato al metodo BeginShowSelect, fornisce lo stato all’oggetto di sincronizzazione.
//B carica i dati
if (padState.Buttons.B == ButtonState.Pressed ||
keyState.IsKeyDown(Keys.B))
{
//apre il file
storageDevice = null;
object stato = (Object)"Carica Dati";
StorageDevice.BeginShowSelector(playerIndex, this.caricaDati, stato);
}
Copia file
La funzione copiafile, permette di copiare il file nello stesso storage Le prime righe sono identiche alla funzione precedente, quindi non le illustriamo, tramite l’oggetto Stream, ed il metodo copyto, si copia il contenuto del file da uno stream ad un altro.
Si riporta il codice completo di tale funzione.
private void CopiaFile(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attende l'esecuzione
result.AsyncWaitHandle.WaitOne();
storageContainer = storageDevice.EndOpenContainer(asyncResult);
// chiudo la sincronizzazione
asyncResult.AsyncWaitHandle.Close();
string FileNuovo = "Dati2.dat";
//Verifico che il file esiste
if (storageContainer.FileExists(filename) && !storageContainer.FileExists(FileNuovo))
{
using (Stream stream = storageContainer.OpenFile(filename, FileMode.Open, FileAccess.Read))
{
Stream fileCopiato = storageContainer.CreateFile(FileNuovo);
stream.CopyTo(fileCopiato);
fileCopiato.Close();
fileCopiato.Dispose();
}
}
//libero la memoria
storageContainer.Dispose();
}
Nell’evento "Update", richiamiamo tale “metodo” tramite il metodo “BeginShowSelector” della classe StorageDevice, sempre passando lo stato.
Nel caso che si digita il tasto "C" viene invocata tale funzione.
Riporta il codice completo dell'evento "Update"
//C Copia i dati
if (
keyState.IsKeyDown(Keys.C))
{
//copia il file
storageDevice = null;
object stato = (Object)"Copia file per giocatore 1";
StorageDevice.BeginShowSelector(playerIndex, this.CopiaFile, stato)
}
Rinomina file
La rinomina dei file, avviene copiando il file, e cancellando quello esistente.
Qui di seguito si riporta la funzione di ciò. Le funzionalità sono le stesse di quelle viste per la Copia dei file.
Tramtie l’oggetto Stream, si copia il contenuto del file da copiare e si genera un nuovo file con il contenuto copiato.
Riportiamo il codice completo per la funzione "Rinomina"
private void Rinomina(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
string FileRinominato = "CopiaDiDati.dat";
//Verifico che il file esiste
if (storageContainer.FileExists(filename) && !storageContainer.FileExists(FileRinominato))
{
using (Stream stream = storageContainer.OpenFile(filename, FileMode.Open, FileAccess.Read))
{
Stream streamfileRinominato = storageContainer.CreateFile(FileRinominato);
stream.CopyTo(streamfileRinominato);
streamfileRinominato.Close();
streamfileRinominato.Dispose();
//Cancello il file
//storageContainer.DeleteFile(filename);
}
}
//libero la memoria
storageContainer.Dispose();
}
Nell’evento update scriviamo il codice che invochi tale funzione, anch’essa identica alle precedenti, utilizzando il metodo beginShowSeelector, passando diversi parametri, come stato, nome funzione e giocatore.
if (
keyState.IsKeyDown(Keys.R))
{
//copia il file
storageDevice = null;
object stato = (Object)"Rinomina file per giocatore 1";
StorageDevice.BeginShowSelector(playerIndex, this.Rinomina, stato);
}
Rilevare le informazioni
Tramite la classe StrorageContainer, possiamo rilevare informazioni riguardante lo spazio di archiviazione,
Le prime righe sono simili a quello precedenza, tranne il fatto, di utilizzare il metodo CreateDirectory, di un oggetto della classe “StorageContainer”, mentre la proprietà Freeaspace ci restituisce lo spazio disponibile, e la proprietà TotalSpace, lo spazio totale che abbiamo nel nostro pc.
Riportiamo un esempio di codice di tale operazioni, la funzione "InfoStorage" ci fornisce ciò. Mentre nell'evento "Update" tramite la pressione del taso "I" invochiamo tale funzione.
private void InfoStorage(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
//nuova cartella
storageContainer.CreateDirectory("NuovaCartella");
//spazio libero sul pc
long spaziolibero = storageContainer.StorageDevice.FreeSpace / 1000000000;
long CapienzaMassima = storageContainer.StorageDevice.TotalSpace / 1000000000;
//libero la memoria
storageContainer.Dispose();
}
//Qui il codice da utilizzare nell’evento update, quando si digita il pulsante “I”
//I Informazioni
if (
keyState.IsKeyDown(Keys.I))
{
//copia il file
storageDevice = null;
object stato = (Object)"Informazioni Storage";
StorageDevice.BeginShowSelector(playerIndex, this.InfoStorage, stato);
}
Ottenere i nomi di file e cartelle
Tramite una semplice funzione, possiamo rilevare tutti i nomi e cartelle del nostro spazio di archiaviazione, qui si riporta un esempio di codice.
Anche in questo caso, il codice è simile al precedente, utilizzando un oggetto StorageDevice e StorageContainer,
Tramite i metodi GetFileNames e GetDirectoryNames, si ottengono i nomi di tutti i file e cartelle presenti nello spazio di archiaviazione.
private void OttieniCartelleFile(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
string[] listaFiles = storageContainer.GetFileNames();
string[] listaCartelle = storageContainer.GetDirectoryNames();
foreach (string file in listaFiles)
{
Debug.WriteLine("File: " + file);
}
foreach (string cartella in listaCartelle)
{
Debug.WriteLine("Cartella: " + cartella);
}
//libero la memoria
storageContainer.Dispose();
}
Mentre per utilizzarlo, sempre nell’evento "Update", verifichiamo che l’utente ha digitato il pulsante “O” ed eseguiamo il codice, per richiamare la funzione precedentemente citata.
//Ottiene Info cartelle e file
if (
keyState.IsKeyDown(Keys.O))
{
//copia il file
storageDevice = null;
object stato = (Object)"Ottieni cartelle e file Storage";
StorageDevice.BeginShowSelector(playerIndex, this.OttieniCartelleFile, stato);
}
Cancellazione dei file
Siamo giunti alla conclusione delle varie funzioni e operazioni che possiamo compiere nello storage, in questo esempio, vedremo la possibilità di cancellare file , il tutto avviene, utilizzando il metodo "DeleteFile" della classe "StorageContainer", che dato il nome del file, verrà cancellato.
Le classi per gestire lo storage sono “StorageDevice” e “StorageContainer”, qui di seguito si riporta il codice completo della funzione "EliminaFile" riguardante la cancellazione del file.
private void EliminaFile(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
string FileDaEliminare = "CopiaDiDati.dat";
if (storageContainer.FileExists(FileDaEliminare))
{
storageContainer.DeleteFile(FileDaEliminare);
}
//libero la memoria
storageContainer.Dispose();
}
Ora vediamo come richiamare tale codice nell’evento update, dopo aver accertato che il tasto digitato è la lettera “E”, sempre tramite il metodo BeginShowSelector, richiamiamo la funzione per la cancellazione dei file
//Elimina il file
if (
keyState.IsKeyDown(Keys.E))
{
//copia il file
storageDevice = null;
object stato = (Object)"Elimina file";
StorageDevice.BeginShowSelector(playerIndex, this.EliminaFile, stato);
}
Si riporta il codice completo delle operazioni elencate in precedenza
//spazio dei nomi
using Microsoft.Xna.Framework.Storage;
using System.IO;
using System.Xml.Serialization;
using System.Diagnostics;
namespace XNAStorage
{
public class InfoGioco
{
public int livello { get; set; }
public int punteggio { get; set; }
}
/// <summary>
/// This is the main type for your game
/// </summary>
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
KeyboardState keyState;
GamePadState padState;
StorageDevice storageDevice;
IAsyncResult asyncResult;
PlayerIndex playerIndex = PlayerIndex.One;
StorageContainer storageContainer;
string filename = "Dati.dat";
InfoGioco SalvataggioDati;
InfoGioco AperturaDati;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
// TODO: Add your initialization logic here
AperturaDati = new InfoGioco();
SalvataggioDati = new InfoGioco();
base.Initialize();
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// all content.
/// </summary>
protected override void UnloadContent()
{
// TODO: Unload any non ContentManager content here
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
keyState = Keyboard.GetState();
if (keyState.IsKeyDown(Keys.Escape)) this.Exit();
//A per salvare i dati
if (
keyState.IsKeyDown(Keys.A))
{
asyncResult = StorageDevice.BeginShowSelector(playerIndex, null, null);
SalvaDati(5, 5);
}
//C Copia i dati
if (
keyState.IsKeyDown(Keys.C))
{
//copia il file
storageDevice = null;
object stato = (Object)"Copia file per giocatore 1";
StorageDevice.BeginShowSelector(playerIndex, this.CopiaFile, stato);
}
//R Rinomina
if (
keyState.IsKeyDown(Keys.R))
{
//copia il file
storageDevice = null;
object stato = (Object)"Rinomina file per giocatore 1";
StorageDevice.BeginShowSelector(playerIndex, this.Rinomina, stato);
}
//I Informazioni
if (
keyState.IsKeyDown(Keys.I))
{
//copia il file
storageDevice = null;
object stato = (Object)"Informazioni Storage";
StorageDevice.BeginShowSelector(playerIndex, this.InfoStorage, stato);
}
//Ottiene Info cartelle e file
if (
keyState.IsKeyDown(Keys.O))
{
//copia il file
storageDevice = null;
object stato = (Object)"Ottieni cartelle e file Storage";
StorageDevice.BeginShowSelector(playerIndex, this.OttieniCartelleFile, stato);
}
//Elimina il file
if (
keyState.IsKeyDown(Keys.E))
{
//copia il file
storageDevice = null;
object stato = (Object)"Elimina file";
StorageDevice.BeginShowSelector(playerIndex, this.EliminaFile, stato);
}
//B carica i dati
if (padState.Buttons.B == ButtonState.Pressed ||
keyState.IsKeyDown(Keys.B))
{
//apre il file
storageDevice = null;
object stato = (Object)"Carica Dati";
StorageDevice.BeginShowSelector(playerIndex, this.caricaDati, stato);
}
// TODO: Add your update logic here
base.Update(gameTime);
}
private void SalvaDati(int punteggio, int livello)
{
//inizializzo l'oggetto per la gestione dello storage in questo modo possiamo gestire la sincronizzazione
storageDevice = StorageDevice.EndShowSelector(asyncResult);
//salvo i dati
SalvataggioDati = new InfoGioco();
SalvataggioDati.punteggio = punteggio;
SalvataggioDati.livello = livello;
AperturaDati = null;
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
// attende l'esecuzione
asyncResult.AsyncWaitHandle.WaitOne();
storageContainer = storageDevice.EndOpenContainer(asyncResult);
//chiudo la sincronizzazione
asyncResult.AsyncWaitHandle.Close();
try
{
//se il file esiste lo cancello
if (storageContainer.FileExists(filename))
{
storageContainer.DeleteFile(filename);
}
//salvo il file nuovo
using (Stream stream = storageContainer.CreateFile(filename))
{
XmlSerializer serializer = new XmlSerializer(
typeof(InfoGioco));
serializer.Serialize(stream, SalvataggioDati);
//libero la memoria
stream.Close();
}
}
catch (IOException e)
{
//errore
Debug.WriteLine(e.Message);
}
finally
{
//libero la memoria
storageContainer.Dispose();
}
}
private void caricaDati(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
// attende l'esecuzione
result.AsyncWaitHandle.WaitOne();
storageContainer = storageDevice.EndOpenContainer(asyncResult);
//chiudo la sincronizzazione
asyncResult.AsyncWaitHandle.Close();
//se il file non esiste, esco e libero la memoria
if (!storageContainer.FileExists(filename))
{
//libero la memoria
storageContainer.Dispose();
return;
}
// Apro il file e serializzo
using (Stream stream = storageContainer.OpenFile(filename, FileMode.Open, FileAccess.Read))
{
XmlSerializer serializer = new XmlSerializer(typeof(InfoGioco));
AperturaDati = (InfoGioco)serializer.Deserialize(stream);
}
//libero la memoria
storageContainer.Dispose();
storageContainer = null;
Debug.WriteLine("Livello: " + AperturaDati.livello.ToString());
Debug.WriteLine("Score: " + AperturaDati.punteggio.ToString());
}
private void CopiaFile(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attende l'esecuzione
result.AsyncWaitHandle.WaitOne();
storageContainer = storageDevice.EndOpenContainer(asyncResult);
// chiudo la sincronizzazione
asyncResult.AsyncWaitHandle.Close();
string FileNuovo = "Dati2.dat";
//Verifico che il file esiste
if (storageContainer.FileExists(filename) && !storageContainer.FileExists(FileNuovo))
{
using (Stream stream = storageContainer.OpenFile(filename, FileMode.Open, FileAccess.Read))
{
Stream fileCopiato = storageContainer.CreateFile(FileNuovo);
stream.CopyTo(fileCopiato);
fileCopiato.Close();
fileCopiato.Dispose();
}
}
//libero la memoria
storageContainer.Dispose();
}
private void Rinomina(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
string FileRinominato = "CopiaDiDati.dat";
//Verifico che il file esiste
if (storageContainer.FileExists(filename) && !storageContainer.FileExists(FileRinominato))
{
using (Stream stream = storageContainer.OpenFile(filename, FileMode.Open, FileAccess.Read))
{
Stream streamfileRinominato = storageContainer.CreateFile(FileRinominato);
stream.CopyTo(streamfileRinominato);
streamfileRinominato.Close();
streamfileRinominato.Dispose();
//Cancello il file
//storageContainer.DeleteFile(filename);
}
}
//libero la memoria
storageContainer.Dispose();
}
private void InfoStorage(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
//nuova cartella
storageContainer.CreateDirectory("NuovaCartella");
//spazio libero sul pc
long spaziolibero = storageContainer.StorageDevice.FreeSpace / 1000000000;
long CapienzaMassima = storageContainer.StorageDevice.TotalSpace / 1000000000;
//libero la memoria
storageContainer.Dispose();
}
private void OttieniCartelleFile(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
string[] listaFiles = storageContainer.GetFileNames();
string[] listaCartelle = storageContainer.GetDirectoryNames();
foreach (string file in listaFiles)
{
Debug.WriteLine("File: " + file);
}
foreach (string cartella in listaCartelle)
{
Debug.WriteLine("Cartella: " + cartella);
}
//libero la memoria
storageContainer.Dispose();
}
private void EliminaFile(IAsyncResult result)
{
storageDevice = StorageDevice.EndShowSelector(result);
//nome della cartella dello storage
asyncResult = storageDevice.BeginOpenContainer("StorageDemo", null, null);
//attesa sincronizzazione
result.AsyncWaitHandle.WaitOne();
//ottengo l'oggetto storageContainer, per la gestione del file
storageContainer = storageDevice.EndOpenContainer(asyncResult);
asyncResult.AsyncWaitHandle.Close();
string FileDaEliminare = "CopiaDiDati.dat";
if (storageContainer.FileExists(FileDaEliminare))
{
storageContainer.DeleteFile(FileDaEliminare);
}
//libero la memoria
storageContainer.Dispose();
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
// TODO: Add your drawing code here
base.Draw(gameTime);
}
}
}
Conclusioni
L'articolo ha illustrata varie tecniche per l’utilizzo dello storage, abbiamo visto i vari metodi e proprietà messi a disposizione della classe StorageDevice,e storageContainer che permettono di gestire le informazioni salvate in un apposito spazio del nostro computer. Classi che possono tornare utile, nel salvaggio dei dati.