Oktatóanyag: Gyorsítótár-feltöltési ranglista létrehozása az ASP.NET-en

Ebben az oktatóanyagban frissíti a ContosoTeamStats ASP.NET webalkalmazást--- amely az Azure Cache for Redis ASP.NET rövid útmutatójában van létrehozva--- hogy tartalmazzon egy ranglistát, amely az Azure Cache for Redis gyorsítótár-feltöltési mintáját használja. A mintaalkalmazás megjeleníti az adatbázisból származó csapatstatisztikák listáját. Azt is bemutatja, hogyan használható az Azure Cache for Redis az adatok gyorsítótárból való tárolására és lekérésére a teljesítmény javítása érdekében. Az oktatóanyag elvégzése után egy futó webalkalmazással rendelkezik, amely az Azure Cache for Redis szolgáltatással optimalizált és az Azure-ban üzemeltetett adatbázisba olvas és ír.

Ebben az oktatóanyagban az alábbiakkal fog megismerkedni:

• Az adatok átviteli sebességének javítása és az adatbázis terhelésének csökkentése adatok tárolásával és beolvasásával az Azure Cache for Redis használatával.
• Egy rendezett Redis-készlet használata az öt legjobb csoport lekérdezéséhez.
• Azure-erőforrások kiépítése egy Resource Manager-sablont használó alkalmazás számára.
• Alkalmazás közzététele az Azure-ban a Visual Studio használatával.

If you don't have an Azure subscription, create an Azure free account before you begin.

Előfeltételek

Az oktatóanyag elvégzéséhez az alábbi előfeltételekkel kell rendelkeznie:

• Ez az oktatóanyag az Azure Cache for Redis ASP.NET rövid útmutatójában folytatódik. Ha még nem tette meg, kövesse a rövid útmutató utasításait.
• Telepítse a Visual Studio 2019-et a következő számítási feladatokkal:
  • ASP.NET és webfejlesztés
  • Azure-fejlesztés
  • .NET asztali fejlesztés az SQL Server Express LocalDB vagy az SQL Server 2017 Express kiadásának használatával.

Ranglista hozzáadása a projekthez

Az oktatóanyag ezen szakaszában a ContosoTeamStats projektet fogja konfigurálni egy ranglistával, amely képzeletbeli csapatok győzelmeinek, vereségeinek és döntetlenjeinek statisztikáit tartalmazza.

Az Entity Framework hozzáadása a projekthez

1. Nyissa meg a Visual Studióban az Azure Cache for Redis ASP.NET rövid útmutatójában létrehozott ContosoTeamStats-megoldást.

2. Válassza az Eszközök > NuGet Csomagkezelő > Csomagkezelő konzol lehetőséget.

3. Az EntityFramework telepítéséhez futtassa a következő parancsot a Csomagkezelő konzol ablakából:

   Install-Package EntityFramework
   

A csomaggal kapcsolatos további információt az EntityFramework NuGet-oldalon talál.

A csapatmodell hozzáadása

1. Kattintson a jobb gombbal a Models (Modellek) elemre a Solution Explorer (Megoldáskezelő) területén, és válassza az Add (Hozzáadás), Class (Osztály) lehetőségeket.

2. Adja meg Team az osztály nevét, és válassza a Hozzáadás lehetőséget.

   

3. A Team.cs fájl elején cserélje le a using utasításokat az alábbi using utasításokra:

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

4. Cserélje le az Team osztály definícióját az alábbi kódrészletre, amely egy frissített Team osztálydefiníciót és néhány más Entity Framework-segédosztályt tartalmaz. Az oktatóanyag a Code First nevű Entity Framework-módszert használja. Ezzel a módszerrel az Entity Framework a kódból tudja létrehozni az adatbázist. További információk a jelen oktatóanyagban használt, Code First nevű Entity Framework-megközelítésról: Code First alkalmazása egy új adatbázisra.

   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. A Solution Explorer (Megoldáskezelő) felületén kattintson duplán a Web.config fájlra annak megnyitásához.

   

