Scrivere direttamente nell'archivio

Sostituire il codice in EchoBot.cs con il codice seguente:

using System;
using System.Threading.Tasks;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

// Represents a bot saves and echoes back user input.
public class EchoBot : ActivityHandler
{
   // Create local Memory Storage.
   private static readonly MemoryStorage _myStorage = new MemoryStorage();

   // Create cancellation token (used by Async Write operation).
   public CancellationToken cancellationToken { get; private set; }

   // Class for storing a log of utterances (text of messages) as a list.
   public class UtteranceLog : IStoreItem
   {
      // A list of things that users have said to the bot
      public List<string> UtteranceList { get; } = new List<string>();

      // The number of conversational turns that have occurred
      public int TurnNumber { get; set; } = 0;

      // Create concurrency control where this is used.
      public string ETag { get; set; } = "*";
   }

   // Echo back user input.
   protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
   {
      // preserve user input.
      var utterance = turnContext.Activity.Text;

      // Make empty local log-items list.
      UtteranceLog logItems = null;

      // See if there are previous messages saved in storage.
      try
      {
         string[] utteranceList = { "UtteranceLog" };
         logItems = _myStorage.ReadAsync<UtteranceLog>(utteranceList).Result?.FirstOrDefault().Value;
      }
      catch
      {
         // Inform the user an error occurred.
         await turnContext.SendActivityAsync("Sorry, something went wrong reading your stored messages!");
      }

      // If no stored messages were found, create and store a new entry.
      if (logItems is null)
      {
         // Add the current utterance to a new object.
         logItems = new UtteranceLog();
         logItems.UtteranceList.Add(utterance);

         // Set initial turn counter to 1.
         logItems.TurnNumber++;

         // Show user new user message.
         await turnContext.SendActivityAsync($"{logItems.TurnNumber}: The list is now: {string.Join(", ", logItems.UtteranceList)}");

         // Create dictionary object to hold received user messages.
         var changes = new Dictionary<string, object>();
         {
            changes.Add("UtteranceLog", logItems);
         }
         try
         {
            // Save the user message to your Storage.
            await _myStorage.WriteAsync(changes, cancellationToken);
         }
         catch
         {
            // Inform the user an error occurred.
            await turnContext.SendActivityAsync("Sorry, something went wrong storing your message!");
         }
      }
      // Else, our storage already contained saved user messages, add new one to the list.
      else
      {
         // add new message to list of messages to display.
         logItems.UtteranceList.Add(utterance);
         // increment turn counter.
         logItems.TurnNumber++;

         // show user new list of saved messages.
         await turnContext.SendActivityAsync($"{logItems.TurnNumber}: The list is now: {string.Join(", ", logItems.UtteranceList)}");

         // Create Dictionary object to hold new list of messages.
         var changes = new Dictionary<string, object>();
         {
            changes.Add("UtteranceLog", logItems);
         };

         try
         {
            // Save new list to your Storage.
            await _myStorage.WriteAsync(changes,cancellationToken);
         }
         catch
         {
            // Inform the user an error occurred.
            await turnContext.SendActivityAsync("Sorry, something went wrong storing your message!");
         }
      }
   }
}

Per usare il file di configurazione con estensione env , il bot deve includere un pacchetto aggiuntivo. Se non è già installato, ottenere il pacchetto .NET da npm:

npm install --save dotenv

Modificare il codice in index.js che crea la finestra di dialogo principale. La riga di codice esistente per creare il dialogo principale è const myBot = new EchoBot();, è necessario aggiornarla per abilitare il EchoBot passaggio di un oggetto di archiviazione al costruttore in modo da poter archiviare l'input dell'utente alla memoria interna del bot:

Prima di tutto è necessario aggiungere un riferimento a MemoryStorage in botbuilder:

const { MemoryStorage } = require('botbuilder');

Creare quindi l'oggetto di archiviazione della memoria e passarlo al EchoBot costruttore:

const myStorage = new MemoryStorage();
const myBot = new EchoBot(myStorage);

In questo modo viene passato un MemoryStorage oggetto al EchoBot costruttore . Questa operazione verrà modificata in un secondo momento per passare un oggetto Cosmos DB o archiviazione BLOB.

Sostituire quindi il codice in bot.js con il codice seguente:

