Esercitazione: Creare una classifica cache-aside in ASP.NET

Articolo
06/01/2023

In questa esercitazione si aggiorna ContosoTeamStats ASP.NET'app Web---creata nella guida introduttiva ASP.NET per cache di Azure per Redis---per includere un tabellone punteggi che usa il modello cache-aside con cache di Azure per Redis. L'applicazione di esempio visualizza un elenco di statistiche del team da un database. Illustra anche diversi modi per usare cache di Azure per Redis per archiviare e recuperare dati dalla cache per migliorare le prestazioni. Al termine dell'esercitazione, si dispone di un'app Web in esecuzione che legge e scrive in un database, ottimizzata con cache di Azure per Redis e ospitata in Azure.

In questa esercitazione apprenderai a:

Aumentare la velocità effettiva dei dati e ridurre il carico del database archiviando e recuperando i dati con Cache Redis di Azure.
Usare un set ordinato Redis per recuperare i primi cinque team.
Effettuare il provisioning delle risorse di Azure per l'applicazione usando un modello di Resource Manager.
Pubblicare l'applicazione in Azure usando Visual Studio.

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Prerequisiti

Per completare questa esercitazione, sono previsti i prerequisiti seguenti:

Questa esercitazione prosegue da dove era terminata la guida introduttiva di ASP.NET per Cache Redis di Azure. Se non si è ancora provveduto, seguire prima tale guida introduttiva.
Installare Visual Studio 2019 con i carichi di lavoro seguenti:
- Sviluppo ASP.NET e Web
- Sviluppo di Azure
- Sviluppo desktop .NET con SQL Server Express Local DB o SQL Server 2017 Express edition.

Aggiungere un classifica al progetto

In questa sezione dell'esercitazione viene configurato il progetto ContosoTeamStats con un classifica che segnala le statistiche di vittorie, sconfitte e pareggi per un elenco di team fittizi.

Aggiungere Entity Framework al progetto

In Visual Studio aprire la soluzione ContosoTeamStats creata nella guida introduttiva di ASP.NET per Cache Redis di Azure.
Selezionare Strumenti > NuGet Gestione pacchetti > console Gestione pacchetti.
Nella finestra Console di Gestione pacchetti eseguire il comando seguente per installare EntityFramework:
```
Install-Package EntityFramework
```

Per altre informazioni sul pacchetto, vedere la pagina NuGet relativa a Entity Framework.

Aggiungere il modello di team

In Esplora soluzioni fare clic con il pulsante destro del mouse su Modelli, quindi scegliere Aggiungi, Classe.
Immettere Team per il nome della classe e selezionare Aggiungi.

Sostituire le istruzioni using all'inizio del file Team.cs con le istruzioni using seguenti:

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Data.Entity.SqlServer;

Sostituire la definizione della Team classe con il frammento di codice seguente che contiene una definizione di classe aggiornata Team e altre classi helper di Entity Framework. Questa esercitazione usa il primo approccio al codice con Entity Framework. Questo approccio consente a Entity Framework di creare il database dal codice. Per altre informazioni sull'approccio Code First per Entity Framework usato in questa esercitazione, vedere Code First per un nuovo database.

public class Team
{
    public int ID { get; set; }
    public string Name { get; set; }
    public int Wins { get; set; }
    public int Losses { get; set; }
    public int Ties { get; set; }

    static public void PlayGames(IEnumerable<Team> teams)
    {
        // Simple random generation of statistics.
        Random r = new Random();

        foreach (var t in teams)
        {
            t.Wins = r.Next(33);
            t.Losses = r.Next(33);
            t.Ties = r.Next(0, 5);
        }
    }
}

public class TeamContext : DbContext
{
    public TeamContext()
        : base("TeamContext")
    {
    }

    public DbSet<Team> Teams { get; set; }
}

public class TeamInitializer : CreateDatabaseIfNotExists<TeamContext>
{
    protected override void Seed(TeamContext context)
    {
        var teams = new List<Team>
        {
            new Team{Name="Adventure Works Cycles"},
            new Team{Name="Alpine Ski House"},
            new Team{Name="Blue Yonder Airlines"},
            new Team{Name="Coho Vineyard"},
            new Team{Name="Contoso, Ltd."},
            new Team{Name="Fabrikam, Inc."},
            new Team{Name="Lucerne Publishing"},
            new Team{Name="Northwind Traders"},
            new Team{Name="Consolidated Messenger"},
            new Team{Name="Fourth Coffee"},
            new Team{Name="Graphic Design Institute"},
            new Team{Name="Nod Publishers"}
        };

        Team.PlayGames(teams);

        teams.ForEach(t => context.Teams.Add(t));
        context.SaveChanges();
    }
}