6. A configuration szakaszon belül adja hozzá a következő connectionStrings szakaszt. A kapcsolati sztring nevének meg kell egyeznie az Entity Framework-adatbáziskörnyezet osztályának nevével, amely a következő: TeamContext.

   Ez a kapcsolati sztring feltételezi, hogy teljesítette az előfeltételeket, és telepítette azt az SQL Server Express LocalDB-t, amely a Visual Studio 2019-ben telepített .NET asztali fejlesztési számítási feladat része.

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

   A következő példa bemutatja az új connectionStrings szakaszt, amely a configSections szakaszt követi a configuration szakaszban:

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

A TeamsController és a nézetek hozzáadása

1. Hozza létre a projektet a Visual Studióban.

2. A Solution Explorerben (Megoldáskezelőben) kattintson a jobb gombbal a Controllers (Vezérlők) mappára, majd válassza az Add (Hozzáadás), Controller (Vezérlő) lehetőségeket.

3. Válassza az MVC 5 Vezérlő nézetekkel, az Entity Framework használatával, majd a Hozzáadás lehetőséget. Ha a Hozzáadás lehetőség kiválasztása után hibaüzenet jelenik meg, győződjön meg arról, hogy először a projektet építette ki.

   

4. Válassza ki a Team (ContosoTeamStats.Models) elemet a Model class (Modellosztály) legördülő listából. Válassza ki a TeamContext (ContosoTeamStats.Models) elemet a Adatkörnyezet osztálya (Adatkörnyezet osztálya) legördülő listából. Írja be TeamsController a Vezérlőnév szövegmezőt (ha nem tölti ki automatikusan). Válassza a Hozzáadás lehetőséget a vezérlőosztály létrehozásához és az alapértelmezett nézetek hozzáadásához.

   

5. A Solution Explorerben (Megoldáskezelőben) bontsa ki a Global.asax elemet, majd kattintson duplán a Global.asax.cs fájlra annak megnyitásához.

   

6. Adja hozzá a következő két using-utasítást a fájl elejéhez, a többi using-utasítás alá:

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

7. Szúrja be az alábbi kódsort az Application_Start metódus végén:

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

8. A Solution Explorerben (Megoldáskezelőben) bontsa ki az App_Start elemet, majd kattintson duplán a RouteConfig.cs elemre.

   

9. A RegisterRoutes metódusban cserélje le a controller = "Home" értéket a Default útvonalban a controller = "Teams" értékre, a következő példában látható módon:

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

Az Elrendezés nézet konfigurálása

1. A Solution Explorerben (Megoldáskezelőben) bontsa ki a Views(Nézetek), majd a Shared (Közös) mappát, és kattintson duplán a _Layout.cshtml fájlra.

   

2. Az alábbi példában látható módon módosítsa a title elem tartalmát, majd cserélje le a My ASP.NET Application szöveget a Contoso Team Stats szövegre:

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

3. body A szakaszban adja hozzá az alábbi új Html.ActionLink utasítást a Contoso csapatstatisztikáihozaz Azure Cache for Redis Test hivatkozása alatt.

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

   

4. Az alkalmazás fordításához és futtatásához nyomja le a Ctrl+F5 billentyűkombinációt. Az alkalmazás ezen verziója az eredményeket közvetlenül az adatbázisból olvassa ki. Figyelje meg, hogy az Új létrehozása, a Szerkesztés, a Részletekés a Törlés parancsok az MVC 5 Controller with views, using Entity Framework (MVC 5 vezérlő nézetekkel, az Entity Framework használatával) szerkezettel automatikusan bekerültek az alkalmazásba. Az oktatóanyag következő szakaszában hozzáadja az Azure Cache for Redist az adathozzáférés optimalizálásához és az alkalmazás további funkcióinak biztosításához.

   

Az Azure Cache for Redis alkalmazásának konfigurálása

Az oktatóanyag jelen szakaszában konfigurálja a mintaalkalmazást a Contoso-csapat statisztikáinak tárolására és lekérésére egy Azure Cache for Redis-példányból a StackExchange.Redis cache-ügyfél használatával.