const { ActivityHandler, MemoryStorage } = require('botbuilder');
const restify = require('restify');

// Process incoming requests - adds storage for messages.
class EchoBot extends ActivityHandler {
    constructor(myStorage) {
        super();
        this.storage = myStorage;
        // See https://video2.skills-academy.com/azure/bot-service/bot-builder-basics to learn more about the message and other activity types.
        this.onMessage(async turnContext => { console.log('this gets called (message)');
        await turnContext.sendActivity(`You said '${ turnContext.activity.text }'`);
        // Save updated utterance inputs.
        await logMessageText(this.storage, turnContext);
    });
        this.onConversationUpdate(async turnContext => { console.log('this gets called (conversation update)');
        await turnContext.sendActivity('Welcome, enter an item to save to your list.'); });
    }
}

// This function stores new user messages. Creates new utterance log if none exists.
async function logMessageText(storage, turnContext) {
    let utterance = turnContext.activity.text;
    // debugger;
    try {
        // Read from the storage.
        let storeItems = await storage.read(["UtteranceLogJS"])
        // Check the result.
        var UtteranceLogJS = storeItems["UtteranceLogJS"];
        if (typeof (UtteranceLogJS) != 'undefined') {
            // The log exists so we can write to it.
            storeItems["UtteranceLogJS"].turnNumber++;
            storeItems["UtteranceLogJS"].UtteranceList.push(utterance);
            // Gather info for user message.
            var storedString = storeItems.UtteranceLogJS.UtteranceList.toString();
            var numStored = storeItems.UtteranceLogJS.turnNumber;

            try {
                await storage.write(storeItems)
                await turnContext.sendActivity(`${numStored}: The list is now: ${storedString}`);
            } catch (err) {
                await turnContext.sendActivity(`Write failed of UtteranceLogJS: ${err}`);
            }
        }
        else{
            await turnContext.sendActivity(`Creating and saving new utterance log`);
            var turnNumber = 1;
            storeItems["UtteranceLogJS"] = { UtteranceList: [`${utterance}`], "eTag": "*", turnNumber }
            // Gather info for user message.
            var storedString = storeItems.UtteranceLogJS.UtteranceList.toString();
            var numStored = storeItems.UtteranceLogJS.turnNumber;

            try {
                await storage.write(storeItems)
                await turnContext.sendActivity(`${numStored}: The list is now: ${storedString}`);
            } catch (err) {
                await turnContext.sendActivity(`Write failed: ${err}`);
            }
        }
    }
    catch (err){
        await turnContext.sendActivity(`Read rejected. ${err}`);
    }
}

module.exports.EchoBot = EchoBot;

Sostituire il codice in echo_bot.py con il codice seguente:

from botbuilder.core import ActivityHandler, TurnContext, StoreItem, MemoryStorage


class UtteranceLog(StoreItem):
    """
    Class for storing a log of utterances (text of messages) as a list.
    """

    def __init__(self):
        super(UtteranceLog, self).__init__()
        self.utterance_list = []
        self.turn_number = 0
        self.e_tag = "*"


class EchoBot(ActivityHandler):
    """
    Represents a bot saves and echoes back user input.
    """

    def __init__(self):
        self.storage = MemoryStorage()

    async def on_message_activity(self, turn_context: TurnContext):
        utterance = turn_context.activity.text

        # read the state object
        store_items = await self.storage.read(["UtteranceLog"])

        if "UtteranceLog" not in store_items:
            # add the utterance to a new state object.
            utterance_log = UtteranceLog()
            utterance_log.utterance_list.append(utterance)
            utterance_log.turn_number = 1
        else:
            # add new message to list of messages existing state object.
            utterance_log: UtteranceLog = store_items["UtteranceLog"]
            utterance_log.utterance_list.append(utterance)
            utterance_log.turn_number = utterance_log.turn_number + 1

        # Show user list of utterances.
        await turn_context.send_activity(f"{utterance_log.turn_number}: "
                                         f"The list is now: {','.join(utterance_log.utterance_list)}")

        try:
            # Save the user message to your Storage.
            changes = {"UtteranceLog": utterance_log}
            await self.storage.write(changes)
        except Exception as exception:
            # Inform the user an error occurred.
            await turn_context.send_activity("Sorry, something went wrong storing your message!")

