Oktatóanyag: Az első keresőalkalmazás létrehozása Azure Cognitive Search a .NET SDK használatával

Cikk
07/01/2022

Ez az oktatóanyag bemutatja, hogyan hozhat létre olyan webalkalmazást, amely lekérdezi és visszaadja az eredményeket egy keresési indexből a Azure Cognitive Search és a Visual Studio használatával.

Ebből az oktatóanyagból az alábbiakat sajátíthatja el:

Fejlesztési környezet beállítása
Adatstruktúrák modellezése
Weblap létrehozása a lekérdezési bemenetek gyűjtéséhez és az eredmények megjelenítéséhez
Keresési módszer definiálása
Az alkalmazás tesztelése

Azt is megtudhatja, hogy milyen egyszerű egy keresési hívás. A kódban szereplő fő utasítások a következő néhány sorba vannak beágyazva:

var options = new SearchOptions()
{
    // The Select option specifies fields for the result set
    options.Select.Add("HotelName");
    options.Select.Add("Description");
};

var searchResult = await _searchClient.SearchAsync<Hotel>(model.searchText, options).ConfigureAwait(false);
model.resultList = searchResult.Value.GetResults().ToList();

Csak egy hívás lekérdezi a keresési indexet, és eredményeket ad vissza.

Áttekintés

Ez az oktatóanyag a hotels-sample-indexet használja, amelyet gyorsan létrehozhat a saját keresési szolgáltatásában az Adatok importálása rövid útmutató lépéseinek végiglépésével. Az index fiktív szállodaadatokat tartalmaz, amely minden keresési szolgáltatásban beépített adatforrásként érhető el.

Az oktatóanyag első leckéje egy egyszerű lekérdezési struktúrát és keresési oldalt hoz létre, amelyet a későbbi leckékben továbbfejleszthet, hogy a lapozást, a aspektusokat és a típusalapú felületet is magában foglalja.

A kód egy kész verziója a következő projektben található:

1-basic-search-page (GitHub)

Előfeltételek

Meglévő keresési szolgáltatás létrehozása vagy keresése.
A keresési szolgáltatásban üzemeltetett mintaindex (hotels-sample-index).
Visual Studio
Azure.Cognitive.Search ügyfélkódtár (11-es verzió)

A projekt telepítése és futtatása a GitHubról

Ha egy működő alkalmazásra szeretne ugrani, az alábbi lépéseket követve töltse le és futtassa a kész kódot.

Keresse meg a mintát a GitHubon: Az első alkalmazás létrehozása.
A gyökérmappában válassza a Kód, majd a Klónozás vagy a ZIP letöltése lehetőséget a projekt privát helyi példányának létrehozásához.
A Visual Studióval keresse meg és nyissa meg az alapszintű keresőoldal (1-basic-search-page) megoldását, majd válassza a Start hibakeresés nélkül lehetőséget (vagy nyomja le az F5 billentyűt) a program létrehozásához és futtatásához.
Ez egy szállodák indexe, ezért írjon be néhány szót, amelyeket a szállodák kereséséhez használhat (például "wifi", "view", "bar", "parking"). Vizsgálja meg az eredményeket.

A kifinomultabb keresések alapvető összetevői ebben az alkalmazásban találhatók. Ha még csak most ismerkedik a keresésfejlesztéssel, lépésről lépésre újra létrehozhatja ezt az alkalmazást a munkafolyamat megismeréséhez. Az alábbi szakaszok bemutatják, hogyan.

Fejlesztési környezet beállítása

Ha ezt a projektet teljesen új alapokra szeretné hozni, és így meg szeretné erősíteni a Azure Cognitive Search fogalmát, kezdje egy Visual Studio-projekttel.

A Visual Studióban válassza az Új>projekt lehetőséget, majd ASP.NET Core webalkalmazást (Model-View-Controller).
Adjon nevet a projektnek, például "FirstSearchApp", és állítsa be a helyet. Kattintson a Tovább gombra.
Fogadja el a cél-keretrendszer, a hitelesítési típus és a HTTPS alapértelmezett értékét. Válassza a Létrehozás lehetőséget.
Telepítse az ügyfélkódtárat. Az EszközökNuGet Package Manager>Manage NuGet Packages for Solution... (NuGet-csomagok> kezelése megoldáshoz) területen válassza a Tallózás lehetőséget, majd keressen rá az "azure.search.documents" kifejezésre. Telepítse az Azure.Search.Documentsot (11-es vagy újabb verzió), elfogadva a licencszerződéseket és a függőségeket.