public class TeamConfiguration : DbConfiguration
{
    public TeamConfiguration()
    {
        SetExecutionStrategy("System.Data.SqlClient", () => new SqlAzureExecutionStrategy());
    }
}

In Esplora soluzioni fare doppio clic su Web.config per aprirlo.

Aggiungere la sezione connectionStrings seguente all'interno della sezione configuration. Il nome della stringa di connessione deve corrispondere al nome della classe di contesto del database Entity Framework, ovvero TeamContext.

Questa stringa di connessione presuppone che siano stati soddisfatti i prerequisiti e che SQL Server Express Local DB che fa parte del carico di lavoro sviluppo di desktop .NET installato con Visual Studio 2019.

<connectionStrings>
    <add name="TeamContext" connectionString="Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\Teams.mdf;Integrated Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>

L'esempio seguente mostra la nuova sezione connectionStrings che segue configSections all'interno della sezione configuration:

<configuration>
    <configSections>
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
    </configSections>
    <connectionStrings>
    <add name="TeamContext" connectionString="Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=|DataDirectory|\Teams.mdf;Integrated Security=True"     providerName="System.Data.SqlClient" />
    </connectionStrings>
    ...

Aggiungere TeamsController e visualizzazioni

Compilare il progetto in Visual Studio.
In Esplora soluzioni fare clic con il pulsante destro del mouse sulla cartella Controller, quindi scegliere Aggiungi, Controller.
Scegliere Controller MVC 5 con visualizzazioni, usando Entity Framework e selezionare Aggiungi. Se viene visualizzato un errore dopo aver selezionato Aggiungi, assicurarsi di aver compilato prima il progetto.
Selezionare Team (ContosoTeamStats.Models) dall'elenco a discesa Classe modello. Selezionare TeamContext (ContosoTeamStats.Models) dall'elenco a discesa Classe del contesto dei dati. Digitare TeamsController nella casella di testo Nome controller (se non viene popolata automaticamente). Selezionare Aggiungi per creare la classe controller e aggiungere le visualizzazioni predefinite.
In Esplora soluzioni espandere Global.asax e fare doppio clic su Global.asax.cs per aprirlo.
Aggiungere le due istruzioni using seguenti all'inizio del file, dopo le altre due istruzioni using:
```
using System.Data.Entity;
using ContosoTeamStats.Models;
```
Aggiungere la seguente riga di codice alla fine del metodo Application_Start :
```
Database.SetInitializer<TeamContext>(new TeamInitializer());
```
In Esplora soluzioni espandere App_Start e fare doppio clic su RouteConfig.cs.

Nel metodo RegisterRoutes sostituire controller = "Home" nella route Default con controller = "Teams", come mostrato nell'esempio seguente:

routes.MapRoute(
    name: "Default",
    url: "{controller}/{action}/{id}",
    defaults: new { controller = "Teams", action = "Index", id = UrlParameter.Optional }
);

Configurare la visualizzazione Layout

