Udostępnij za pośrednictwem

Samouczek: tworzenie rankingu z odkładaniem do pamięci podręcznej na platformie ASP.NET

  • Artykuł

W tym samouczku zaktualizujesz aplikację internetową ContosoTeamStats ASP.NET--- utworzoną w przewodniku Szybki start ASP.NET dla usługi Azure Cache for Redis--- aby dołączyć ranking korzystający ze wzorca odkładania do pamięci podręcznej za pomocą usługi Azure Cache for Redis. Przykładowa aplikacja wyświetla listę statystyk zespołu z bazy danych. Demonstruje również różne sposoby używania usługi Azure Cache for Redis do przechowywania i pobierania danych z pamięci podręcznej w celu zwiększenia wydajności. Po ukończeniu samouczka masz uruchomioną aplikację internetową, która odczytuje i zapisuje w bazie danych, zoptymalizowaną pod kątem usługi Azure Cache for Redis i hostowaną na platformie Azure.

Z tego samouczka dowiesz się, jak wykonywać następujące czynności:

  • Zwiększ przepływność danych i ogranicz obciążenie bazy danych, przechowując i pobierając dane przy użyciu usługi Azure Cache for Redis.
  • Użyj sortowanego zestawu Redis do pobrania pierwszych pięciu zespołów.
  • Aprowizuj zasoby platformy Azure dla aplikacji przy użyciu szablonu usługi Resource Manager.
  • Opublikuj aplikację na platformie Azure przy użyciu programu Visual Studio.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

Wymagania wstępne

Do ukończenia tego samouczka niezbędne są:

Dodawanie rankingu do projektu

W tej części samouczka dla projektu ContosoTeamStats zostanie skonfigurowany ranking przedstawiający statystyki zwycięstw, przegranych i remisów fikcyjnych drużyn.

Dodawanie platformy Entity Framework do projektu

  1. W programie Visual Studio otwórz rozwiązanie ContosoTeamStats utworzone w przewodniku Szybki start platformy ASP.NET dla usługi Azure Cache for Redis.

  2. Wybierz pozycję Narzędzia NuGet > Menedżer pakietów konsoli Menedżer pakietów>.

  3. Uruchom następujące polecenie w oknie Konsola menedżera pakietów, aby zainstalować platformę EntityFramework:

    Install-Package EntityFramework

Aby uzyskać więcej informacji dotyczących tego pakietu, zobacz stronę pakietu NuGet programu EntityFramework.

Dodawanie modelu zespołu

  1. Kliknij prawym przyciskiem myszy pozycję Modele w Eksploratorze rozwiązań, a następnie wybierz kolejno pozycje Dodaj, Klasa.

  2. Wprowadź Team nazwę klasy i wybierz pozycję Dodaj.

    Dodawanie klasy modelu

  3. Zastąp instrukcje using na początku pliku Team.cs poniższymi instrukcjami using:

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

  4. Zastąp definicję Team klasy poniższym fragmentem kodu zawierającym zaktualizowaną Team definicję klasy i inne klasy pomocnicze programu Entity Framework. W tym samouczku stosowane jest podejście Code First z platformą Entity Framework. Takie podejście umożliwia platformie Entity Framework utworzenie bazy danych z poziomu kodu. Więcej informacji na temat podejścia typu Code First na platformie Entity Framework używanego w tym samouczku znajduje się w artykule Code first to a new database (Rozwiązanie Code First dla nowej bazy danych).

    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. W Eksploratorze rozwiązań kliknij dwukrotnie plik Web.config, aby go otworzyć.

    Web.config

  6. Dodaj następującą sekcję connectionStrings wewnątrz sekcji configuration. Nazwa parametrów połączenia musi być zgodna z nazwą klasy kontekstu bazy danych platformy Entity Framework, którą jest TeamContext.

    W tym parametry połączenia przyjęto założenie, że spełniono wymagania wstępne i zainstalowano bazę danych SQL Server Express LocalDB, która jest częścią obciążenia programistycznego dla komputerów .NET zainstalowanych w programie Visual Studio 2019.

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

    W poniższym przykładzie pokazano nową sekcję connectionStrings znajdującą się po sekcji configSections wewnątrz sekcji 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>
    ...