Aggiungere le informazioni seguenti al file di configurazione.

appsettings.json

"CosmosDbEndpoint": "<your-CosmosDb-URI>",
"CosmosDbAuthKey": "<your-primary-key>",
"CosmosDbDatabaseId": "<your-database-id>",
"CosmosDbContainerId": "bot-storage"

Aggiungere le informazioni seguenti al file con estensione env .

.env

CosmosDbEndpoint="<your-CosmosDb-URI>"
CosmosDbAuthKey="<your-primary-key>"
CosmosDbDatabaseId="<your-database-id>"
CosmosDbContainerId="bot-storage"

Aggiungere le informazioni seguenti al file di configurazione.

config.py

COSMOS_DB_URI="<your-CosmosDb-URI>"
COSMOS_DB_PRIMARY_KEY="your-primary-key"
COSMOS_DB_DATABASE_ID="<your-database-id>"
COSMOS_DB_CONTAINER_ID="bot-storage"

Installare il pacchetto NuGet Microsoft.Bot.Builder.Azure . Per altre informazioni sull'uso di NuGet, vedere Installare e gestire pacchetti in Visual Studio usando NuGet Gestione pacchetti .

Aggiungere un riferimento a botbuilder-azure usando npm.

npm install --save botbuilder-azure

Se non è già installato, ottenere il pacchetto .NET da npm per accedere alle impostazioni del file con estensione env .

npm install --save dotenv

È possibile aggiungere un riferimento a botbuilder-azure nel progetto tramite pip.

pip install botbuilder-azure

Il codice di esempio seguente viene eseguito usando lo stesso codice bot dell'esempio di archiviazione di memoria fornito in precedenza, con le eccezioni elencate di seguito. I frammenti di codice seguenti mostrano un'implementazione dell'archiviazione di Cosmos DB per "myStorage" che sostituisce l'archiviazione di memoria locale.

È prima necessario aggiornare Startup.cs per fare riferimento alla libreria di Azure di Bot Builder:

using Microsoft.Bot.Builder.Azure;

Successivamente, nel ConfigureServices metodo in Startup.cs, creare l'oggetto CosmosDbPartitionedStorage . Verrà passato al costruttore tramite l'inserimento EchoBot delle dipendenze.

// Use partitioned CosmosDB for storage, instead of in-memory storage.
services.AddSingleton<IStorage>(
    new CosmosDbPartitionedStorage(
        new CosmosDbPartitionedStorageOptions
        {
            CosmosDbEndpoint = Configuration.GetValue<string>("CosmosDbEndpoint"),
            AuthKey = Configuration.GetValue<string>("CosmosDbAuthKey"),
            DatabaseId = Configuration.GetValue<string>("CosmosDbDatabaseId"),
            ContainerId = Configuration.GetValue<string>("CosmosDbContainerId"),
            CompatibilityMode = false,
        }));

In EchoBot.cs modificare la dichiarazione private static readonly MemoryStorage _myStorage = new MemoryStorage(); della _myStorage variabile nel modo seguente:

// variable used to save user input to CosmosDb Storage.
private readonly IStorage _myStorage;

Passare quindi l'oggetto IStorage al EchoBot costruttore:

public EchoBot(IStorage storage)
{
    if (storage is null) throw new ArgumentNullException();
    _myStorage = storage;
}

Aggiungere prima di tutto il codice al file di index.js per consentire di accedere ai valori del file con estensione env immesso in precedenza:

// initialized to access values in .env file.
const ENV_FILE = path.join(__dirname, '.env');
require('dotenv').config({ path: ENV_FILE });

Sarà quindi necessario apportare modifiche a index.js per usare l'archiviazione partizionata di Cosmos DB anziché l'archiviazione interna di Bot Frameworks. Tutte le modifiche al codice in questa sezione vengono apportate in index.js.

Aggiungere prima di tutto un riferimento a botbuilder-azure in index.js. In questo modo sarà possibile accedere alla CosmosDbPartitionedStorage classe .

const { CosmosDbPartitionedStorage } = require('botbuilder-azure');

Creare quindi un nuovo CosmosDbPartitionedStorage oggetto.

