Kurz: Vytvoření tabulky výsledků s principem s doplňováním mezipaměti aplikací v ASP.NET

v tomto kurzu aktualizujete webovou aplikaci ContosoTeamStats ASP.NET---vytvořenou v ASP.NET rychlém startu pro Azure Cache pro Redis---, aby zahrnovala tabulek výsledků, která používá model doplňování mezipaměti s azure cache pro Redis. Ukázková aplikace zobrazuje seznam týmových statistik z databáze. Také ukazuje různé způsoby použití mezipaměti Azure pro Redis k ukládání a načítání dat z mezipaměti za účelem zvýšení výkonu. Po dokončení tohoto kurzu máte spuštěnou webovou aplikaci, která čte a zapisuje do databáze, je optimalizovaná pomocí Azure cache pro Redis a je hostovaná v Azure.

V tomto kurzu se naučíte:

  • Díky ukládání a načítání dat pomocí Azure cache pro Redis můžete zvýšit propustnost dat a snížit zatížení databáze.
  • Použít seřazenou sadu Redis k načtení pěti nejlepších týmů
  • Zřídit prostředky Azure pro aplikaci pomocí šablony Resource Manageru
  • Publikovat aplikaci do Azure pomocí sady Visual Studio

Pokud ještě nemáte předplatné Azure,vytvořte si bezplatný účet před tím, než začnete.

Požadavky

Pro absolvování tohoto kurzu musí být splněné následující požadavky:

Přidání tabulky výsledků do projektu

V této části kurzu nakonfigurujete projekt ContosoTeamStats s tabulkou výsledků, která oznamuje statistiku výher, proher a remíz u seznamu fiktivních týmů.

Přidání sady technologií Entity Framework do projektu

  1. v Visual Studio otevřete řešení ContosoTeamStats , které jste vytvořili v části rychlý start ASP.NET pro Azure Cache pro Redis.

  2. vyberte nástroje > NuGet Správce balíčků > konzole pro Správce balíčků.

  3. Z okna konzoly Správce balíčků spusťte následující příkaz a nainstalujte sadu technologií Entity Framework:

    Install-Package EntityFramework
    

Další informace o tomto balíčku najdete na stránce NuGet pro EntityFramework.

Přidání modelu Team

  1. V Průzkumníku řešení klikněte pravým tlačítkem na Modely a vyberte Přidat, Třídu.

  2. Jako Team název třídy zadejte a vyberte Přidat.

    Přidání třídy modelu

  3. Nahraďte příkazy using v horní části souboru Team.cs následujícími příkazy using:

    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Data.Entity.SqlServer;
    
  4. Nahraďte definici Team třídy následujícím fragmentem kódu, který obsahuje aktualizovanou Team definici třídy a jiné Entity Framework pomocné třídy. Tento kurz používá přístup Code First se sadou technologií Entity Framework. Díky tomu může sada technologií Entity Framework vytvořit databázi z vašeho kódu. Další informace o přístupu Code First k Entity Frameworku, který používáme v tomto kurzu, najdete v tématu Code First pro novou databázi.

    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. V Průzkumníku řešení dvakrát klikněte na soubor Web.config a otevřete ho.

    Soubor web.config

  6. Přidejte následující sekci connectionStrings do sekce configuration. Název připojovacího řetězce se musí shodovat s názvem třídy kontextu databáze v sadě Entity Framework, což je TeamContext.

    tento připojovací řetězec předpokládá, že jste splnili požadavky a nainstalovaná SQL Server Express LocalDB, která je součástí úlohy vývoj desktopových aplikací pro .net, která je nainstalovaná s Visual Studio 2019.

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

    Následující příklad ukazuje novou sekci connectionStrings následující configSections v sekci 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>
        ...
    