Dodawanie elementu TeamsController i widoków

  1. Skompiluj projekt w programie Visual Studio.

  2. W Eksploratorze rozwiązań kliknij prawym przyciskiem myszy folder Kontrolery i wybierz kolejno pozycje Dodaj, Kontroler.

  3. Wybierz pozycję Kontroler MVC 5 z widokami, przy użyciu programu Entity Framework, a następnie wybierz pozycję Dodaj. Jeśli po wybraniu pozycji Dodaj wystąpi błąd, upewnij się, że projekt został skompilowany jako pierwszy.

    Dodawanie klasy kontrolera

  4. Wybierz pozycję Zespół (ContosoTeamStats.Models) z listy rozwijanej Klasa modelu. Wybierz pozycję TeamContext (ContosoTeamStats.Models) z listy rozwijanej Klasa kontekstu danych. Wpisz TeamsController w polu tekstowym Nazwa kontrolera (jeśli nie zostanie on automatycznie wypełniony). Wybierz pozycję Dodaj , aby utworzyć klasę kontrolera i dodać widoki domyślne.

    Konfigurowanie kontrolera

  5. W Eksploratorze rozwiązań rozwiń folder Global.asax i kliknij dwukrotnie plik Global.asax.cs, aby go otworzyć.

    Global.asax.cs

  6. Dodaj dwie poniższe instrukcje using na początku pliku pod innymi instrukcjami using:

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

  7. Dodaj poniższy wiersz kodu na końcu metody Application_Start:

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

  8. W Eksploratorze rozwiązań rozwiń folder App_Start i kliknij dwukrotnie pozycję RouteConfig.cs.

    RouteConfig.cs

  9. W metodzie RegisterRoutes zastąp element controller = "Home" w trasie Default elementem controller = "Teams", jak pokazano w poniższym przykładzie:

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

Konfigurowanie widoku układu

  1. W Eksploratorze rozwiązań rozwiń folder Widoki, a następnie folder Współużytkowane, a następnie kliknij dwukrotnie pozycję _Layout.cshtml.

    _Layout.cshtml

  2. Zmień zawartość elementu title i zastąp ciąg My ASP.NET Application ciągiem Contoso Team Stats, jak pokazano w poniższym przykładzie:

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

  3. W sekcji body dodaj następującą nową instrukcję Html.ActionLink dla projektu Contoso Team Stats zaraz pod linkiem dla elementu Azure Cache for Redis Test.

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

    Zmiany kodu

  4. Naciśnij klawisze Ctrl+F5, aby utworzyć i uruchomić aplikację. Ta wersja aplikacji odczytuje wyniki bezpośrednio z bazy danych. Zwróć uwagę na akcje Utwórz nowe, Edytuj, Szczegóły oraz Usuń, które zostały automatycznie dodane do aplikacji przez szkielet Kontroler MVC 5 z widokami używający narzędzia Entity Framework. W następnej sekcji samouczka dodasz usługę Azure Cache for Redis, aby zoptymalizować dostęp do danych i udostępnić więcej funkcji aplikacji.

    Aplikacja startowa

Konfigurowanie aplikacji dla usługi Azure Cache for Redis

W tej sekcji samouczka skonfigurujesz przykładową aplikację do przechowywania i pobierania statystyk zespołu Contoso z wystąpienia usługi Azure Cache for Redis za pomocą klienta pamięci podręcznej StackExchange.Redis.

Dodawanie połączenia pamięci podręcznej do kontrolera zespołów