const myStorage = new CosmosDbPartitionedStorage({
    cosmosDbEndpoint: process.env.CosmosDbEndpoint,
    authKey: process.env.CosmosDbAuthKey,
    databaseId: process.env.CosmosDbDatabaseId,
    containerId: process.env.CosmosDbContainerId,
    compatibilityMode: false
});

È ora possibile impostare come commento o rimuovere la myStorage dichiarazione const aggiunta in precedenza, poiché l'input dell'utente non viene più salvato nell'archiviazione interna di Bot Frameworks, ma in Cosmos DB:

//const myStorage = new MemoryStorage();
const myBot = new EchoBot(myStorage);

Il codice di esempio seguente viene eseguito usando lo stesso codice bot dell'esempio di archiviazione di memoria fornito in precedenza, con le eccezioni elencate di seguito.

CosmosDbPartitionedConfig Sia CosmosDbPartitionedStorage da botbuilder-azure che sono necessari per creare l'oggetto CosmosDBStorage.

echo_bot.py

from botbuilder.azure import CosmosDbPartitionedStorage, CosmosDbPartitionedConfig

Per accedere alle impostazioni in config.py, si importerà DefaultConfig come illustrato di seguito:

from config import DefaultConfig
CONFIG = DefaultConfig()

Impostare come commento la stringa relativa all'archiviazione in memoria in __init__ e sostituirla con un riferimento a Cosmos DB. Usare l'URI (endpoint), la chiave primaria (chiave di autorizzazione), l'ID del database e l'ID contenitore usati in precedenza.

Rimuovere o impostare come commento il codice di Archiviazione memoria in __init__ e aggiungere quindi un riferimento alle informazioni di Cosmos DB da config.py.

Il frammento di codice seguente mostra un'implementazione di Cosmos DB per 'Storage' che sostituisce l'archiviazione di memoria locale.

echo_bot.py

def __init__(self):
    cosmos_config = CosmosDbPartitionedConfig(
        cosmos_db_endpoint=CONFIG.COSMOS_DB_URI,
        auth_key=CONFIG.COSMOS_DB_PRIMARY_KEY,
        database_id=CONFIG.COSMOS_DB_DATABASE_ID,
        container_id=CONFIG.COSMOS_DB_CONTAINER_ID,
        compatibility_mode = False
    )
    self.storage = CosmosDbPartitionedStorage(cosmos_config)

Aggiungere le informazioni seguenti al file di configurazione.

appsettings.json

"BlobConnectionString": "<your-blob-connection-string>",
"BlobContainerName": "<your-blob-container-name>",

Aggiungere le informazioni seguenti al file con estensione env .

.env

BlobConnectionString="<your-blob-connection-string>"
BlobContainerName="<your-blob-container-name>"

Aggiungere le informazioni seguenti al file di configurazione. Usare lo stesso nome del contenitore e stringa di connessione usati durante la creazione del contenitore di archiviazione BLOB.

config.py

BLOB_CONNECTION_STRING="<your-blob-connection-string>"
BLOB_CONTAINER_NAME="<your-blob-container-name>"

Installare il pacchetto NuGet Microsoft.Bot.Builder.Azure.Blobs . Per altre informazioni sull'uso di NuGet, vedere Installare e gestire pacchetti in Visual Studio usando il Gestione pacchetti NuGet.

Aggiungere riferimenti a botbuilder-azure-blobs nel progetto tramite npm.

npm install --save botbuilder-azure-blobs

Se non è già installato, ottenere il pacchetto .NET da npm per accedere alle impostazioni del file con estensione env .

npm install --save dotenv

è possibile aggiungere un riferimento a botbuilder-azure nel progetto tramite pip.

pip install botbuilder-azure

Il codice di esempio seguente viene eseguito usando lo stesso codice bot dell'esempio di archiviazione di memoria fornito in precedenza, con le eccezioni elencate di seguito.

I frammenti di codice seguenti mostrano un'implementazione dell'archivio BLOB per "myStorage" che sostituisce l'archiviazione di memoria locale.

È prima necessario aggiornare Startup.cs per fare riferimento alla libreria BLOB di Azure di Bot Builder:

Startup.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Successivamente, nel metodo in ConfigureServices Startup.cs creare l'oggetto BlobsStorage passando i valori da appsettings.json. Verrà passato al costruttore tramite l'inserimento EchoBot delle dipendenze.