Přidání kontroleru TeamsController a zobrazení

  1. V sadě Visual Studio sestavte projekt.

  2. V Průzkumníku řešení klikněte pravým tlačítkem na složku Kontrolery a vyberte Přidat, Kontroler.

  3. Zvolte kontroler MVC 5 se zobrazeními, pomocí Entity Framework a vyberte Přidat. Pokud se po výběru možnosti Přidat zobrazí chyba, ujistěte se, že jste projekt vytvořili jako první.

    Přidání třídy kontroleru

  4. Vyberte Team (ContosoTeamStats.Models) z rozevíracího seznamu Třída modelu. Vyberte TeamContext (ContosoTeamStats.Models) z rozevíracího seznamu Třída kontextu dat. TeamsControllerDo textového pole název kontroleru zadejte (Pokud není automaticky vyplněný). Vyberte Přidat a vytvořte třídu kontroleru a přidejte výchozí zobrazení.

    Konfigurace kontroleru

  5. V Průzkumníku řešení rozbalte Global.asax a dvojím kliknutím otevřete soubor Global.asax.cs.

    Soubor Global.asax.cs

  6. Přidejte následující dva příkazy using do horní části souboru pod ostatní příkazy using:

    using System.Data.Entity;
    using ContosoTeamStats.Models;
    
  7. Přidejte následující řádek kódu na konec metody Application_Start:

    Database.SetInitializer<TeamContext>(new TeamInitializer());
    
  8. V Průzkumníku řešení rozbalte App_Start a dvakrát klikněte na soubor RouteConfig.cs.

    Soubor RouteConfig.cs

  9. V metodě RegisterRoutes nahraďte controller = "Home" v cestě Default řetězcem controller = "Teams", jak je znázorněno v následujícím příkladu:

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

Konfigurace zobrazení Rozložení

  1. V Průzkumníku řešení rozbalte složku Zobrazení, poté složku Sdílené, a dvakrát klikněte na soubor _Layout.cshtml.

    Soubor _Layout.cshtml

  2. Změňte obsah elementu title a nahraďte My ASP.NET Application za Contoso Team Stats, jak je znázorněno v následujícím příkladu:

    <title>@ViewBag.Title - Contoso Team Stats</title>
    
  3. V body části přidejte následující nový Html.ActionLink příkaz pro statistiky týmu contoso hned pod odkazem pro Azure cache for Redis test.

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

    Změny kódu

  4. Stisknutím kombinace kláves Ctrl+F5 sestavíte a spustíte aplikaci. Tato verze aplikace načítá výsledky přímo z databáze. Všimněte si akcí Vytvořit nový, Upravit, Podrobnosti a Odstranit, které do aplikace automaticky přidalo vygenerované uživatelské rozhraní Kontroler MVC 5 se zobrazeními, s použitím Entity Frameworku. V další části tohoto kurzu přidáte Azure cache pro Redis k optimalizaci přístupu k datům a poskytování dalších funkcí aplikace.

    Startovní aplikace

Konfigurace aplikace pro mezipaměť Azure pro Redis

V této části kurzu nakonfigurujete ukázkovou aplikaci pro ukládání a načítání týmových statistik contoso z mezipaměti Azure pro instanci Redis pomocí klienta mezipaměti stackexchange. Redis .

Přidání připojení mezipaměti ke kontroleru Teams

V rychlém startu jste už nainstalovali balíček klientské knihovny StackExchange.Redis. Také jste nakonfigurovali aplikaci CacheConnection, aby se používala místně a pomocí publikované služby App Service. Použijte stejnou klientskou knihovnu a informace CacheConnection uvedené v kontroleru TeamsController.

  1. V Průzkumníku řešení rozbalte složku Kontrolery a dvojím kliknutím otevřete soubor TeamsController.cs.

    Kontroler Teams

  2. usingDo TeamsController. cs přidejte následující dva příkazy:

    using System.Configuration;
    using StackExchange.Redis;
    
  3. Přidejte následující dvě vlastnosti do třídy 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;
        }
    }
    

Aktualizace kontroleru TeamsController na čtení z mezipaměti nebo databáze

V této ukázce lze týmové statistiky získat z databáze nebo z mezipaměti. Týmové statistiky jsou v mezipaměti uložené pomocí datových typů Redis jako serializovaný seznam List<Team>, a také jako seřazená sada. Při načítání položek ze seřazené sady můžete načíst část položek, všechny položky nebo provézt dotaz na určité položky. V této ukázce se podíváte na seřazenou sadu pro 5 nejoblíbenějších týmů seřazené podle počtu WINS.

