XNA storage la gestione dei dati nello storage

Articolo che illustra la gestione dello storage, come gestire le informazioni nei nostri video giochi.

il
Sviluppatore Microsoft .Net, Collaboratore di IProgrammatori

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.


<?xml version="1.0"?>
<InfoGioco xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <livello>1</livello>
  <punteggio>200</punteggio>
</InfoGioco>


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.