Gyorsítótár-kapcsolat hozzáadása a Teams Controllerhez

A gyors útmutató során már telepítette a StackExchange.Redis ügyféloldali kódtárcsomagját. Emellett már konfigurálta a CacheConnection alkalmazásbeállítást a helyi, illetve a közzétett App Service-szel való használatra. Használja ugyanazon ügyféloldali kódtár és CacheConnection információit a TeamsControllerben.

1. A Solution Explorerben (Megoldáskezelőben) bontsa ki a Controllers (Vezérlők) mappát, majd kattintson duplán a TeamsController.cs fájlra annak megnyitásához.

   

2. Adja hozzá az alábbi két using-utasítást a TeamsController.cs fájlhoz:

   using System.Configuration;
   using StackExchange.Redis;
   

3. Adja hozzá az alábbi két tulajdonságot a TeamsController osztályhoz:

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

A TeamsController frissítése a gyorsítótárból vagy az adatbázisból történő beolvasáshoz

Jelen példában a csapatstatisztikák az adatbázisból vagy a gyorsítótárból is lekérdezhetők. A csapatstatisztikák a gyorsítótárban szerializált List<Team>, illetve (Redis adattípusok használatával) rendezett készlet formájában vannak tárolva. Rendezett készletből történő lekérdezéskor egyes, az összes vagy bizonyos feltételnek megfelelő elemek lekérésére van lehetőség. Ebben a mintában lekérdezi az első öt csapat rendezési készletét a győzelemek száma alapján rangsorolva.

Az Azure Cache for Redis használatához nem szükséges a csapatstatisztikákat több formátumban tárolni a gyorsítótárban. Ez az oktatóanyag többféle formátumot használ az adatok gyorsítótárazásához használható különböző módszerek és adattípusok példáinak bemutatására.

1. Adja hozzá az alábbi using-utasításokat a TeamsController.cs fájl elejéhez, a többi using-utasítással együtt:

   using System.Diagnostics;
   using Newtonsoft.Json;
   

2. Az aktuális public ActionResult Index() metódusimplementációt cserélje le az alábbi implementációra:

   // 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. Vegye fel az alábbi három módszert a TeamsController osztályba azon playGames, clearCache, és rebuildDB művelettípusok megvalósításához, amelyek az előző kódrészletben hozzáadott „switch” utasításból származnak.

   Egy játékszezon szimulálásával a PlayGames módszer frissíti a csapatstatisztikákat, az eredményeket elmenti az adatbázisba, majd törli a gyorsítótárból a már elavult adatokat.

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

   A RebuildDB módszer újrainicializálja az adatbázist az alapértelmezett csapatokkal, statisztikákat állít elő számukra, és törli a gyorsítótárból a már elavult adatokat.

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

   A ClearCachedTeams módszer eltávolítja a gyorsítótárazott csapatstatisztikákat a gyorsítótárból.

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

4. Vegye fel az alábbi négy módszert a TeamsController osztályba a csapatstatisztikák gyorsítótárból és adatbázisból különböző módszerekkel történő lekérdezéséhez. Mindegyik metódus egy List<Team> választ ad vissza, amely ezután megjelenik a nézetben.

   A GetFromDB módszer beolvassa a csapatstatisztikákat a gyorsítótárból.

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

   A GetFromList módszer szerializált List<Team> formájában olvassa be a csapatstatisztikákat a gyorsítótárból. Ha a statisztikák nem szerepelnek a gyorsítótárban, a gyorsítótár nem jelenik meg. Gyorsítótár-tévesztés esetén a rendszer az adatbázisból olvassa be a statisztikákat, és a gyorsítótárba menti őket a következő kérés számára. Ebben a mintában JSON.NET-szerializálást használunk a .NET-objektumok gyorsítótárba és gyorsítótárból történő szerializálására. További információ: .NET-objektumok használata az Azure Cache for Redisben.

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

   A GetFromSortedSet módszer beolvassa a csapatstatisztikákat egy gyorsítótárazott rendezett készletből. Ha hiányzik a gyorsítótár, a csapat statisztikái beolvashatók az adatbázisból, és rendezett készletként vannak tárolva a gyorsítótárban.

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

   A GetFromSortedSetTop5 metódus beolvassa az öt legjobb csapatot a gyorsítótárazott rendezett készletből. Első lépésben a teamsSortedSet kulcsot keresi meg a gyorsítótárban. Ha ez a kulcs nincs jelen, a metódus a GetFromSortedSet csapat statisztikáinak olvasására és a gyorsítótárban való tárolására lesz meghívva. Ezt a gyorsítótárazott rendezett készlet lekérdezése követi, amely az öt legjobb csapatot adja vissza.

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