Není nutné ukládat statistiky týmu do více formátů v mezipaměti pro použití mezipaměti Azure pro Redis. V tomto kurzu používáme více formátů, abychom předvedli různé způsoby a datové typy, které můžete použít pro ukládání dat do mezipaměti.

  1. Přidejte následující příkazy using do horní části souboru TeamsController.cs k ostatním příkazům using:

    using System.Diagnostics;
    using Newtonsoft.Json;
    
  2. Nahraďte stávající implementaci metody public ActionResult Index() za následující implementaci:

    // 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. Přidejte následující tři metody do třídy TeamsController pro implementaci typů akcí playGames, clearCache a rebuildDB z výrazu switch, který jste přidali v předchozím fragmentu kódu.

    Metoda PlayGames aktualizuje týmové statistiky tak, že simuluje sezónu her, výsledky uloží do databáze, a vymaže již zastaralá data z mezipaměti.

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

    Metoda RebuildDB znovu inicializuje databázi s výchozí sadou týmů, vygeneruje pro ně statistiky, a vymaže již zastaralá data z mezipaměti.

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

    Metoda ClearCachedTeams odebere z mezipaměti všechny uložené týmové statistiky.

    void ClearCachedTeams()
    {
        IDatabase cache = Connection.GetDatabase();
        cache.KeyDelete("teamsList");
        cache.KeyDelete("teamsSortedSet");
        ViewBag.msg += "Team data removed from cache. ";
    }
    
  4. Přidejte následující čtyři metody do třídy TeamsController pro implementaci různých způsobů načítání týmových statistik z mezipaměti a z databáze. Každá z těchto metod vrátí seznam List<Team>, který se následně zobrazí v zobrazení.

    Metoda GetFromDB načítá týmové statistiky z databáze.

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

    Metoda GetFromList načítá týmové statistiky z mezipaměti jako serializovaný seznam List<Team>. Pokud statistiky nejsou k dispozici v mezipaměti, dojde k neúspěšnému vykonání mezipaměti. V takovém případě se týmové statistiky načtou z databáze a uloží se do mezipaměti pro použití v další žádosti. V této ukázce je pro serializaci objektů .NET do a z mezipaměti použita serializace JSON.NET. Další informace najdete v tématu How to work with .NET objects in 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;
    }
    

    Metoda GetFromSortedSet načítá týmové statistiky ze seřazené sady v mezipaměti. Pokud dojde k chybě v mezipaměti, týmové statistiky se načtou z databáze a uloží se do mezipaměti jako seřazená sada.

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

    Metoda GetFromSortedSetTop5 načte seznam pěti nejlepších týmů ze seřazené sady uložené v mezipaměti. Začne tím, že zjistí přítomnost klíče teamsSortedSet v mezipaměti. Pokud tento klíč neexistuje, volá se metoda , která načte týmové statistiky a GetFromSortedSet uloží je do mezipaměti. Poté se provede dotaz na seřazenou sadu, aby se vrátil seznam pěti nejlepších týmů.

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

Aktualizace metod Create, Edit a Delete pro práci s mezipamětí

Kód generování uživatelského rozhraní vygenerovaný jako součást této ukázky obsahuje metody pro přidávání, upravování a odstraňování týmů. Pokaždé když dojde k přidání, úpravě nebo odstranění týmu se data v mezipaměti stanou zastaralými. V této části upravíte tyto tři metody pro vymazání týmů z mezipaměti, aby bylo možné mezipaměť aktualizovat.

  1. Přejděte k metodě Create(Team team) ve třídě TeamsController. Přidejte volání metody ClearCachedTeams, jak je znázorněno v následujícím příkladu:

    // 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. Přejděte k metodě Edit(Team team) ve třídě TeamsController. Přidejte volání metody ClearCachedTeams, jak je znázorněno v následujícím příkladu:

    // 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. Přejděte k metodě DeleteConfirmed(int id) ve třídě TeamsController. Přidejte volání metody ClearCachedTeams, jak je znázorněno v následujícím příkladu:

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

