Självstudiekurs: Skapa en cache-aside-resultattavla för ASP.NET

I den här självstudien uppdaterar du ContosoTeamStats ASP.NET webbapp---skapad i snabbstarten ASP.NET för Azure Cache for Redis---till att inkludera en topplista som använder cache-aside-mönstret med Azure Cache for Redis. Exempelprogrammet visar en lista över teamstatistik från en databas. Den visar också olika sätt att använda Azure Cache for Redis för att lagra och hämta data från cacheminnet för att förbättra prestandan. När du har slutfört självstudien har du en webbapp som körs som läser och skriver till en databas, optimerad med Azure Cache for Redis och som finns i Azure.

I den här självstudien lär du dig att:

• Förbättra dataflödet och minskar databasbelastningen genom att lagra och hämta data med Azure Cache for Redis.
• Använd en Redis-sorterad uppsättning till att hämta de översta fem teamen.
• Etablera Azure-resurserna för programmet med en Resource Manager-mall.
• Publicera programmet till Azure med Visual Studio.

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

Förutsättningar

För att kunna slutföra den här självstudien behöver du följande:

• Självstudien fortsätter där du slutade i ASP.NET-snabbstarten för Azure Cache for Redis. Följ snabbstarten först, om du inte redan har gjort det.
• Installera Visual Studio 2019 med följande arbetsbelastningar:
  • ASP.NET- och webbutveckling
  • Azure Development
  • .NET Desktop Development med SQL Server Express LocalDB eller SQL Server 2017 Express Edition.

Lägga till en resultattavla i projektet

I det här avsnittet av kursen konfigurerar du ContosoTeamStats-projektet med en resultattavla som rapporterar statistik för vinster, förluster och oavgjort för en lista med fiktiva team.

Lägga till Entity Framework i projektet

1. Öppna i Visual Studio den ContosoTeamStats-lösning som du skapade i ASP.NET-snabbstarten för Azure Cache for Redis.

2. Välj Verktyg > NuGet Package Manager Package Manager-konsolen>.

3. Kör följande kommando via fönstret för Package Manager-konsolen för att installera EntityFramework:

   Install-Package EntityFramework
   

Mer information om det här paketet finns i NuGet-paketet EntityFramework.

Lägga till Team-modellen

1. Högerklicka på Modeller i Solution Explorer och välj Lägg till, Klass.

2. Ange Team som klassnamn och välj Lägg till.

   

3. Ersätt using-satserna överst i filen Team.cs med följande using-satser:

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

4. Ersätt definitionen av Team klassen med följande kodfragment som innehåller en uppdaterad Team klassdefinition och några andra Entity Framework-hjälpklasser. Den här kursen använder kod först-metoden med Entity Framework. Med den här metoden kan Entity Framework skapa databasen utifrån din kod. Mer information om den första kodmetoden för Entity Framework som används i den här självstudien finns i Kod först till en ny databas.

   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());
       }
   }
   

5. I Solution Explorer dubbelklickar du på Web.config för att öppna det.

   

6. Lägg till följande connectionStrings-avsnitt inuti avsnittet configuration. Namnet på anslutningssträngen måste matcha namnet på klassen för Entity Framework-databasens kontext som är TeamContext.

   Den här anslutningssträng förutsätter att du har uppfyllt kraven och installerat SQL Server Express LocalDB som ingår i arbetsbelastningen för .NET-skrivbordsutveckling som installerats med Visual Studio 2019.

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

   I följande exempel visas det nya connectionStrings-avsnittet efter configSections inuti configuration-avsnittet:

   <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>
       ...
   

Lägga till TeamsController och vyer

1. Skapa projektet i Visual Studio.

2. I Solution Explorer högerklickar du på mappen Kontrollanter. Klicka sedan på Lägg till och på Kontrollant.

3. Välj MVC 5-styrenhet med vyer, använd Entity Framework och välj Lägg till. Om du får ett fel när du har valt Lägg till kontrollerar du att du har skapat projektet först.

   

4. Välj Team (ContosoTeamStats.Models) från listrutan Modellklass. Välj TeamContext (ContosoTeamStats.Models) från listrutan Datakontextklass. Skriv TeamsController textrutan Kontrollantnamn (om den inte fylls i automatiskt). Välj Lägg till för att skapa kontrollantklassen och lägg till standardvyerna.

   

5. I Solution Explorer expanderar du Global.asax och dubbelklickar på Global.asax.cs för att öppna den.

   

6. Lägg till följande två using-satser längst upp i filen under de andra using-satserna:

   using System.Data.Entity;
   using ContosoTeamStats.Models;
   

7. Lägg till följande kodrad i slutet av metoden Application_Start:

   Database.SetInitializer<TeamContext>(new TeamInitializer());
   