Azure Cognitive Search inicializálása

Ebben a lépésben állítsa be a végpontot és a hozzáférési kulcsot a szállodai mintaindexet biztosító keresési szolgáltatáshoz való csatlakozáshoz.

Nyissa meg az appsettings.json fájlt, és cserélje le az alapértelmezett sorokat a keresési szolgáltatás URL-címére (formátumban https://<service-name>.search.windows.net) és a keresési szolgáltatás rendszergazdai vagy lekérdezési API-kulcsára . Mivel nem kell indexet létrehoznia vagy frissítenie, ehhez az oktatóanyaghoz használhatja a lekérdezési kulcsot.
```
{
    "SearchServiceUri": "<YOUR-SEARCH-SERVICE-URI>",
    "SearchServiceQueryApiKey": "<YOUR-SEARCH-SERVICE-API-KEY>"
}
```
A Megoldáskezelő válassza ki a fájlt, majd a Tulajdonságok területen módosítsa a Másolás kimeneti könyvtárra beállítást Másolás, ha újabb értékre.

Adatstruktúrák modellezése

A modellek (C#-osztályok) az ügyfél (a nézet), a kiszolgáló (a vezérlő) és az Azure-felhő közötti adatátvitelre szolgálnak az MVC (modell, nézet, vezérlő) architektúra használatával. Ezek a modellek általában az elérni kívánt adatok struktúráját tükrözik.

Ebben a lépésben modellezi a keresési index adatstruktúráját, valamint a megtekintési/vezérlői kommunikációban használt keresési sztringet. A hotelindexben minden szálloda több szobával rendelkezik, és minden szálloda többrészes címmel rendelkezik. Összességében a szálloda teljes ábrázolása hierarchikus és beágyazott adatstruktúra. Az egyes összetevők létrehozásához három osztályra lesz szükség.

A Hotel, a Address és a Room osztályokat összetett típusnak nevezzük, amely a Azure Cognitive Search egyik fontos jellemzője. Az összetett típusok számos osztály- és alosztályszintet tartalmazhatnak, és sokkal összetettebb adatstruktúrák ábrázolását teszik lehetővé, mint egyszerű típusok (csak primitív tagokat tartalmazó osztály) használata esetén.

A Megoldáskezelő kattintson a jobb gombbal a Modellek>Új elemhozzáadása> elemre.

Válassza az Osztály lehetőséget, és nevezze el a Hotel.cs elemet. Cserélje le a Hotel.cs teljes tartalmát az alábbi kódra. Figyelje meg, hogy az osztály Cím és Helyiség tagjai, ezek a mezők maguk az osztályok, így ezekhez is modellekre lesz szüksége.

using Azure.Search.Documents.Indexes;
using Azure.Search.Documents.Indexes.Models;
using Microsoft.Spatial;
using System;
using System.Text.Json.Serialization;

namespace FirstAzureSearchApp.Models
{
    public partial class Hotel
    {
        [SimpleField(IsFilterable = true, IsKey = true)]
        public string HotelId { get; set; }

        [SearchableField(IsSortable = true)]
        public string HotelName { get; set; }

        [SearchableField(AnalyzerName = LexicalAnalyzerName.Values.EnLucene)]
        public string Description { get; set; }

        [SearchableField(AnalyzerName = LexicalAnalyzerName.Values.FrLucene)]
        [JsonPropertyName("Description_fr")]
        public string DescriptionFr { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string Category { get; set; }

        [SearchableField(IsFilterable = true, IsFacetable = true)]
        public string[] Tags { get; set; }

        [SimpleField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public bool? ParkingIncluded { get; set; }

        [SimpleField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public DateTimeOffset? LastRenovationDate { get; set; }

        [SimpleField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public double? Rating { get; set; }

        public Address Address { get; set; }

        [SimpleField(IsFilterable = true, IsSortable = true)]
        public GeographyPoint Location { get; set; }

        public Room[] Rooms { get; set; }
    }
}

Ismételje meg ugyanazt a folyamatot, amikor létrehoz egy modellt a Address osztályhoz, és elnevezi a address.cs fájlt. Cserélje le a tartalmat a következőre.

using Azure.Search.Documents.Indexes;

namespace FirstAzureSearchApp.Models
{
    public partial class Address
    {
        [SearchableField]
        public string StreetAddress { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string City { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string StateProvince { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string PostalCode { get; set; }

        [SearchableField(IsFilterable = true, IsSortable = true, IsFacetable = true)]
        public string Country { get; set; }
    }
}

És ismét kövesse ugyanezt a folyamatot a Room osztály létrehozásához, a Room.cs fájl elnevezésével.

using Azure.Search.Documents.Indexes;
using Azure.Search.Documents.Indexes.Models;
using System.Text.Json.Serialization;

namespace FirstAzureSearchApp.Models
{
    public partial class Room
    {
        [SearchableField(AnalyzerName = LexicalAnalyzerName.Values.EnMicrosoft)]
        public string Description { get; set; }

        [SearchableField(AnalyzerName = LexicalAnalyzerName.Values.FrMicrosoft)]
        [JsonPropertyName("Description_fr")]
        public string DescriptionFr { get; set; }

        [SearchableField(IsFilterable = true, IsFacetable = true)]
        public string Type { get; set; }

        [SimpleField(IsFilterable = true, IsFacetable = true)]
        public double? BaseRate { get; set; }

        [SearchableField(IsFilterable = true, IsFacetable = true)]
        public string BedOptions { get; set; }

        [SimpleField(IsFilterable = true, IsFacetable = true)]
        public int SleepsCount { get; set; }

        [SimpleField(IsFilterable = true, IsFacetable = true)]
        public bool? SmokingAllowed { get; set; }

        [SearchableField(IsFilterable = true, IsFacetable = true)]
        public string[] Tags { get; set; }
    }
}

Az oktatóanyagban utoljára létrehozott modell egy SearchData nevű osztály, amely a felhasználó bemenetét (searchText) és a keresés kimenetét (resultList) jelöli. A kimenet típusa kritikus, SearchResults<Hotel>, mivel ez a típus pontosan megfelel a keresés eredményeinek, és ezt a hivatkozást át kell adnia a nézetnek. Cserélje le az alapértelmezett sablont a következő kódra.
```
using Azure.Search.Documents.Models;

namespace FirstAzureSearchApp.Models
{
    public class SearchData
    {
        // The text to search for.
        public string searchText { get; set; }

        // The list of results.
        public SearchResults<Hotel> resultList;
    }
}
```

Weblap létrehozása

A Projektsablonok a Nézetek mappában található számos ügyfélnézetet is tartalmazza. A pontos nézetek a használt Core .NET-verziótól függenek (ebben a példában a 3.1-es verziót használjuk). Ebben az oktatóanyagban úgy fogja módosítani az Index.cshtml fájlt, hogy tartalmazza a keresési oldal elemeit.

Törölje az Index.cshtml teljes tartalmát, és építse újra a fájlt a következő lépésekben.

Az oktatóanyag két kis képet használ a nézetben: egy Azure-emblémát és egy keresőnagyító ikont (azure-logo.png és search.png). Másolja át a GitHub-projekt képeit a projekt wwwroot/images mappájába.
Az Index.cshtml első sora az ügyfél (nézet) és a kiszolgáló (a vezérlő) közötti adatközléssel kapcsolatos modellre kell hivatkoznia, amely a korábban létrehozott SearchData modell. Adja hozzá ezt a sort az Index.cshtml fájlhoz.
```
@model FirstAzureSearchApp.Models.SearchData
```
A nézet címének megadása szokásos eljárás, ezért a következő soroknak a következőknek kell lenniük:
```
@{
    ViewData["Title"] = "Home Page";
}
```
A cím után adjon meg egy hivatkozást egy HTML-stíluslapra, amelyet hamarosan létre fog hozni.
```
<head>
    <link rel="stylesheet" href="~/css/hotels.css" />
</head>
```

A nézet törzse két használati esetet kezel. Először egy üres oldalt kell megadnia az első használatkor, mielőtt bármilyen keresési szöveget beír. Másodszor, a keresési szövegmezőn kívül az ismételt lekérdezések eredményeit is kezelnie kell.

Mindkét eset kezeléséhez ellenőriznie kell, hogy a nézethez megadott modell null értékű-e. A null értékű modell az első használati esetet (az alkalmazás kezdeti futtatását) jelzi. Adja hozzá a következőket az Index.cshtml fájlhoz, és olvassa el a megjegyzéseket.

<body>
<h1 class="sampleTitle">
    <img src="~/images/azure-logo.png" width="80" />
    Hotels Search
</h1>

@using (Html.BeginForm("Index", "Home", FormMethod.Post))
{
    // Display the search text box, with the search icon to the right of it.
    <div class="searchBoxForm">
        @Html.TextBoxFor(m => m.searchText, new { @class = "searchBox" }) <input class="searchBoxSubmit" type="submit" value="">
    </div>

    @if (Model != null)
    {
        // Show the result count.
        <p class="sampleText">
            @Model.resultList.TotalCount Results
        </p>

        var results = Model.resultList.GetResults().ToList();

        @for (var i = 0; i < results.Count; i++)
        {
            // Display the hotel name and description.
            @Html.TextAreaFor(m => results[i].Document.HotelName, new { @class = "box1" })
            @Html.TextArea($"desc{i}", results[i].Document.Description, new { @class = "box2" })
        }
    }
}
</body>

Adja hozzá a stíluslapot. A Visual Studióban azÚj>fájl fájlban> válassza a Stíluslap lehetőséget (az Általános elem ki van emelve).

Cserélje le az alapértelmezett kódot a következőre. Ezt a fájlt nem fogjuk részletesebben beszkenni, a stílusok szabványos HTML-nek számítanak.

textarea.box1 {
    width: 648px;
    height: 30px;
    border: none;
    background-color: azure;
    font-size: 14pt;
    color: blue;
    padding-left: 5px;
}

textarea.box2 {
    width: 648px;
    height: 100px;
    border: none;
    background-color: azure;
    font-size: 12pt;
    padding-left: 5px;
    margin-bottom: 24px;
}

.sampleTitle {
    font: 32px/normal 'Segoe UI Light',Arial,Helvetica,Sans-Serif;
    margin: 20px 0;
    font-size: 32px;
    text-align: left;
}

.sampleText {
    font: 16px/bold 'Segoe UI Light',Arial,Helvetica,Sans-Serif;
    margin: 20px 0;
    font-size: 14px;
    text-align: left;
    height: 30px;
}

.searchBoxForm {
    width: 648px;
    box-shadow: 0 0 0 1px rgba(0,0,0,.1), 0 2px 4px 0 rgba(0,0,0,.16);
    background-color: #fff;
    display: inline-block;
    border-collapse: collapse;
    border-spacing: 0;
    list-style: none;
    color: #666;
}

.searchBox {
    width: 568px;
    font-size: 16px;
    margin: 5px 0 1px 20px;
    padding: 0 10px 0 0;
    border: 0;
    max-height: 30px;
    outline: none;
    box-sizing: content-box;
    height: 35px;
    vertical-align: top;
}

.searchBoxSubmit {
    background-color: #fff;
    border-color: #fff;
    background-image: url(/images/search.png);
    background-repeat: no-repeat;
    height: 20px;
    width: 20px;
    text-indent: -99em;
    border-width: 0;
    border-style: solid;
    margin: 10px;
    outline: 0;
}

Mentse a stylesheet fájlt hotels.css néven a wwwroot/css mappába az alapértelmezett site.css fájl mellett.

Ez befejezi a nézetünket. Ezen a ponton a modellek és a nézetek is befejeződnek. Csak a kontroller marad, hogy mindent összekössünk.

Metódusok definiálása

Ebben a lépésben módosítsa a beállítást az Otthoni vezérlő tartalmára.

Nyissa meg a HomeController.cs fájlt, és cserélje le a using utasításokat a következőre.

using Azure;
using Azure.Search.Documents;
using Azure.Search.Documents.Indexes;
using FirstAzureSearchApp.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;

Indexelési metódusok hozzáadása

Az MVC-alkalmazásokban az Index() metódus bármely vezérlő alapértelmezett műveletmetódusa. Megnyitja az index HTML-oldalát. Ebben az oktatóanyagban az alkalmazás indítási használati esete az alapértelmezett metódust használja, amely nem vesz igénybe paramétereket: egy üres keresési oldal megjelenítése.

Ebben a szakaszban kiterjesztjük a metódust egy második használati eset támogatására: a lap megjelenítésére, amikor egy felhasználó keresési szöveget adott meg. Az eset támogatásához az indexmetódus ki van terjesztve, hogy egy modellt paraméterként használjon.

Adja hozzá a következő metódust az alapértelmezett Index() metódus után.

    [HttpPost]
    public async Task<ActionResult> Index(SearchData model)
    {
        try
        {
            // Ensure the search string is valid.
            if (model.searchText == null)
            {
                model.searchText = "";
            }

            // Make the Azure Cognitive Search call.
            await RunQueryAsync(model);
        }

        catch
        {
            return View("Error", new ErrorViewModel { RequestId = "1" });
        }
        return View(model);
    }

Figyelje meg a metódus aszinkron deklarációját és a RunQueryAsyncvárakozó hívását. Ezek a kulcsszavak gondoskodnak az aszinkron hívásokról, és így elkerülik a szálak blokkolását a kiszolgálón.

A fogási blokk a létrehozott alapértelmezett hibamodellt használja.

Figyelje meg a hibakezelést és az egyéb alapértelmezett nézeteket és metódusokat

Attól függően, hogy a .NET Core melyik verzióját használja, a rendszer kissé eltérő alapértelmezett nézeteket hoz létre. A .NET Core 3.1 alapértelmezett nézetei az Index, az Adatvédelem és a Hiba. Az alkalmazás futtatásakor megtekintheti ezeket az alapértelmezett lapokat, és megvizsgálhatja, hogyan kezeli őket a vezérlő.

Az oktatóanyag későbbi részében tesztelni fogja a Hiba nézetet.

A GitHub-mintában a nem használt nézetek és a hozzájuk tartozó műveletek törlődnek.

A RunQueryAsync metódus hozzáadása

A Azure Cognitive Search hívás a RunQueryAsync metódusba van beágyazva.

Először adjon hozzá néhány statikus változót az Azure-szolgáltatás beállításához, és hozzon létre egy hívást, amely elindítja őket.

    private static SearchClient _searchClient;
    private static SearchIndexClient _indexClient;
    private static IConfigurationBuilder _builder;
    private static IConfigurationRoot _configuration;

    private void InitSearch()
    {
        // Create a configuration using appsettings.json
        _builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
        _configuration = _builder.Build();

        // Read the values from appsettings.json
        string searchServiceUri = _configuration["SearchServiceUri"];
        string queryApiKey = _configuration["SearchServiceQueryApiKey"];

        // Create a service and index client.
        _indexClient = new SearchIndexClient(new Uri(searchServiceUri), new AzureKeyCredential(queryApiKey));
        _searchClient = _indexClient.GetSearchClient("hotels");
    }

Most adja hozzá magát a RunQueryAsync metódust.
```
private async Task<ActionResult> RunQueryAsync(SearchData model)
{
    InitSearch();

    var options = new SearchOptions() 
    { 
        IncludeTotalCount = true
    };

    // Enter Hotel property names into this list so only these values will be returned.
    // If Select is empty, all values will be returned, which can be inefficient.
    options.Select.Add("HotelName");
    options.Select.Add("Description");

    // For efficiency, the search call should be asynchronous, so use SearchAsync rather than Search.
    model.resultList = await _searchClient.SearchAsync<Hotel>(model.searchText, options).ConfigureAwait(false);          

    // Display the results.
    return View("Index", model);
}
```
Ebben a módszerben először győződjön meg arról, hogy az Azure-konfiguráció elindul, majd adjon meg néhány keresési lehetőséget. A Kiválasztás beállítás megadja, hogy mely mezőket kell visszaadni az eredményekben, és így egyeznie kell a szállodai osztályban lévő tulajdonságnevekkel. Ha kihagyja a Kiválasztás lehetőséget, a rendszer az összes felfedetlen mezőt visszaadja, ami nem hatékony, ha csak az összes lehetséges mező egy részhalmaza érdekli.

A keresési aszinkron hívás a kérést ( searchTextként modellezett) és a választ ( searchResult modellben) fogalmazza meg. Ha hibakeresést végez a kódon, a SearchResult osztály jó választás töréspont beállítására, ha meg kell vizsgálnia a model.resultList tartalmát. Azt kell tapasztalnia, hogy intuitív, csak a kért adatokat adja meg, és nem sok mást.

Az alkalmazás tesztelése

Most ellenőrizzük, hogy az alkalmazás megfelelően fut-e.

Válassza a Hibakeresés>indítása hibakeresés nélkül lehetőséget, vagy nyomja le az F5 billentyűt. Ha az alkalmazás a várt módon fut, a kezdeti Index nézetet kell kapnia.
Adjon meg egy lekérdezési sztringet, például "strand" (vagy bármilyen szöveg, amely eszébe jut), és kattintson a keresés ikonra a kérés elküldéséhez.
Próbálja meg beírni az "öt csillag" szót. Figyelje meg, hogy ez a lekérdezés nem ad vissza eredményt. Egy kifinomultabb keresés az "ötcsillagos" kifejezést a "luxus" szinonimájaként kezelné, és visszaadná ezeket az eredményeket. A szinonimák támogatása Azure Cognitive Search érhető el, de ez az oktatóanyag-sorozat nem foglalkozik ezzel.
Próbálja meg beírni a "gyakori elérésű" kifejezést keresési szövegként. Nem ad vissza olyan bejegyzéseket, amelyben a "hotel" szó szerepel. A keresés csak a teljes szavakat keresi, bár néhány találatot ad vissza.
Próbálkozzon más szavakkal: "medence", "napsütés", "nézet", és bármi. Látni fogja, Azure Cognitive Search a legegyszerűbb, de mégis meggyőző szinten működik.

Peremhálózati feltételek és hibák tesztelése

Fontos ellenőrizni, hogy a hibakezelési funkciók megfelelően működnek-e, még akkor is, ha a dolgok tökéletesen működnek.

Az Index metódusban a try { hívás után adja meg az Új kivétel() elvetése sort. Ez a kivétel hibát jelez a szöveg keresésekor.
Futtassa az alkalmazást, írja be a "sáv" kifejezést keresési szövegként, majd kattintson a keresés ikonra. A kivételnek hibanézetet kell eredményeznie.

Fontos

Biztonsági kockázatnak számít, ha belső hibaszámokat ad vissza a hibalapokon. Ha az alkalmazás általános használatra készült, kövesse a biztonsági ajánlott eljárásokat, hogy mit kell visszaadni hiba esetén.
Távolítsa el az Új kivétel() elvetése lehetőséget, ha elégedett a hibakezeléssel.

Legfontosabb ismeretek

Vegye figyelembe a projekt alábbi tanulságait:

A Azure Cognitive Search hívás tömör, és könnyen értelmezhető az eredmény.
Az aszinkron hívások kis mértékű összetettséggel egészíthetik ki a vezérlőt, de ez az ajánlott eljárás, amely javítja a teljesítményt.
Ez az alkalmazás egyszerű szöveges keresést hajtott végre, amelyet a searchOptionsban beállítottak. Ez az egy osztály azonban számos olyan taggal tölthető fel, amelyek kifinomultan hatnak a keresésre. Egy kicsit több munkával jelentősen hatékonyabbá teheti ezt az alkalmazást.

Következő lépések

A felhasználói élmény javítása érdekében adjon hozzá további funkciókat, például a lapozást (oldalszámozás vagy végtelen görgetés) és az automatikus kiegészítést/javaslatokat. Más keresési lehetőségeket is figyelembe vehet (például egy adott pont adott sugarán belüli szállodákban végzett földrajzi kereséseket) és a keresési eredmények sorrendjét.

Ezeket a következő lépéseket a további oktatóanyagok ismertetik. Kezdjük a lapozással.

C# oktatóanyag: Keresési eredmények lapozása – Azure Cognitive Search