Pakiet biblioteki klienta StackExchange.Redis został już zainstalowany w ramach przewodnika Szybki start. Oprócz tego skonfigurowano ustawienia aplikacji CacheConnection tak, aby była używana lokalnie i z opublikowaną usługą App Service. Użyj tej samej biblioteki klienta i informacji CacheConnection w elemencie TeamsController.

  1. W Eksploratorze rozwiązań rozwiń folder Kontrolery i kliknij dwukrotnie plik TeamsController.cs, aby go otworzyć.

    Kontroler zespołów

  2. Dodaj dwie poniższe instrukcje using do pliku TeamsController.cs:

    using System.Configuration;
using StackExchange.Redis;

  3. Dodaj dwie poniższe właściwości do klasy 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;
    }
}

Aktualizacja elementu TeamsController do odczytywania informacji z pamięci podręcznej lub bazy danych

W tym przykładzie statystyki zespołu można pobrać z bazy danych lub z pamięci podręcznej. Statystyki zespołu są przechowywane w pamięci podręcznej jako zserializowany obiekt List<Team>, a także jako posortowany zestaw korzystający z typów danych Redis. Podczas pobierania elementów z zestawu posortowanego możesz pobrać część z nich, wszystkie lub przesłać zapytanie o określone elementy. W tym przykładzie wykonasz zapytanie dotyczące posortowanego zestawu dla pięciu najlepszych zespołów sklasyfikowanych według liczby zwycięstw.

Nie jest wymagane przechowywanie statystyk zespołu w wielu formatach w pamięci podręcznej w celu korzystania z usługi Azure Cache for Redis. W tym samouczku używa się wielu formatów, aby przedstawić różne sposoby i różne typy danych, których można użyć do buforowania danych.

  1. Dodaj poniższe instrukcje using na początku pliku TeamsController.cs razem z innymi instrukcjami using:

    using System.Diagnostics;
using Newtonsoft.Json;

  2. Zastąp bieżącą implementację metody public ActionResult Index() następującą implementacją:

    // 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. Dodaj następujące trzy metody do klasy TeamsController, aby wdrożyć typy akcji playGames, clearCache i rebuildDB z instrukcji switch dodanej w poprzednim fragmencie kodu.

    Metoda PlayGames aktualizuje statystyki zespołu, symulując sezon gier, zapisuje wyniki w bazie danych i czyści obecnie nieaktualne dane z pamięci podręcznej.

    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 ponownie inicjuje bazę danych z domyślnym zestawem zespołów, generuje ich statystyki i czyści obecnie nieaktualne dane z pamięci podręcznej.

    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 usuwa wszystkie buforowane statystyki zespołów z pamięci podręcznej.

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

  4. Dodaj poniższe cztery metody do klasy TeamsController, aby wdrożyć różne sposoby pobierania statystyk zespołu z pamięci podręcznej i bazy danych. Każda z tych metod zwraca obiekt List<Team>, który jest następnie wyświetlany w widoku.

    Metoda GetFromDB odczytuje statystyki zespołu z bazy danych.

    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 odczytuje statystyki zespołu z pamięci podręcznej jako zserializowany obiekt List<Team>. Jeśli statystyki nie są obecne w pamięci podręcznej, wystąpi błąd pamięci podręcznej. W przypadku chybienia w pamięci podręcznej statystyki zespołu są odczytywane z bazy danych, a następnie zapisywane w pamięci podręcznej do użytku przy następnym żądaniu. W tym przykładzie używana jest serializacja JSON.NET do serializacji obiektów platformy .NET podczas zapisu w pamięci podręcznej i odczytu z niej. Aby uzyskać więcej informacji, zobacz Praca z obiektami .NET w usłudze 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 odczytuje statystyki zespołu z buforowanego zestawu posortowanego. Jeśli brakuje pamięci podręcznej, statystyki zespołu są odczytywane z bazy danych i przechowywane w pamięci podręcznej jako posortowany zestaw.

    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 odczytuje pierwsze pięć zespołów z buforowanego zestawu posortowanego. Rozpoczyna od sprawdzenia pamięci podręcznej pod kątem istnienia klucza teamsSortedSet. Jeśli ten klucz nie jest obecny, metoda jest wywoływana w GetFromSortedSet celu odczytania statystyk zespołu i zapisania ich w pamięci podręcznej. Następnie zostaje przesłane zapytanie do buforowanego zestawu posortowanego, które zwraca pięć najlepszych zespołów.

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