A Létrehozás, Szerkesztés és Törlés módszerek frissítése a gyorsítótárral való együttműködéshez

A szerkezeti kódot a rendszer ezen minta részeként állítja elő a csapatok hozzáadásához, szerkesztéséhez és törléséhez. Egy csapat hozzáadását, szerkesztését vagy eltávolítását követően a gyorsítótárban található adatok elavulttá válnak. Ebben a szakaszban ezt a három metódust fogja módosítani a gyorsítótárazott csapatok törlése érdekében, hogy a gyorsítótár frissüljön.

1. Keresse meg a Create(Team team) módszert a TeamsController osztályban. Adja hozzá a ClearCachedTeams metódus hívását, ahogy az az alábbi példában is látható:

   // 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. Keresse meg a Edit(Team team) módszert a TeamsController osztályban. Adja hozzá a ClearCachedTeams metódus hívását, ahogy az az alábbi példában is látható:

   // 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. Keresse meg a DeleteConfirmed(int id) módszert a TeamsController osztályban. Adja hozzá a ClearCachedTeams metódus hívását, ahogy az az alábbi példában is látható:

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

Gyorsítótárazási metódusok hozzáadása a Teams Index nézethez

1. A Solution Explorer (Megoldáskezelőben) bontsa ki a Views (Nézetek), majd a Teams (Csapatok) mappát, és kattintson duplán az Index.cshtml fájlra.

   

2. A fájl elején keresse meg az alábbi bekezdéselemet:

   

   Ez a hivatkozás egy új csapatot hoz létre. Cserélje le a bekezdéselemet az alábbi táblával. Ez a tábla műveleti hivatkozásokkal rendelkezik egy új csapat létrehozása, egy új játékszezon lejátszása, a gyorsítótár kiürítése, a csapatok gyorsítótárból, több formátumban történő lekérdezése, a csapatok adatbázisból történő lekérdezése, valamint az adatbázis friss mintaadatokkal való újraépítése céljából.

   <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. Görgessen az Index.cshtml fájl aljára, és adja hozzá a következő tr elemet, hogy az a fájl utolsó táblázatának utolsó sora legyen:

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

   Ez a sor az aktuális művelet állapotjelentését ViewBag.Msgtartalmazó értékeket jeleníti meg. A ViewBag.Msg beállítás akkor van beállítva, ha az előző lépésben bármelyik művelethivatkozást kiválasztja.

   

4. A projekt létrehozásához nyomja le az F6 billentyűt.

Az alkalmazás futtatása helyben

Futtassa az alkalmazást a helyi számítógépen a csapatok támogatása érdekében hozzáadott funkció ellenőrzéséhez.

Ebben a tesztben az alkalmazás és az adatbázis is helyben fut. Az Azure Cache for Redis nem helyi. Távolról üzemelteti az Azure-ban. Ezért a gyorsítótár valószínűleg kissé alul fogja végezni az adatbázist. A legjobb teljesítmény érdekében az ügyfélalkalmazásnak és az Azure Cache for Redis-példánynak ugyanazon a helyen kell lennie.

A következő szakaszban minden erőforrást üzembe helyez az Azure-ban, hogy láthassa a gyorsítótár használatának jobb teljesítményét.

Az alkalmazás helyi futtatása:

1. Az alkalmazás futtatásához nyomja le a Ctrl+F5 billentyűkombinációt.

   