//Use Azure Blob storage, instead of in-memory storage.
services.AddSingleton<IStorage>(
    new BlobsStorage(
        Configuration.GetValue<string>("BlobConnectionString"),
        Configuration.GetValue<string>("BlobContainerName")
        ));

È prima necessario aggiornare EchoBot.cs per fare riferimento alla libreria BLOB di Azure di Bot Builder:

EchoBot.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Rimuovere o impostare come commento la riga di codice che crea la variabile MemoryStorage 'private static readonly MemoryStorage _myStorage = new MemoryStorage();' e creare una nuova variabile che verrà usata per salvare l'input dell'utente nell'archivio BLOB.

EchoBot.cs

// variable used to save user input to CosmosDb Storage.
private readonly IStorage _myStorage;

Passare quindi l'oggetto IStorage al EchoBot costruttore:

public EchoBot(IStorage storage)
{
    if (storage is null) throw new ArgumentNullException();
    _myStorage = storage;
}

Dopo aver impostato l'archiviazione in modo che punti all'account di archiviazione BLOB, il codice del bot archivierà e recupererà i dati dall'archivio BLOB.

Tutte le modifiche al codice in questa sezione vengono apportate in index.js.

Aggiungere prima di tutto il codice per consentire di accedere ai valori dal file con estensione env immesso in precedenza:

// initialized to access values in .env file.
const ENV_FILE = path.join(__dirname, '.env');
require('dotenv').config({ path: ENV_FILE });

Sarà quindi necessario apportare modifiche usando l'archiviazione BLOB anziché l'archiviazione interna di Bot Framework.

Aggiungere quindi un riferimento a botbuilder-azure-blobs. In questo modo sarà possibile accedere all'API di archiviazione BLOB:

const { BlobsStorage } = require("botbuilder-azure-blobs");

Per modificare il codice per usare la classe , modificare la BlobsStorage myStorage dichiarazione come indicato di seguito:

const myStorage = new BlobsStorage(
    process.env.BlobConnectionString,
    process.env.BlobContainerName
);

Dopo aver impostato l'archiviazione in modo che punti all'account di archiviazione BLOB, il codice del bot archivierà e recupererà i dati dall'archivio BLOB.

Il codice di esempio seguente viene eseguito usando lo stesso codice bot dell'esempio di archiviazione di memoria fornito in precedenza, con le eccezioni elencate di seguito.

Ciò richiederà BlobStorage e BlobStorageSettings da botbuilder-azure.

echo_bot.py

from botbuilder.azure import BlobStorage, BlobStorageSettings

Per accedere alle impostazioni in config.py, si importerà DefaultConfig come illustrato di seguito:

from config import DefaultConfig
CONFIG = DefaultConfig()

Rimuovere o impostare come commento il codice di Archiviazione memoria in __init__ e aggiungere quindi un riferimento alle informazioni sull'archiviazione BLOB da config.py.

Il frammento di codice seguente mostra un'implementazione di Archiviazione BLOB che sostituisce l'archiviazione di memoria locale.

echo_bot.py

def __init__(self):
    blob_settings = BlobStorageSettings(
        connection_string=CONFIG.BLOB_CONNECTION_STRING,
        container_name=CONFIG.BLOB_CONTAINER_NAME
    )
    self.storage = BlobStorage(blob_settings)

In primo luogo, creare una classe che implementi IStoreItem.

EchoBot.cs

public class Note : IStoreItem
{
    public string Name { get; set; }
    public string Contents { get; set; }
    public string ETag { get; set; }
}

Successivamente, creare una nota iniziale mediante la creazione di un oggetto di archiviazione e aggiungere l'oggetto all'archivio.

EchoBot.cs

// create a note for the first time, with a non-null, non-* ETag.
var note = new Note { Name = "Shopping List", Contents = "eggs", ETag = "x" };

var changes = Dictionary<string, object>();
{
    changes.Add("Note", note);
};
await NoteStore.WriteAsync(changes, cancellationToken);

Quindi, accedere e aggiornare la nota in un secondo momento, mantenendo il valore eTag letto dall'archivio.

EchoBot.cs