Aktualizacja metod Utwórz, Edytuj i Usuń w celu pracy z pamięcią podręczną

Kod tworzenia szkieletu, który został wygenerowany w ramach tego przykładu, zawiera metody dodawania, edytowania i usuwania zespołów. Za każdym razem, gdy zespół jest dodawany, edytowany lub usuwany, dane w pamięci podręcznej stają się nieaktualne. W tej sekcji zmodyfikujesz te trzy metody w celu czyszczenia buforowanych zespołów w taki sposób, aby pamięć podręczna była odświeżana.

  1. Przejdź do metody Create(Team team) w klasie TeamsController. Dodaj wywołanie metody ClearCachedTeams, jak pokazano w poniższym przykładzie:

    // 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. Przejdź do metody Edit(Team team) w klasie TeamsController. Dodaj wywołanie metody ClearCachedTeams, jak pokazano w poniższym przykładzie:

    // 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. Przejdź do metody DeleteConfirmed(int id) w klasie TeamsController. Dodaj wywołanie metody ClearCachedTeams, jak pokazano w poniższym przykładzie:

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

Dodawanie metod buforowania do widoku indeksu zespołów

  1. W Eksploratorze rozwiązań rozwiń folder Widoki, a następnie folder Zespoły i kliknij dwukrotnie plik Index.cshtml.

    Index.cshtml

  2. W początkowej części pliku odszukaj następujący element akapitu:

    Tabela akcji

    Ten link tworzy nowy zespół. Zastąp element akapitu poniższą tabelą. Ta tabela zawiera linki akcji do tworzenia nowego zespołu, odtwarzania nowego sezonu gier, czyszczenia pamięci podręcznej, pobierania zespołów z pamięci podręcznej w wielu formatach, pobierania zespołów z bazy danych i odbudowy bazy danych przy użyciu nowych przykładowych danych.

    <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. Przewiń do dołu pliku Index.cshtml i dodaj następujący tr element, aby był to ostatni wiersz w ostatniej tabeli w pliku:

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

    W tym wierszu jest wyświetlana wartość ViewBag.Msg, która zawiera raport o stanie bieżącej operacji. Parametr ViewBag.Msg jest ustawiany po wybraniu dowolnego linku akcji z poprzedniego kroku.

    Komunikat o stanie

  4. Naciśnij klawisz F6, aby utworzyć projekt.

Lokalne uruchamianie aplikacji

Uruchom aplikację lokalnie na swojej maszynie, aby sprawdzić funkcje dodane w celu obsługi zespołów.

Podczas tego testu aplikacja i baza danych działają lokalnie. Usługa Azure Cache for Redis nie jest lokalna. Jest on hostowany zdalnie na platformie Azure. Dlatego pamięć podręczna będzie prawdopodobnie nieco niedostatecznie wykonywać bazę danych. Aby uzyskać najlepszą wydajność, aplikacja klienta i wystąpienie usługi Azure Cache for Redis powinny być w tej samej lokalizacji.

W następnej sekcji wdrożysz wszystkie zasoby na platformie Azure, aby zobaczyć lepszą wydajność korzystania z pamięci podręcznej.

Aby uruchomić aplikację lokalnie:

  1. Naciśnij klawisze Ctrl+F5, aby uruchomić aplikację.

    Aplikacja uruchomiona lokalnie

  2. Przetestuj wszystkie nowe metody dodane do widoku. Ponieważ w tych testach pamięć podręczna jest zdalna, wydajność bazy danych powinna nieco przewyższać wydajność pamięci podręcznej.

Publikowanie i uruchamianie na platformie Azure

Aprowizuj bazę danych dla aplikacji