2. Tesztelje a nézethez hozzáadott összes új metódust. Mivel a gyorsítótár ezen tesztek során távolról fut, az adatbázisnak a gyorsítótárnál némileg nagyobb teljesítménnyel kell rendelkeznie.

Közzététel és futtatás az Azure-ban

Adatbázis kiépítése az alkalmazáshoz

Ebben a szakaszban egy új adatbázist fog kiépíteni az SQL Database-ben az azure-ban üzemeltetett alkalmazás számára.

1. Az Azure Portalon válassza az Erőforrás létrehozása lehetőséget az Azure Portal bal felső sarkában.

2. Az Új lapon válassza az Adatbázisok>SQL Database lehetőséget.

3. Használja a következő beállításokat az új SQL Database-adatbázishoz:

   Beállítás	Ajánlott érték	Leírás
   Adatbázis neve	ContosoTeamsDatabase	Az érvényes adatbázisnevekkel kapcsolatban lásd az adatbázis-azonosítókat ismertető cikket.
   Előfizetés	Az Ön előfizetése	Válassza ki ugyanazt az előfizetést, amelyet a gyorsítótár létrehozásához és az App Service futtatásához használt.
   Erőforráscsoport	TestResourceGroup	Válassza a Meglévő használata lehetőséget, és használja ugyanazt az erőforráscsoportot, amelyben elhelyezte a gyorsítótárat és az App Service-t.
   Forrás kiválasztása	Üres adatbázis	Kezdje egy üres adatbázissal.

4. A Kiszolgáló területen válassza a Szükséges beállítások>konfigurálása új kiszolgáló létrehozása lehetőséget, adja meg a következő adatokat, majd használja a Kiválasztás gombot:

   Beállítás	Ajánlott érték	Leírás
   Kiszolgáló neve	Bármely globálisan egyedi név	Az érvényes kiszolgálónevekkel kapcsolatban lásd az elnevezési szabályokat és korlátozásokat ismertető cikket.
   Kiszolgáló rendszergazdájának felhasználóneve	Bármely érvényes név	Az érvényes bejelentkezési nevekkel kapcsolatban lásd az adatbázis-azonosítókat ismertető cikket.
   Jelszó	Bármely érvényes jelszó	A jelszónak legalább 8 karakter hosszúságúnak kell lennie, és tartalmaznia kell karaktereket a következő kategóriák közül legalább háromból: nagybetűs karakterek, kisbetűs karakterek, számjegyek és nem alfanumerikus karakterek.
   Tartózkodási hely	USA keleti régiója	Válassza ki ugyanazt a régiót, amelyben a gyorsítótárat és az App Service-t létrehozta.

5. Válassza a Rögzítés az irányítópulton lehetőséget, majd a Létrehozás lehetőséget az új adatbázis és kiszolgáló létrehozásához.

6. Az új adatbázis létrehozása után válassza az Adatbázis-kapcsolati sztring megjelenítése lehetőséget, és másolja a ADO.NET kapcsolati sztring.

   

7. Az Azure Portalon lépjen az App Service-be, és válassza az Alkalmazás Gépház lehetőséget, majd adja hozzá az új kapcsolati sztring a Csatlakozás ion sztringek szakaszában.

8. Adjon hozzá egy TeamContext nevű kapcsolati sztringet, amely megegyezik az Entity Framework-adatbáziskörnyezet osztályának nevével. Illessze be az új adatbázis kapcsolati sztringjét az értékként. Cserélje le a következő helyőrzőket a kapcsolati sztring, és válassza a Mentés lehetőséget:

   Helyőrző	Ajánlott érték
   {saját_felhasználónév}	Használja az imént létrehozott kiszolgáló rendszergazdai bejelentkezési adatait .
   {saját_jelszó}	Használja az imént létrehozott kiszolgáló jelszavát.

   Ha a felhasználónevet és a jelszót alkalmazásbeállításként adja hozzá, a felhasználónév és a jelszó nem szerepel a kódban. Ez a módszer segíti a hitelesítő adatok védelmét.

Alkalmazásfrissítések közzététele az Azure-ban

Az oktatóanyag ezen lépésében közzéteszi az alkalmazás frissítéseit az Azure-ban, majd futtatja az alkalmazást a felhőben.