8. I Solution Explorer expanderar du App_Start och dubbelklickar på RouteConfig.cs.

   

9. I RegisterRoutes-metoden ersätter du controller = "Home" i Default-routningen med controller = "Teams" som visas i följande exempel:

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

Konfigurera vyn Layout

1. I Solution Explorer expanderar du mappen Vyer och sedan mappen Delad. Dubbelklicka på _Layout.cshtml.

   

2. Ändra innehållet i title-elementet och ersätt My ASP.NET Application med Contoso Team Stats enligt följande exempel:

   <title>@ViewBag.Title - Contoso Team Stats</title>
   

3. I avsnittet body lägger du till följande nya Html.ActionLink-uttryck för Contoso Team Stats under länken för Azure Cache for Redis-test.

   @Html.ActionLink("Contoso Team Stats", "Index", "Teams", new { area = "" }, new { @class = "navbar-brand" })`
   

   

4. Tryck på Ctrl+F5 för att skapa och köra programmet. Den här versionen av programmet läser resultaten direkt från databasen. Observera att åtgärderna Skapa nytt, Redigera, Information och Ta bort har lagts till automatiskt till programmet av MVC 5-kontrollanten med vyer, med hjälp av Entity Framework-autogenerering. I nästa avsnitt av självstudien lägger du till Azure Cache for Redis för att optimera dataåtkomsten och tillhandahålla fler funktioner i programmet.

   

Konfigurera appen för Azure Cache for Redis

I det här avsnittet av självstudien konfigurerar du exempelprogrammet till att lagra och hämta Contoso-teamets statistik från en Azure Cache for Redis-instans med hjälp av cacheklienten StackExchange.Redis.

Lägga till en cacheanslutning till Teams Controller

Du har redan installerat StackExchange.Redis-klientbibliotekspaketet i snabbstarten. Du har också redan konfigurerat CacheConnection-appinställningen som ska användas lokalt och med den publicerade apptjänsten. Använd samma klientbibliotek och CacheConnection-information i TeamsController.

1. I Solution Explorer expanderar du mappen Kontrollanter och sedan dubbelklickar du på filen TeamController.cs för att öppna den.

   

2. Lägg till följande två using-satser i TeamsController.cs:

   using System.Configuration;
   using StackExchange.Redis;
   

3. Lägg till följande två egenskaper i klassen 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;
       }
   }
   

Uppdatera TeamsController för att läsa från cachen eller databasen

I det här exemplet kan teamstatistik hämtas från databasen eller från cachen. Teamstatistik lagras i cacheminnet som en serialiserad List<Team> och även som en sorterad uppsättning med Redis-datatyper. När du hämtar objekt från en sorterad uppsättning hämtar du vissa, alla eller frågar efter vissa objekt. I det här exemplet frågar du den sorterade uppsättningen efter de fem bästa lagen som rangordnas efter antal vinster.

Det krävs inte att teamstatistiken lagras i flera format i cacheminnet för att använda Azure Cache for Redis. Den här självstudien använder flera olika format för att visa några av de olika sätt och olika datatyper som du kan använda för att cachelagra data.

1. Lägg till följande två using-satser längst upp i filen TeamsController.cs tillsammans med de andra using-satserna:

   using System.Diagnostics;
   using Newtonsoft.Json;
   

2. Ersätt den befintliga implementeringen av metoden public ActionResult Index() med följande implementering:

   // 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);
   }
   

3. Lägg till följande tre metoder till TeamsController-klassen för att implementera åtgärdstyperna playGames, clearCache och rebuildDB från switch-satsen som lades till i föregående kodfragment.

   PlayGames-metoden uppdaterar teamstatistiken genom att simulera en spelsäsong, spara resultaten i databasen och rensa inaktuella data från cachen.

   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();
   }
   

   RebuildDB-metoden återinitierar databasen med en standarduppsättning av team, genererar statistik för dem och rensar inaktuella data från cachen.

   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();
   }
   

   ClearCachedTeams-metoden tar bort cachelagrad teamstatistik från cachen.

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

4. Lägg till följande fyra metoder till TeamsController-klassen för att implementera olika sätt att hämta teamstatistik från cacheminnet och databasen. Var och en av dessa metoder returnerar en List<Team> som visas i vyn.

   GetFromDB-metoden läser teamstatistiken från databasen.

   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>();
   }
   

   GetFromList-metoden läser teamstatistiken från cachen som en serialiserad List<Team>. Om statistiken inte finns i cacheminnet inträffar en cachemiss. För en cachemiss läses teamstatistiken från databasen och lagras sedan i cacheminnet för nästa begäran. I det här exemplet används JSON.NET-serialisering för att serialisera .NET-objekt till och från cacheminnet. Mer information finns i Så här arbetar du med .NET-objekt i Azure Cache for Redis.

   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;
   }
   

   GetFromSortedSet-metoden läser teamstatistiken från en cachelagrad sorterad uppsättning. Om det finns en cachemiss läss teamstatistiken från databasen och lagras i cacheminnet som en sorterad uppsättning.

   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;
   }
   

   GetFromSortedSetTop5-metoden läser de översta fem teamen från den cachelagrade sorterade uppsättningen. Den startar genom att kontrollera cacheminnet efter förekomsten av teamsSortedSet-nyckeln. Om den här nyckeln inte finns GetFromSortedSet anropas metoden för att läsa teamstatistiken och lagra dem i cacheminnet. Därefter efterfrågas den cachelagrade sorterade uppsättningens översta fem team som returneras.

   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;
   }
   

Uppdatera metoderna Skapa, Redigera och Ta bort till att arbeta med cacheminnet

Den autogenererade kod som skapats som en del av det här exemplet innehåller metoder för att lägga till, redigera och ta bort team. Varje gång ett team läggs till, redigeras eller tas bort, blir data i cacheminnet inaktuell. I det här avsnittet ändrar du dessa tre metoder för att ta bort de cachelagrade teamen så att cachen uppdateras.

1. Bläddra till Create(Team team)-metoden i TeamsController-klassen. Lägg till ett anrop till metoden ClearCachedTeams enligt följande exempel:

   // 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);
   }
   

2. Bläddra till Edit(Team team)-metoden i TeamsController-klassen. Lägg till ett anrop till metoden ClearCachedTeams enligt följande exempel:

   // 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);
   }
   

3. Bläddra till DeleteConfirmed(int id)-metoden i TeamsController-klassen. Lägg till ett anrop till metoden ClearCachedTeams enligt följande exempel:

   // 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");
   }
   

Lägga till cachelagringsmetoder i teamindexvyn

1. I Solution Explorer expanderar du mappen Vyer och sedan mappen Team. Dubbelklicka på Index.cshtml.

   

2. Leta efter följande paragrafelement i den övre delen av filen:

   

   Den här länken skapar ett nytt team. Ersätt paragrafelementet med följande tabell. Den här tabellen innehåller åtgärdslänkar för att skapa ett nytt team, spela en ny spelsäsong, rensa cacheminnet, hämta teamen från cachen i olika format, hämta teamen från databasen och återskapa databasen med ny exempeldata.

   <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>
   

3. Rulla längst ned i filen Index.cshtml och lägg till följande tr element så att det är den sista raden i den sista tabellen i filen:

   <tr><td colspan="5">@ViewBag.Msg</td></tr>
   

   Den här raden visar värdet för ViewBag.Msg, som innehåller en statusrapport om den aktuella åtgärden. ViewBag.Msg Anges när du väljer någon av åtgärdslänkarna från föregående steg.

   

4. Tryck på F6 för att skapa projektet.

Köra appen lokalt

Kör programmet lokalt på din dator för att verifiera funktionerna som har lagts till för att stödja teamen.

I det här testet körs både programmet och databasen lokalt. Azure Cache for Redis är inte lokal. Den finns på distans i Azure. Det är därför cachen sannolikt underpresterar databasen något. För bästa prestanda bör klientprogrammet och Azure Cache for Redis-instansen finnas på samma plats.

I nästa avsnitt distribuerar du alla resurser till Azure för att se den förbättrade prestandan från att använda en cache.

Köra appen lokalt:

1. Tryck på Ctrl+F5 för att köra programmet.

   

2. Testa de nya metoderna som har lagts till i vyn. Eftersom cachen är fjärrbaserad i dessa tester har databasen något högre prestanda än cachen.

Publicera och köra i Azure

Etablera en databas för appen

I det här avsnittet etablerar du en ny databas i SQL Database som appen ska använda när den finns i Azure.

1. I Azure-portalen väljer du Skapa en resurs i det övre vänstra hörnet av Azure-portalen.

2. På sidan Nytt väljer du på Databaser>SQL Database.

3. Använd följande inställningar för den nya SQL-databasen:

   Inställningen	Föreslaget värde	Beskrivning
   Databasnamn	ContosoTeamsDatabase	För giltiga databasnamn, se databasidentifierare.
   Abonnemang	Din prenumeration	Välj samma prenumeration som du använde för att skapa cachen och vara värd för apptjänsten.
   Resursgrupp	TestResourceGroup	Välj Använd befintlig och använd samma resursgrupp där du placerade din cache och App Service.
   Välj källa	Tom databas	Börja med en tom databas.

4. Under Server väljer du Konfigurera nödvändiga inställningar>Skapa en ny server och ange följande information och använd sedan knappen Välj:

   Inställningen	Föreslaget värde	Beskrivning
   Servernamn	Valfritt globalt unikt namn	Giltiga servernamn finns i Namngivningsregler och begränsningar.
   Inloggning för serveradministratör	Valfritt giltigt namn	För giltiga inloggningsnamn, se Databasidentifierare.
   Lösenord	Valfritt giltigt lösenord	Lösenordet måste innehålla minst 8 tecken och måste innehålla tecken från tre av följande kategorier: versaler, gemener, siffror och icke-alfanumeriska tecken.
   Location	USA, östra	Välj samma region där du skapade cachen och apptjänsten.

5. Välj Fäst på instrumentpanelen och sedan Skapa för att skapa den nya databasen och servern.

6. När den nya databasen har skapats väljer du Visa databas anslutningssträng och kopierar ADO.NET anslutningssträng.

   

7. I Azure-portalen går du till Din App Service och väljer Program Inställningar och sedan Lägg till nya anslutningssträng under avsnittet Anslut ionssträngar.

8. Lägg till en ny anslutningssträng med namnet TeamContext så att det matchar Entity Framework-databaskontextklassen. Klistra in anslutningssträngen för den nya databasen som värde. Se till att ersätta följande platshållare i anslutningssträng och välj Spara:

   Platshållare	Föreslaget värde
   {ditt_användarnamn}	Använd serveradministratörsinloggningen för den server som du nyss skapade.
   {ditt_lösenord}	Använd lösenordet för den server som du nyss skapade.

   Genom att lägga till användarnamnet och lösenordet som en programinställning inkluderas inte ditt användarnamn och lösenord i koden. Den här metoden skyddar dessa autentiseringsuppgifter.

Publicera programuppdateringar i Azure

I det här steget i självstudien publicerar du programuppdateringarna i Azure för att köra det i molnet.

1. Högerklicka på ContosoTeamStats-projektet i Visual Studio och välj Publicera.

   

2. Välj Publicera för att använda samma publiceringsprofil som du skapade i snabbstarten.

3. När publiceringen är klar startar Visual Studio appen i standardwebbläsaren.

   

   I följande tabell beskrivs varje åtgärdslänk från exempelprogrammet:

   Åtgärd	Beskrivning
   Skapa Ny	Skapa ett nytt team.
   Spela säsong	Spela en spelsäsong, uppdatera teamstatistiken och avmarkera inaktuell teamdata från cachen.
   Rensa cache	Rensa teamstatistik från cachen.
   Lista från cache	Hämta teamstatistik från cachen. Om det finns en cachemiss läser du in statistiken från databasen och sparar i cacheminnet för nästa gång.
   Sorterad uppsättning från cachen	Hämtar teamstatistiken från cachen med en sorterad uppsättning. Om det finns en cachemiss läser du in statistiken från databasen och sparar i cacheminnet med hjälp av en sorterad uppsättning.
   Översta 5 teamen från cachen	Hämtar de översta fem teamen från cachen med en sorterad uppsättning. Om det finns en cachemiss läser du in statistiken från databasen och sparar i cacheminnet med hjälp av en sorterad uppsättning.
   Läsa in från databas	Hämtar teamstatistiken från databasen.
   Återskapa databas	Återskapa databasen och öppna den igen med exempelteamdata.
   Redigera/Information/Ta bort	Redigera ett team, visa information om ett team, ta bort ett team.

Välj några av åtgärderna och experimentera med att hämta data från de olika källorna. Observera skillnaderna mellan den tid det tar för att slutföra de olika sätten att hämta data från databasen och cachen.

Rensa resurser

När du är klar med exempelprogrammet för självstudier kan du ta bort Azure-resurserna för att spara kostnader och resurser. Alla dina resurser ska finnas i samma resursgrupp. Du kan ta bort dem tillsammans i en åtgärd genom att ta bort resursgruppen. Anvisningarna i den här artikeln använde en resursgrupp med namnet TestResources.

Viktigt!

Det går inte att ångra borttagningen av en resursgrupp och att resursgruppen och alla resurser i den tas bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för att vara värd för det här exemplet i en befintlig resursgrupp, som innehåller resurser som du vill behålla, kan du ta bort varje resurs individuellt till vänster.

1. Logga in på Azure Portal och välj Resursgrupper.

2. Skriv namnet på din resursgrupp i textrutan Filtrera objekt....

3. Välj ... till höger om resursgruppen och välj Ta bort resursgrupp.

   

4. Du blir ombedd att bekräfta borttagningen av resursgruppen. Skriv namnet på resursgruppen för att bekräfta och välj Ta bort.

   Efter en liten stund tas resursgruppen och resurser som finns i den bort.

Nästa steg

Så här skalar du Azure Cache for Redis