W tej sekcji zaaprowizujesz nową bazę danych w usłudze SQL Database, aby aplikacja była używana podczas hostowania na platformie Azure.

  1. W witrynie Azure Portal wybierz pozycję Utwórz zasób w lewym górnym rogu witryny Azure Portal.

  2. Na stronie Nowy wybierz pozycje Bazy danych>SQL Database.

  3. Dla nowej bazy danych SQL Database użyj następujących ustawień:

    Ustawienie Sugerowana wartość Opis
    Nazwa bazy danych ContosoTeamsDatabase Prawidłowe nazwy baz danych opisano w artykule Database Identifiers (Identyfikatory baz danych).
    Subskrypcja Twoja subskrypcja Wybierz tę samą subskrypcję, która została użyta do utworzenia pamięci podręcznej i hostowania usługi App Service.
    Grupa zasobów: TestResourceGroup Wybierz pozycję Użyj istniejącej i użyj tej samej grupy zasobów, w której umieszczono pamięć podręczną i usługę App Service.
    Wybierz źródło Pusta baza danych Zacznij od pustej bazy danych.

  4. W obszarze Serwer wybierz pozycję Skonfiguruj wymagane ustawienia>Utwórz nowy serwer i podaj następujące informacje, a następnie użyj przycisku Wybierz:

    Ustawienie Sugerowana wartość Opis
    Nazwa serwera Dowolna nazwa unikatowa w skali globalnej Prawidłowe nazwy serwera opisano w artykule Naming rules and restrictions (Reguły i ograniczenia nazewnictwa).
    Identyfikator logowania administratora serwera Dowolna prawidłowa nazwa Prawidłowe nazwy identyfikatorów logowania opisano w artykule Database Identifiers (Identyfikatory baz danych).
    Hasło Dowolne prawidłowe hasło Hasło musi mieć co najmniej 8 znaków i musi zawierać znaki z trzech z następujących kategorii: wielkie litery, małe litery, cyfry i znaki inne niż alfanumeryczne.
    Lokalizacja Wschodnie stany USA Wybierz ten sam region, w którym utworzono pamięć podręczną i usługę App Service.

  5. Wybierz pozycję Przypnij do pulpitu nawigacyjnego , a następnie pozycję Utwórz , aby utworzyć nową bazę danych i serwer.

  6. Po utworzeniu nowej bazy danych wybierz pozycję Pokaż parametry połączenia bazy danych i skopiuj ADO.NET parametry połączenia.

    Pokazywanie parametrów połączeń

  7. W witrynie Azure Portal przejdź do usługi App Service i wybierz pozycję Ustawienia aplikacji, a następnie pozycję Dodaj nowe parametry połączenia w sekcji Parametry połączenia.

  8. Dodaj nowe parametry połączenia o nazwie TeamContext, aby zachować zgodność z klasą kontekstu bazy danych platformy Entity Framework. Wklej parametry połączenia dla nowej bazy danych jako wartość. Pamiętaj, aby zastąpić następujące symbole zastępcze w parametry połączenia i wybrać pozycję Zapisz:

    Symbol zastępczy Sugerowana wartość
    {your_username} Użyj nazwy logowania administratora serwera dla właśnie utworzonego serwera.
    {your_password} Użyj hasła dla właśnie utworzonego serwera.

    Dodając nazwę użytkownika i hasło jako ustawienie aplikacji, nazwa użytkownika i hasło nie są uwzględnione w kodzie. To podejście pomaga chronić te poświadczenia.

Publikowanie aktualizacji aplikacji na platformie Azure