Přidání metod ukládání do mezipaměti do zobrazení indexu Teams

  1. V Průzkumníku řešení rozbalte složku Zobrazení, poté složku Týmy, a dvakrát klikněte na soubor Index.cshtml.

    Soubor Index.cshtml

  2. V horní části souboru vyhledejte následující element odstavce:

    Tabulka akcí

    Tento odkaz vytvoří nový tým. Nahraďte element odstavce za následující tabulku. Tato tabulka obsahuje odkazy pro vytvoření nového týmu, hraní nové sezóny her, vymazání mezipaměti, načtení týmů z mezipaměti v různých formátech, načtení týmů z databáze a nové sestavení databáze s novými vzorovými daty.

    <table class="table&quot;>
        <tr>
            <td>
                @Html.ActionLink(&quot;Create New&quot;, &quot;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. Posuňte se do dolní části souboru Index.cshtml a přidejte následující element, aby byl posledním řádkem poslední tabulky tr v souboru:

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

    Tento řádek zobrazuje hodnotu ViewBag.Msg , která obsahuje zprávu o stavu aktuální operace. Vlastnost ViewBag.Msg se nastaví, když vyberete některý z odkazů na akce z předchozího kroku.

    Zpráva o stavu

  4. Projekt sestavíte stisknutím klávesy F6.

Místní spuštění aplikace

Spusťte aplikaci místně na počítači a ověřte funkci přidanou pro podporu týmů.

V tomto testu jsou aplikace i databáze spuštěny místně. Název Azure Cache for Redis není místní. Hostuje se vzdáleně v Azure. To je důvod, proč mezipaměť pravděpodobně nebude provádět databázi poněkud málo. Pro nejlepší výkon by klientská aplikace a Azure Cache for Redis měly být ve stejném umístění.

V další části nasadíte všechny prostředky do Azure, abyste viděli vylepšený výkon při používání mezipaměti.

Spuštění aplikace místně:

  1. Stisknutím kombinace kláves Ctrl+F5 spusťte aplikaci.

    Aplikace spuštěná místně

  2. Otestuje všechny nové metody, které jste přidali do zobrazení. Vzhledem k tomu, že mezipaměť je v těchto testech vzdálená, bude databáze o něco málo výkonnější než mezipaměť.

Publikování a spuštění v Azure

Zřízení databáze pro aplikaci

V této části zzřídit novou databázi v SQL Database, kterou bude aplikace používat, když je hostovaná v Azure.

  1. V Azure Portalvyberte Vytvořit prostředek v levém horním rohu Azure Portal.

  2. Na stránce Nový vyberte Databáze > SQL Database.

  3. Pro novou databázi SQL použijte následující nastavení:

    Nastavení       Navrhovaná hodnota Popis 
    Název databáze ContosoTeamsDatabase Platné názvy databází najdete v tématu Identifikátory databází.
    Předplatné Vaše předplatné Vyberte stejné předplatné, které jste použili k vytvoření mezipaměti a hostování služby App Service.
    Skupina prostředků TestResourceGroup Vyberte Použít existující a použijte stejnou skupinu prostředků, do které jste umístili mezipaměť a App Service.
    Zvolit zdroj Prázdná databáze Začněte s prázdnou databází.
  4. V části Server vyberte Konfigurovat požadovaná nastavení. Vytvořte nový > server, zadejte následující informace a pak použijte tlačítko Vybrat:

    Nastavení       Navrhovaná hodnota Popis 
    Název serveru Libovolný globálně jedinečný název Platné názvy serverů najdete v tématu Pravidla a omezení pojmenování.
    Přihlašovací jméno správce serveru Libovolné platné jméno Platná přihlašovací jména najdete v tématu Identifikátory databází.
    Heslo Libovolné platné heslo Heslo musí mít alespoň 8 znaků a musí obsahovat znaky ze tří z následujících kategorií: velká písmena, malá písmena, číslice a jiné než alfanumerické znaky.
    Umístění East US Vyberte stejnou oblast, ve které jste vytvořili mezipaměť a App Service.
  5. Vyberte Připnout na řídicí panel a pak Vytvořit a vytvořte novou databázi a server.

  6. Po vytvoření nové databáze vyberte Zobrazit připojovací řetězce databáze a zkopírujte ADO.NET připojovací řetězec.

    Zobrazení připojovacích řetězců

  7. V Azure Portal přejděte ke svému App Service, vyberte Application Nastavení a pak v části Připojovací řetězce přidejte nový připojovací řetězec.

  8. Přidejte nový připojovací řetězec s názvem TeamContext, aby odpovídal třídě kontextu databáze sady technologií Entity Framework. Vložte připojovací řetězec nové databáze jako hodnotu. Nezapomeňte v připojovacím řetězci nahradit následující zástupné symboly a vybrat Uložit:

    Zástupný symbol Navrhovaná hodnota
    {vaše_uživatelské jméno} Použijte přihlašovací jméno správce serveru pro server, který jste právě vytvořili.
    {vaše_heslo} Použijte heslo pro server, který jste právě vytvořili.

    Když uživatelské jméno a heslo přidáte jako Nastavení aplikace, vaše uživatelské jméno a heslo se do vašeho kódu nezahrnou. Tento přístup vám pomůže přihlašovací údaje ochránit.

Publikování aktualizací aplikace do Azure

V tomto kroku kurzu publikujete aktualizace aplikace do Azure a spustíte ji v cloudu.

  1. Pravým tlačítkem vyberte projekt ContosoTeamStats v Visual Studio a zvolte Publikovat.

    Publikovat

  2. Pokud chcete použít stejný profil publikování, který jste vytvořili v rychlém startu, vyberte Publikovat.

  3. Po dokončení publikování Visual Studio spustí aplikaci ve výchozím webovém prohlížeči.

    Mezipaměť byla přidána

    Následující tabulka popisuje každý odkaz na akci v ukázkové aplikaci:

    Akce Popis
    Vytvořit nové Vytvoření nového týmu.
    Odehrát sezónu Odehrání sezóny her, aktualizace týmových statistik a vymazání zastaralých dat z mezipaměti.
    Vymazat mezipaměť Vymazání týmových statistik z mezipaměti.
    Seznam z mezipaměti Načtení týmových statistik z mezipaměti. Pokud dojde k chybě v mezipaměti, načtěte statistiky z databáze a příště je uložte do mezipaměti.
    Seřazená sada z mezipaměti Načtení týmových statistik z mezipaměti pomocí seřazené sady. Pokud dojde k chybě v mezipaměti, načtěte statistiky z databáze a uložte je do mezipaměti pomocí seřazené sady.
    Top 5 týmů z mezipaměti Načtení Top 5 týmů z mezipaměti pomocí seřazené sady. Pokud dojde k chybě v mezipaměti, načtěte statistiky z databáze a uložte je do mezipaměti pomocí seřazené sady.
    Načíst z databáze Načtení týmových statistik z databáze.
    Znovu sestavit databázi Opětovné vytvoření databáze se vzorovými týmovými daty.
    Upravit / Podrobnosti / Odstranit Upravení týmu, zobrazení podrobností o týmu, odstranění týmu.

Vyberte některé z akcí a experimentujte s načítáním dat z různých zdrojů. Všimněte si rozdílů v době trvání různých způsobů načítání dat z databáze a mezipaměti.

Vyčištění prostředků

Po dokončení ukázkové výukové aplikace můžete prostředky Azure odstranit a ušetřit tak náklady a prostředky. Všechny vaše prostředky by měly být obsažené ve stejné skupině prostředků. Můžete je odstranit společně v jedné operaci odstraněním skupiny prostředků. V pokynech v tomto článku se používala skupina prostředků TestResources.

Důležité

Odstranění skupiny prostředků je nevratné a skupina prostředků včetně všech v ní obsažených prostředků bude trvale odstraněna. Ujistěte se, že nechtěně neodstraníte nesprávnou skupinu prostředků nebo prostředky. Pokud jste vytvořili prostředky pro hostování této ukázky v existující skupině prostředků, která obsahuje prostředky, které chcete zachovat, můžete odstranit každý prostředek jednotlivě na levé straně.

  1. Přihlaste se k webu Azure Portal a potom vyberte Skupiny prostředků.

  2. Zadejte název vaší skupiny prostředků do textového pole Filtrování položek....

  3. Vyberte ... napravo od vaší skupiny prostředků a vyberte Odstranit skupinu prostředků.

    Odstranit

  4. Zobrazí se výzva k potvrzení odstranění skupiny prostředků. Potvrďte to tak, že zadejte název vaší skupiny prostředků, a vyberte Odstranit.

    Po chvíli bude skupina prostředků včetně všech obsažených prostředků odstraněná.

Další kroky