Il mondo NoSql rappresenta al giorno d'oggi una matura tecnologia per la gestione dei dati, che si contrappone, con pro e contro, al modello relazionale. In questo ambito, MongoDB (https://www.mongodb.com/) rappresenta una delle soluzioni più popolari, oltre che gratuita e open source. Inoltre, un assoluto punto a favore è rappresentato dal fatto che il nuovo Azure Cosmos DB (https://docs.microsoft.com/en-us/azure/cosmos-db/introduction) è compatibile con le Mongo API, così che possiamo scrivere la nostra solution basandola su un database Mongo locale e portarla, senza troppi sforzi, sul cloud di Microsoft.

Primi passi

docker run -p 27017:27017 -d mongo

In entrambi i casi, ci ritroveremo a disposizione un'istanza locale di MongoDB, esposta per default sulla porta 27017, che siamo pronti a utilizzare da ASP.NET Core.

Configurazione di ASP.NET Core

Install-Package MongoDB.Driver

Questo package espone un paio di oggetti di cui avremo bisogno a brevissimo, quando inizieremo a interagire con la base dati:

• IMongoClient, che rappresenta un pool di connessioni a un server MongoDB;
• IMongoDatabase, che invece ci consente di accedere a un database.

Come al solito, la best practice è quella di configurarli nel modulo di Startup, all'interno del metodo ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    services.AddSingleton<IMongoClient>(x => new MongoClient(Configuration.GetConnectionString("mongo")));
    services.AddTransient<IMongoDatabase>(x => x.GetService<IMongoClient>().GetDatabase("MyTestDb"));
}

Nell'esempio, IMongoClient è registrato come Singleton e inizializzato passando una connection string che si trova all'interno di appSettings.json:

"ConnectionStrings": {
  "mongo": "mongodb://localhost"
}

Come possiamo notare, per default il server locale di mongo accetta anche connessioni non autenticate. In ogni modo, le credenziali possono essere specificate nella URL di connessione, quindi il codice che abbiamo visto rimane comunque valido.

IMongoDatabase, invece, è un'istanza transient e viene creata tramite il metodo GetDatabase, a cui passsiamo il nome del database che vorremo utilizzare.

Usiamo MongoDB per persistere un oggetto

public class Person
{
    public ObjectId Id { get; set; }

    public string Name { get; set; }

    public string Email { get; set; }
}

L'unico aspetto da segnalare è costituito dalla proprietà Id. MongoDB, come è lecito aspettarsi, necessita che ogni oggetto abbia un Id univoco. Il modo più semplice è quello di sfruttare un oggetto denominato ObjectId, che implementa tutte le logiche di generazione per far sì che non ci siano sovrapposizioni tra due entità. Grazie alle naming convention di default, una proprietà di nome Id verrà immediatamente identificata dal client come identificativo dell'oggetto Person.

Una volta creata la nostra classe, passiamo a gestirla all'interno del controller PeopleController, che accetta un oggetto di tipo IMongoDatabase nel costruttore.

private readonly IMongoDatabase _db;
private readonly IMongoCollection<Person> _people;

public PeopleController(IMongoDatabase db)
{
    _db = db;
    _people = _db.GetCollection<Person>("people");
}

Il metodo GetCollection ci permette di referenziare una collection di Person del database, il cui nome è "people". Possiamo pensare a una collection come all'analogo di una tabella di un database relazionale, con la differenza che, ovviamente, in questo caso i dati sono non strutturati e non devono avere per forza forma tabellare.

Una volta ottenuta questa reference, possiamo recuperare un elenco di Person tramite il metodo FindAsync:

public async Task<IActionResult> Index()
{
    var filter = new BsonDocument();
    var query = await _people.FindAsync(filter);

    return View(await query.ToListAsync());
}

Il parametro filter ci permette di specificare dei filtri di ricerca, ma ne esploreremo le peculiarità in un successivo script.

Per inserire una nuova Person sul database, invece, possiamo sfruttare il metodo InsertOneAsync:

public async Task<IActionResult> Create([Bind("Name,Email")] Person person)
{
    if (ModelState.IsValid)
    {
        person.Id = ObjectId.GenerateNewId();
        await _people.InsertOneAsync(person);

        return RedirectToAction(nameof(Index));
    }

    return View(person);
}

Come possiamo notare, prima di inserire l'oggetto, dobbiamo generare un nuovo identificativo tramite il metodo ObjectId.GenerateNewId.

Conclusione