W tym kroku samouczka opublikujesz aktualizacje aplikacji na platformie Azure w celu uruchamiania jej w chmurze.

  1. Wybierz prawym przyciskiem pozycję Projekt ContosoTeamStats w programie Visual Studio i wybierz pozycję Publikuj.

    Publikowanie

  2. Wybierz pozycję Publikuj , aby użyć tego samego profilu publikowania utworzonego w przewodniku Szybki start.

  3. Po zakończeniu publikowania program Visual Studio uruchomi aplikację w domyślnej przeglądarce internetowej.

    Dodano pamięć podręczną

    W poniższej tabeli opisano każdy link akcji z przykładowej aplikacji:

    Akcja opis
    Kliknięcie przycisku Nowe Tworzenie nowego zespołu.
    Play Season (Odtwarzaj sezon) Odtwarzanie sezonu gier, aktualizacja statystyk zespołu i czyszczenie nieaktualnych danych zespołu z pamięci podręcznej.
    Clear Cache Czyszczenie statystyk zespołu z pamięci podręcznej.
    List from Cache (Lista z pamięci podręcznej) Pobieranie statystyk zespołu z pamięci podręcznej. Jeśli brakuje pamięci podręcznej, załaduj statystyki z bazy danych i zapisz je w pamięci podręcznej następnym razem.
    Sorted Set from Cache (Zestaw posortowany z pamięci podręcznej) Pobieranie statystyk zespołu z pamięci podręcznej przy użyciu zestawu posortowanego. Jeśli brakuje pamięci podręcznej, załaduj statystyki z bazy danych i zapisz je w pamięci podręcznej przy użyciu posortowanego zestawu.
    Top 5 Teams from Cache (5 najlepszych zespołów z pamięci podręcznej) Pobieranie najlepszych 5 zespołów z pamięci podręcznej przy użyciu zestawu posortowanego. Jeśli brakuje pamięci podręcznej, załaduj statystyki z bazy danych i zapisz je w pamięci podręcznej przy użyciu posortowanego zestawu.
    Load from DB (Ładuj z bazy danych) Pobieranie statystyk zespołu z bazy danych.
    Rebuild DB (Odbuduj bazę danych) Odbudowywanie bazy danych i ponowne jej ładowanie z użyciem przykładowych danych zespołu.
    Edytuj / Szczegóły / Usuń Edytowanie zespołu, wyświetlanie szczegółów dla zespołu, usuwanie zespołu.

Wybierz niektóre akcje i poeksperymentuj z pobieraniem danych z różnych źródeł. Zwróć uwagę na różnice czasu, który jest potrzebny do realizacji różnych sposobów pobierania danych z bazy danych i pamięci podręcznej.

Czyszczenie zasobów

Po zakończeniu pracy z przykładową aplikacją samouczka możesz usunąć zasoby platformy Azure, aby zaoszczędzić koszty i zasoby. Wszystkie zasoby powinny znajdować się w tej samej grupie zasobów. Można je usunąć razem w jednej operacji, usuwając grupę zasobów. Instrukcje w tym artykule używały grupy zasobów o nazwie TestResources.

Ważne

Usunięcie grupy zasobów jest nieodwracalne i grupa zasobów oraz wszystkie zawarte w niej zasoby zostaną trwale usunięte. Uważaj, aby nie usunąć przypadkowo niewłaściwych zasobów lub grupy zasobów. Jeśli utworzono zasoby do hostowania tego przykładu wewnątrz istniejącej grupy zasobów, która zawiera zasoby, które chcesz zachować, możesz usunąć każdy zasób indywidualnie po lewej stronie.

  1. Zaloguj się do witryny Azure Portal i wybierz pozycję Grupy zasobów.

  2. Wpisz nazwę grupy zasobów w polu tekstowym Filtruj elementy....

  3. Wybierz pozycję ... po prawej stronie grupy zasobów i wybierz pozycję Usuń grupę zasobów.

    Delete

  4. Zobaczysz prośbę o potwierdzenie usunięcia grupy zasobów. Wpisz nazwę grupy zasobów, aby potwierdzić, a następnie wybierz pozycję Usuń.

    Po krótkim czasie grupa zasobów i wszystkie zawarte w niej zasoby zostaną usunięte.

Następne kroki

Jak skalować usługę Azure Cache for Redis