1. Kattintson a jobb gombbal a ContosoTeamStats projektre a Visual Studióban, és válassza a Közzététel lehetőséget.

   

2. Válassza a Közzététel lehetőséget, ha ugyanazt a közzétételi profilt szeretné használni, amelyet a rövid útmutatóban létrehozott.

3. Ha a közzététel befejeződött, a Visual Studio elindítja az alkalmazást az alapértelmezett webböngészőben.

   

   A mintaalkalmazás egyes műveleti hivatkozásait a következő táblázat ismerteti:

   Action	Leírás
   Új létrehozása	Létrehoz egy új csapatot.
   Szezon végigjátszása	Végigjátszik egy szezont, frissíti a csapatstatisztikákat, és törli a gyorsítótárból az elavult adatokat.
   Clear Cache	Törli a csapatstatisztikákat a gyorsítótárból.
   Lista a gyorsítótárból	Lekérdezi a csapatstatisztikákat a gyorsítótárból. Ha a gyorsítótár hiányzik, töltse be a statisztikákat az adatbázisból, és mentse a gyorsítótárba a következő alkalommal.
   Rendezett készlet a gyorsítótárból	Lekérdezi a csapatstatisztikákat a gyorsítótárból egy rendezett készlet használatával. Ha a gyorsítótár hiányzik, töltse be a statisztikákat az adatbázisból, és mentse a gyorsítótárba egy rendezett készlettel.
   Az 5 legjobb csapat a gyorsítótárból	Lekérdezi az 5 legjobb csapatot a gyorsítótárból egy rendezett készlet használatával. Ha a gyorsítótár hiányzik, töltse be a statisztikákat az adatbázisból, és mentse a gyorsítótárba egy rendezett készlettel.
   Betöltés adatbázisból	Lekérdezi a csapatstatisztikákat az adatbázisból.
   Adatbázis újraépítése	Újraépíti az adatbázist, és ismét feltölti azt minta-csapatadatokkal.
   Szerkesztés / Részletek / Törlés	Szerkeszthet egy csapatot, megtekintheti annak részletes adatait, törölhet egy csapatot.

Válasszon ki néhány műveletet, és kísérletezzen az adatok lekérésével a különböző forrásokból. Figyelje meg az adatbázisból és a gyorsítótárból történő adatlekérdezés különböző módjainak végrehajtásához szükséges időbeli eltéréseket.

Clean up resources

Ha végzett a minta oktatóanyag-alkalmazással, törölheti az Azure-erőforrásokat a költségek és erőforrások megőrzése érdekében. Az összes erőforrásnak ugyanabban az erőforráscsoportban kell lennie. Az erőforráscsoport törlésével egy művelettel együtt törölheti őket. A cikkben szereplő utasítások egy TestResources nevű erőforráscsoportot használtak.

Fontos

Az erőforráscsoport törlése nem visszaállítható; az erőforráscsoport és a benne foglalt erőforrások véglegesen törlődnek. Figyeljen arra, hogy ne töröljön véletlenül erőforráscsoportot vagy erőforrásokat. Ha a minta üzemeltetéséhez létrehozott erőforrásokat egy meglévő erőforráscsoportban hozta létre, amely a megtartani kívánt erőforrásokat tartalmazza, a bal oldalon egyenként törölheti az egyes erőforrásokat.

1. Jelentkezzen be az Azure Portalra, és válassza az Erőforráscsoportok elemet.

2. Írja be az erőforráscsoport nevét az Elemek szűrése... szövegmezőbe.

3. Válassza az erőforráscsoporttól jobbra található ... lehetőséget, és válassza az Erőforráscsoport törlése lehetőséget.

   

4. A rendszer az erőforráscsoport törlésének megerősítését kéri. Írja be a megerősítéshez az erőforráscsoport nevét, és válassza a Törlés lehetőséget.

   A rendszer néhány pillanaton belül törli az erőforráscsoportot és a benne foglalt erőforrásokat.

Következő lépések

Az Azure Cache for Redis méretezése