In Esplora soluzioni espandere la cartella Visualizzazioni, quindi la cartella Condiviso e infine fare doppio clic su _Layout.cshtml.
Cambiare il contenuto dell'elemento title e sostituire My ASP.NET Application con Contoso Team Stats, come illustrato nell'esempio seguente:
```
<title>@ViewBag.Title - Contoso Team Stats</title>
```
Nella sezione body aggiungere la nuova istruzione Html.ActionLink seguente per Contoso Team Stats appena sotto al collegamento per il test di Cache Redis di Azure.
```
@Html.ActionLink("Contoso Team Stats", "Index", "Teams", new { area = "" }, new { @class = "navbar-brand" })`
```
Premere CTRL+F5 per compilare ed eseguire l'applicazione. Questa versione dell'applicazione legge i risultati direttamente dal database. Si notino le azioni Crea nuovo, Modifica, Dettagli ed Elimina aggiunte automaticamente all'applicazione dallo scaffolding Controller MVC 5 con visualizzazioni, che usa Entity Framework. Nella sezione successiva dell'esercitazione si aggiungeranno cache di Azure per Redis per ottimizzare l'accesso ai dati e fornire altre funzionalità all'applicazione.

Configurare l'app per Cache Redis di Azure

In questa sezione dell'esercitazione viene configurata l'applicazione di esempio per archiviare e recuperare le statistiche del team Contoso da un'istanza di Cache Redis di Azure usando il client StackExchange.Redis della cache.

Aggiungere una connessione della cache a TeamsController

L'installazione del pacchetto della libreria client StackExchange.Redis è già stata effettuata nella guida introduttiva. Inoltre è già stata configurata l'impostazione dell'app CacheConnection da usare in locale e con il servizio app pubblicato. Usare la stessa libreria client e le informazioni di CacheConnection in TeamsController.

In Esplora soluzioni espandere la cartella Controller e fare doppio clic su TeamsController.cs per aprirlo.
Aggiungere le due istruzioni using seguenti a TeamsController.cs:
```
using System.Configuration;
using StackExchange.Redis;
```

Aggiungere le due proprietà seguenti alla classe TeamsController:

// Redis Connection string info
private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
{
    string cacheConnection = ConfigurationManager.AppSettings["CacheConnection"].ToString();
    return ConnectionMultiplexer.Connect(cacheConnection);
});

public static ConnectionMultiplexer Connection
{
    get
    {
        return lazyConnection.Value;
    }
}

Aggiornare TeamsController in modo da leggere dalla cache o dal database

In questo esempio è possibile recuperare le statistiche del team dal database o dalla cache. Le statistiche del team vengono archiviate nella cache come elemento List<Team>serializzato e anche come set ordinato usando tipi di dati Redis. Quando si recuperano elementi da un set ordinato, è possibile recuperare alcuni o tutti gli elementi o eseguire query per determinati elementi. In questo esempio si eseguirà una query sul set ordinato per le prime cinque squadre classificate in base al numero di vittorie.

Non è necessario archiviare le statistiche del team in più formati nella cache per usare cache di Azure per Redis. Questa esercitazione usa più formati per illustrare alcuni dei modi diversi e dei tipi di dati diversi che è possibile usare per memorizzare i dati nella cache.

Aggiungere le istruzioni using seguenti nella parte iniziale del file TeamsController.cs, insieme alle altre istruzioni using:
```
using System.Diagnostics;
using Newtonsoft.Json;
```

Sostituire l'implementazione del metodo public ActionResult Index() corrente con l'implementazione seguente:

// GET: Teams
public ActionResult Index(string actionType, string resultType)
{
    List<Team> teams = null;

    switch(actionType)
    {
        case "playGames": // Play a new season of games.
            PlayGames();
            break;

        case "clearCache": // Clear the results from the cache.
            ClearCachedTeams();
            break;

        case "rebuildDB": // Rebuild the database with sample data.
            RebuildDB();
            break;
    }

    // Measure the time it takes to retrieve the results.
    Stopwatch sw = Stopwatch.StartNew();

    switch(resultType)
    {
        case "teamsSortedSet": // Retrieve teams from sorted set.
            teams = GetFromSortedSet();
            break;

        case "teamsSortedSetTop5": // Retrieve the top 5 teams from the sorted set.
            teams = GetFromSortedSetTop5();
            break;

        case "teamsList": // Retrieve teams from the cached List<Team>.
            teams = GetFromList();
            break;

        case "fromDB": // Retrieve results from the database.
        default:
            teams = GetFromDB();
            break;
    }

    sw.Stop();
    double ms = sw.ElapsedTicks / (Stopwatch.Frequency / (1000.0));

    // Add the elapsed time of the operation to the ViewBag.msg.
    ViewBag.msg += " MS: " + ms.ToString();

    return View(teams);
}

Aggiungere i tre metodi seguenti alla classe TeamsController per implementare i tipi di azione playGames, clearCache e rebuildDB dall'istruzione switch aggiunta nel frammento di codice precedente.

Il metodo PlayGames aggiorna le statistiche del team simulando una stagione di partite, salva i risultati nel database e cancella i dati ora obsoleti dalla cache.

void PlayGames()
{
    ViewBag.msg += "Updating team statistics. ";
    // Play a "season" of games.
    var teams = from t in db.Teams
                select t;

    Team.PlayGames(teams);

    db.SaveChanges();

    // Clear any cached results
    ClearCachedTeams();
}

Il metodo RebuildDB inizializza di nuovo il database con il set predefinito di team, genera le rispettive statistiche e cancella i dati ora obsoleti dalla cache.

void RebuildDB()
{
    ViewBag.msg += "Rebuilding DB. ";
    // Delete and re-initialize the database with sample data.
    db.Database.Delete();
    db.Database.Initialize(true);

    // Clear any cached results
    ClearCachedTeams();
}

Il metodo ClearCachedTeams rimuove dalla cache eventuali statistiche del team memorizzate.

void ClearCachedTeams()
{
    IDatabase cache = Connection.GetDatabase();
    cache.KeyDelete("teamsList");
    cache.KeyDelete("teamsSortedSet");
    ViewBag.msg += "Team data removed from cache. ";
}

Aggiungere i quattro metodi seguenti alla classe TeamsController per implementare diversi modi di recupero per le statistiche del team dalla cache e dal database. Ognuno di questi metodi restituisce un valore List<Team>, che viene quindi mostrato dalla visualizzazione.

Il metodo GetFromDB legge le statistiche del team dal database.

List<Team> GetFromDB()
{
    ViewBag.msg += "Results read from DB. ";
    var results = from t in db.Teams
        orderby t.Wins descending
        select t;

    return results.ToList<Team>();
}

Il metodo GetFromList legge le statistiche del team dalla cache, come elemento List<Team> serializzato. Se le statistiche non sono presenti nella cache, si verifica un mancato riscontro nella cache. In caso di mancato riscontro nella cache, le statistiche del team vengono lette dal database e quindi archiviate nella cache per la richiesta successiva. In questo esempio viene usata la serializzazione JSON.NET per serializzare gli oggetti .NET da e verso la cache. Per altre informazioni, vedere Come usare gli oggetti .NET in Cache Redis di Azure.

List<Team> GetFromList()
{
    List<Team> teams = null;

    IDatabase cache = Connection.GetDatabase();
    string serializedTeams = cache.StringGet("teamsList");
    if (!String.IsNullOrEmpty(serializedTeams))
    {
        teams = JsonConvert.DeserializeObject<List<Team>>(serializedTeams);

        ViewBag.msg += "List read from cache. ";
    }
    else
    {
        ViewBag.msg += "Teams list cache miss. ";
        // Get from database and store in cache
        teams = GetFromDB();

        ViewBag.msg += "Storing results to cache. ";
        cache.StringSet("teamsList", JsonConvert.SerializeObject(teams));
    }
    return teams;
}

Il metodo GetFromSortedSet legge le statistiche del team da un set ordinato memorizzato nella cache. Se si verifica un mancato riscontro nella cache, le statistiche del team vengono lette dal database e archiviate nella cache come set ordinato.

List<Team> GetFromSortedSet()
{
    List<Team> teams = null;
    IDatabase cache = Connection.GetDatabase();
    // If the key teamsSortedSet is not present, this method returns a 0 length collection.
    var teamsSortedSet = cache.SortedSetRangeByRankWithScores("teamsSortedSet", order: Order.Descending);
    if (teamsSortedSet.Count() > 0)
    {
        ViewBag.msg += "Reading sorted set from cache. ";
        teams = new List<Team>();
        foreach (var t in teamsSortedSet)
        {
            Team tt = JsonConvert.DeserializeObject<Team>(t.Element);
            teams.Add(tt);
        }
    }
    else
    {
        ViewBag.msg += "Teams sorted set cache miss. ";

        // Read from DB
        teams = GetFromDB();

        ViewBag.msg += "Storing results to cache. ";
        foreach (var t in teams)
        {
            Console.WriteLine("Adding to sorted set: {0} - {1}", t.Name, t.Wins);
            cache.SortedSetAdd("teamsSortedSet", JsonConvert.SerializeObject(t), t.Wins);
        }
    }
    return teams;
}

Il metodo GetFromSortedSetTop5 legge i primi cinque team dal set ordinato memorizzato nella cache. Controlla prima di tutto la cache per verificare l'esistenza della chiave teamsSortedSet . Se questa chiave non è presente, viene chiamato il GetFromSortedSet metodo per leggere le statistiche del team e archiviarle nella cache. Il set ordinato memorizzato nella cache viene quindi sottoposto a query alla ricerca dei primi cinque team, che vengono restituiti.

List<Team> GetFromSortedSetTop5()
{
    List<Team> teams = null;
    IDatabase cache = Connection.GetDatabase();

    // If the key teamsSortedSet is not present, this method returns a 0 length collection.
    var teamsSortedSet = cache.SortedSetRangeByRankWithScores("teamsSortedSet", stop: 4, order: Order.Descending);
    if(teamsSortedSet.Count() == 0)
    {
        // Load the entire sorted set into the cache.
        GetFromSortedSet();

        // Retrieve the top 5 teams.
        teamsSortedSet = cache.SortedSetRangeByRankWithScores("teamsSortedSet", stop: 4, order: Order.Descending);
    }

    ViewBag.msg += "Retrieving top 5 teams from cache. ";
    // Get the top 5 teams from the sorted set
    teams = new List<Team>();
    foreach (var team in teamsSortedSet)
    {
        teams.Add(JsonConvert.DeserializeObject<Team>(team.Element));
    }
    return teams;
}

Aggiornare i metodi Create, Edit e Delete per l'interazione con la cache

Il codice di scaffolding generato come parte di questo esempio include metodi per l'aggiunta, la modifica e l'eliminazione di elementi. Quando un team viene aggiunto, modificato o rimosso, i dati nella cache diventano obsoleti. In questa sezione verranno modificati questi tre metodi per cancellare i team memorizzati nella cache, in modo che la cache venga aggiornata.

Passare al metodo Create(Team team) nella classe TeamsController. Aggiungere una chiamata al metodo ClearCachedTeams, come illustrato nell'esempio seguente:

// POST: Teams/Create
// To protect from overposting attacks, please enable the specific properties you want to bind to, for 
// more details see https://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Create([Bind(Include = "ID,Name,Wins,Losses,Ties")] Team team)
{
    if (ModelState.IsValid)
    {
        db.Teams.Add(team);
        db.SaveChanges();
        // When a team is added, the cache is out of date.
        // Clear the cached teams.
        ClearCachedTeams();
        return RedirectToAction("Index");
    }

    return View(team);
}

Passare al metodo Edit(Team team) nella classe TeamsController. Aggiungere una chiamata al metodo ClearCachedTeams, come illustrato nell'esempio seguente:

// POST: Teams/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for 
// more details see https://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Edit([Bind(Include = "ID,Name,Wins,Losses,Ties")] Team team)
{
    if (ModelState.IsValid)
    {
        db.Entry(team).State = EntityState.Modified;
        db.SaveChanges();
        // When a team is edited, the cache is out of date.
        // Clear the cached teams.
        ClearCachedTeams();
        return RedirectToAction("Index");
    }
    return View(team);
}

Passare al metodo DeleteConfirmed(int id) nella classe TeamsController. Aggiungere una chiamata al metodo ClearCachedTeams, come illustrato nell'esempio seguente:

// POST: Teams/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public ActionResult DeleteConfirmed(int id)
{
    Team team = db.Teams.Find(id);
    db.Teams.Remove(team);
    db.SaveChanges();
    // When a team is deleted, the cache is out of date.
    // Clear the cached teams.
    ClearCachedTeams();
    return RedirectToAction("Index");
}

Aggiungere metodi di memorizzazione nella cache per la visualizzazione dell'indice dei team

In Esplora soluzioni espandere la cartella Visualizzazioni, quindi la cartella Team e fare doppio clic su Index.cshtml.

Cercare l'elemento paragrafo seguente nella parte superiore del file:

Action table

Questo collegamento crea un nuovo team. Sostituire l'elemento paragrafo con la tabella seguente. Questa tabella include collegamenti alle azioni per la creazione di un nuovo team, l'avvio di una nuova stagione di partite, la cancellazione della cache, il recupero dei team dalla cache in diversi formati, il recupero di team dal database e la ricompilazione del database con dati di esempio aggiornati.

<table class="table">
    <tr>
        <td>
            @Html.ActionLink("Create New", "Create")
        </td>
        <td>
            @Html.ActionLink("Play Season", "Index", new { actionType = "playGames" })
        </td>
        <td>
            @Html.ActionLink("Clear Cache", "Index", new { actionType = "clearCache" })
        </td>
        <td>
            @Html.ActionLink("List from Cache", "Index", new { resultType = "teamsList" })
        </td>
        <td>
            @Html.ActionLink("Sorted Set from Cache", "Index", new { resultType = "teamsSortedSet" })
        </td>
        <td>
            @Html.ActionLink("Top 5 Teams from Cache", "Index", new { resultType = "teamsSortedSetTop5" })
        </td>
        <td>
            @Html.ActionLink("Load from DB", "Index", new { resultType = "fromDB" })
        </td>
        <td>
            @Html.ActionLink("Rebuild DB", "Index", new { actionType = "rebuildDB" })
        </td>
    </tr>
</table>

Scorrere fino alla fine del file Index.cshtml e aggiungere l'elemento seguente tr in modo che sia l'ultima riga dell'ultima tabella nel file:
```
<tr><td colspan="5">@ViewBag.Msg</td></tr>
```
In questa riga viene visualizzato il valore di ViewBag.Msg, che contiene un report sullo stato relativo all'operazione corrente. l'oggetto ViewBag.Msg viene impostato quando si seleziona uno dei collegamenti all'azione del passaggio precedente.
Premere F6 per compilare il progetto.

Eseguire l'app in locale

Eseguire l'applicazione in locale nel computer in uso per verificare la funzionalità che è stata aggiunta per supportare i team.

In questo test sia l'applicazione che il database vengono eseguiti in locale. Il cache di Azure per Redis non è locale. È ospitato in modalità remota in Azure. Per questo motivo, è probabile che la cache esegua leggermente il database. Per prestazioni ottimali, l'applicazione client e l'istanza di Cache Redis di Azure devono trovarsi nella stessa posizione.

Nella sezione successiva si distribuiscono tutte le risorse in Azure per visualizzare le prestazioni migliorate rispetto all'uso di una cache.

Per eseguire l'app in locale:

Premere CTRL+F5 per eseguire l'applicazione.
Testare ognuno dei nuovi metodi aggiunti alla visualizzazione. Dal momento che la cache è remota in questi test, le prestazioni del database dovrebbero essere leggermente superiori a quelle della cache.

Pubblicare ed eseguire l'app in Azure

Effettuare il provisioning di un database per l'app

In questa sezione si effettuerà il provisioning di un nuovo database nel database SQL che l'app userà mentre è ospitata in Azure.

Nella portale di Azure selezionare Crea una risorsa nell'angolo superiore sinistro del portale di Azure.
Nella pagina Nuovo selezionare Database>Database SQL.

Usare le impostazioni seguenti per il nuovo database SQL:

Impostazione	Valore suggerito	Descrizione
Nome database	ContosoTeamsDatabase	Per i nomi di database validi, vedere Identificatori del database.
Abbonamento	Sottoscrizione in uso	Selezionare la stessa sottoscrizione che è stata usata per creare la cache e ospitare il servizio app.
Gruppo di risorse	TestResourceGroup	Selezionare Usa esistente e usare lo stesso gruppo di risorse in cui è stata inserita la cache e servizio app.
Seleziona origine	Database vuoto	Iniziare con un database vuoto.

In Server selezionare Configura le impostazioni>necessarie Crea un nuovo server e specificare le informazioni seguenti e quindi usare il pulsante Seleziona :

Impostazione	Valore suggerito	Descrizione
Nome server	Qualsiasi nome globalmente univoco	Per i nomi di server validi, vedere Regole di denominazione e restrizioni.
Accesso amministratore server	Qualsiasi nome valido	Per i nomi di accesso validi, vedere Identificatori del database.
Password	Qualsiasi password valida	La password deve almeno 8 caratteri e contenere caratteri inclusi in tre delle categorie seguenti: caratteri maiuscoli, caratteri minuscoli, numeri e caratteri non alfanumerici.
Location	Stati Uniti orientali	Selezionare la stessa area geografica in cui sono stati creati la cache e il servizio app.

Selezionare Aggiungi al dashboard e quindi Crea per creare il nuovo database e il nuovo server.
Dopo aver creato il nuovo database, selezionare Mostra stringa di connessione database e copiare il stringa di connessione ADO.NET.
Nella portale di Azure passare al servizio app e selezionare Application Impostazioni (Applicazione) e quindi Add new stringa di connessione (Aggiungi nuovo stringa di connessione) nella sezione stringhe di Connessione ion.
Aggiungere una nuova stringa di connessione denominata TeamContext corrispondente alla classe di contesto del database Entity Framework. Incollare la stringa di connessione per il nuovo database come valore. Assicurarsi di sostituire i segnaposto seguenti nel stringa di connessione e selezionare Salva:

Segnaposto Valore suggerito

{your_username} Usare l'accesso di amministratore server per il server appena creato.

{your_password} Usare la password per il server appena creato.

Aggiungendo il nome utente e la password come impostazione dell'applicazione, il nome utente e la password non sono inclusi nel codice. Questo approccio consente di proteggere tali credenziali.

Segnaposto	Valore suggerito
{your_username}	Usare l'accesso di amministratore server per il server appena creato.
{your_password}	Usare la password per il server appena creato.

Pubblicare gli aggiornamenti dell'applicazione in Azure

In questo passaggio dell'esercitazione l'applicazione verrà aggiornata in Azure per essere eseguita nel cloud.

Selezionare il progetto ContosoTeamStats in Visual Studio e scegliere Pubblica.
Selezionare Pubblica per usare lo stesso profilo di pubblicazione creato nella guida introduttiva.

Dopo che la pubblicazione è stata completata, Visual Studio avvia l'app nel Web browser predefinito.

Cache added

La tabella seguente illustra ogni collegamento all'azione dall'applicazione di esempio:

Azione	Descrizione
Crea nuovo	Crea un nuovo team.
Play Season	Avvia una stagione di partite, aggiorna le statistiche del team e cancella eventuali dati del team obsoleti dalla cache.
Clear Cache	Cancella le statistiche del team dalla cache.
List from Cache	Recupera le statistiche del team dalla cache. Se si verifica un mancato riscontro nella cache, caricare le statistiche dal database e salvarle nella cache per la prossima volta.
Sorted Set from Cache	Recupera le statistiche del team dalla cache usando un set ordinato. Se si verifica un mancato riscontro nella cache, caricare le statistiche dal database e salvarle nella cache usando un set ordinato.
Top 5 Teams from Cache	Recupera i primi cinque team dalla cache usando un set ordinato. Se si verifica un mancato riscontro nella cache, caricare le statistiche dal database e salvarle nella cache usando un set ordinato.
Load from DB	Recupera le statistiche del team dal database.
Rebuild DB	Ricompila il database e lo ricarica con i dati del team di esempio.
Edit / Details / Delete	Modifica un team, visualizza dettagli per un team, elimina un team.

Selezionare alcune delle azioni e provare a recuperare i dati dalle diverse origini. Si notino le differenze a livello di tempo necessario per il completamento nelle varie modalità di recupero di dati dal database e dalla cache.

Pulire le risorse

Al termine dell'applicazione di esercitazione di esempio, è possibile eliminare le risorse di Azure per risparmiare costi e risorse. Tutte le risorse devono essere contenute nello stesso gruppo di risorse. È possibile eliminarli insieme in un'unica operazione eliminando il gruppo di risorse. Le istruzioni in questo articolo usano un gruppo di risorse denominato TestResources.

Importante

L'eliminazione di un gruppo di risorse è irreversibile e comporta l'eliminazione definitiva del gruppo di risorse e di tutte le risorse incluse nel gruppo. Assicurarsi di non eliminare accidentalmente il gruppo di risorse sbagliato o le risorse errate. Se sono state create le risorse per l'hosting di questo esempio all'interno di un gruppo di risorse esistente, che contiene le risorse da conservare, è possibile eliminare ogni risorsa singolarmente a sinistra.

Accedere al portale di Azure e selezionare Gruppi di risorse.
Immettere il nome del gruppo di risorse nella casella di testo Filtra elementi .
Selezionare ... a destra del gruppo di risorse e selezionare Elimina gruppo di risorse.
Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Digitare il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Passaggi successivi

Come ridimensionare Cache Redis di Azure

Condividi tramite