var note = NoteStore.ReadAsync<Note>("Note").Result?.FirstOrDefault().Value;

if (note != null)
{
    note.Contents += ", bread";
    var changes = new Dictionary<string, object>();
    {
         changes.Add("Note1", note);
    };
    await NoteStore.WriteAsync(changes, cancellationToken);
}

Se la nota è stata aggiornata nell'archivio prima di scrivere le modifiche, la chiamata a Write genera un'eccezione.

Alla fine del bot aggiungere una funzione helper che scriverà una nota di esempio in un archivio dati. Prima di tutto, creare l'oggetto myNoteData.

bot.js

// Helper function for writing a sample note to a data store
async function createSampleNote(storage, context) {
    var myNoteData = {
        name: "Shopping List",
        contents: "eggs",
        // If any Note file is already stored, the eTag field
        // must be set to "*" in order to allow writing without first reading the stored eTag
        // otherwise you'll likely get an exception indicating an eTag conflict.
        eTag: "*"
    }
}

All'interno della createSampleNote funzione helper inizializzare un changes oggetto e aggiungervi le note , quindi scriverlo nella risorsa di archiviazione.

bot.js

// Write the note data to the "Note" key
var changes = {};
changes["Note"] = myNoteData;
// Creates a file named Note, if it doesn't already exist.
// specifying eTag= "*" will overwrite any existing contents.
// The act of writing to the file automatically updates the eTag property
// The first time you write to Note, the eTag is changed from *, and file contents will become:
//    {"name":"Shopping List","contents":"eggs","eTag":"1"}
try {
     await storage.write(changes);
     var list = changes["Note"].contents;
     await context.sendActivity(`Successful created a note: ${list}`);
} catch (err) {
     await context.sendActivity(`Could not create note: ${err}`);
}

Per accedere alla funzione helper dall'interno della logica del bot, è necessario aggiungere la chiamata seguente:

bot.js

// Save a note with etag.
await createSampleNote(storage, turnContext);

Dopo la creazione, per recuperare e aggiornare la nota in un secondo momento, viene quindi creata un'altra funzione helper accessibile quando l'utente digita "update note".

bot.js

async function updateSampleNote(storage, context) {
    try {
        // Read in a note
        var note = await storage.read(["Note"]);
        console.log(`note.eTag=${note["Note"].eTag}\n note=${JSON.stringify(note)}`);
        // update the note that we just read
        note["Note"].contents += ", bread";
        console.log(`Updated note=${JSON.stringify(note)}`);

        try {
             await storage.write(note); // Write the changes back to storage
             var list = note["Note"].contents;
             await context.sendActivity(`Successfully updated note: ${list}`);
        } catch (err) {
             console.log(`Write failed: ${err}`);
        }
    }
    catch (err) {
        await context.sendActivity(`Unable to read the Note: ${err}`);
    }
}

Per accedere a questa funzione helper dall'interno della logica del bot, è necessario aggiungere la chiamata seguente:

bot.js

// Update a note with etag.
await updateSampleNote(storage, turnContext);

Se la nota è stata aggiornata nell'archivio da un altro utente prima che venisse effettuato un tentativo di scrivere le modifiche, il valore eTag non sarà più corrispondente e la chiamata a write genererà un'eccezione.

In primo luogo, creare una classe che implementi StoreItem.

echo_bot.py

class Note(StoreItem):
    def __init__(self, name: str, contents: str, e_tag="*"):
        super(Note, self).__init__()
        self.name = name
        self.contents = contents
        self.e_tag = e_tag

Successivamente, creare una nota iniziale mediante la creazione di un oggetto di archiviazione e aggiungere l'oggetto all'archivio.

echo_bot.py

# create a note for the first time, with a non-null, non-* ETag.
changes = {"Note": Note(name="Shopping List", contents="eggs", e_tag="x")}

await self.storage.write(changes)

Quindi, accedere e aggiornare la nota in un secondo momento, mantenendo il valore eTag letto dall'archivio.

echo_bot.py

store_items = await self.storage.read(["Note"])
    note = store_items["Note"]
    note.contents = note.contents + ", bread"

    changes = {"Note": note}
    await self.storage.write(changes)

Se la nota è stata aggiornata nell'archivio prima di scrivere le modifiche, la chiamata a write genera un'eccezione.