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

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 az Azure Cognitive Search és a Visual Studio használatával.

Ebben az oktatóanyagban megtanulhatja, hogyan:

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

Azt is megtudhatja, hogy milyen egyszerű a keresési hívás. A kódban szereplő fő utasítások a következő néhány sorba vannak á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 saját keresési szolgáltatásában az Adatok importálása gyorsútmutatón való lépéssel. 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övetkező leckékben tovább fejleszthet, hogy lapozást, nézeteket és beírás közbeni találatjavaslatokat is tartalmazzon.

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

1-alap-keresési-oldal (GitHub)

Előfeltételek

Keresési szolgáltatás létrehozása vagy meglévő 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 továbblépni, 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 másolatának létrehozásához.
A Visual Studio használatával keresse meg és nyissa meg a megoldást az alapszintű keresőoldalhoz ("1-basic-search-page"), majd válassza a Start elemet hibakeresés nélkül (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, amelyekkel szállodákat kereshet (például "wifi", "view", "bar", "parking"). Vizsgálja meg az eredményeket.

A kifinomultabb keresésekhez szükséges alapvető összetevők ebben az alkalmazásban találhatók. Ha még csak most ismerkedik a keresési fejlesztéssel, lépésről lépésre újra létrehozhatja ezt az alkalmazást a munkafolyamat megismeréséhez. A következő szakaszok bemutatják, hogyan.

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

Ha ezt a projektet az alapoktól szeretné létrehozni, és ezáltal megerősíteni az Azure Cognitive Search fogalmait, kezdje egy Visual Studio-projekttel.

A Visual Studióban válassza az Új>projekt lehetőséget, majd ASP.NET Core Web App (Model-View-Controller) lehetőséget.
Adjon egy nevet a projektnek, például a "FirstSearchApp" nevet, és állítsa be a helyet. Válassza a Következőlehetőséget.
Fogadja el a cél-keretrendszer, a hitelesítési típus és a HTTPS alapértelmezett értékét. Válassza a Create gombot.
Telepítse a klienskönyvtárat. Az Eszközök>NuGet-csomagkezelőben>a NuGet-csomagok kezelése megoldáshoz..., válassza a Tallózás lehetőséget , majd keressen rá az "azure.search.documents" kifejezésre. Telepítse az Azure.Search.Documentst (11-es vagy újabb verzió), elfogadva a licencszerződéseket és a függőségeket.

Az 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 aappsettings.json , és cserélje le az alapértelmezett sorokat a keresési szolgáltatás URL-címére (formátum 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éskulcsot.
```
{
    "SearchServiceUri": "<YOUR-SEARCH-SERVICE-URI>",
    "SearchServiceQueryApiKey": "<YOUR-SEARCH-SERVICE-API-KEY>"
}
```
A Megoldáskezelő ablakban jelölje ki a fájlt, és a Tulajdonságok területen módosítsa a Másolás a kimeneti könyvtárba beállítást Másolás, ha újabb.

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 adatközlésére szolgálnak az MVC (modell, nézet, vezérlő) architektúra használatával. Ezek a modellek általában a hozzáférés alatt álló adatok szerkezetét tükrözik.

Ebben a lépésben modellezi a keresési index adatstruktúráját, valamint a nézet-/vezérlők kommunikációjában használt keresési sztringet. A hotelek indexében 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 megjelenítése hierarchikus és beágyazott adatstruktúra. Mindegyik összetevő létrehozásához három osztályra lesz szükség.

A szálloda, cím és szoba osztályok összetett típusúként ismertek, ami az Azure Cognitive Search fontos funkciója. Az összetett típusok az osztályok és alosztályok számos szintjén lehetnek, és sokkal összetettebb adatstruktúrák ábrázolását teszik lehetővé, mint az egyszerű típusok (csak primitív tagokat tartalmazó osztály) használata.

A Megoldáskezelőben kattintson a jobb gombbal a Modellek> elemre, majd válassza a Hozzáadás>Új elem lehetőséget.

Válassza az Osztály lehetőséget , és nevezze el az elemet Hotel.cs. Cserélje le az Hotel.cs összes tartalmát a következő kódra. Figyelje meg az osztály cím és szoba tagjait; ezek a mezők maguk is osztályok, így nekik is szükségük lesz modellekre.

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 Cím osztályhoz, és elnevezi a fájl Address.cs. 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 ugyanezzel a eljárással hozza létre a Helyiség osztályt, és nevezse el a fájlt Room.cs.

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

Egy weboldal 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 mintá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 tartalmát teljes egészében, és építse újra a fájlt az alábbi 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 képeket a GitHub-projektből a projekt wwwroot/images mappájába.
Az Index.cshtml első sora az ügyfél (a 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 beírása általános gyakorlat, ezért a következő soroknak a következőknek kell lenniük:
```
@{
    ViewData["Title"] = "Home Page";
}
```
A címet követve adjon meg egy rövidesen létrehozott HTML-stíluslapra mutató hivatkozást.
```
<head>
    <link rel="stylesheet" href="~/css/hotels.css" />
</head>
```

A nézet törzse két használati esetet kezel. Először meg kell adnia egy üres oldalt 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étlődő 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 kiemeléssel).

Cserélje le az alapértelmezett kódot a következőre. Ennél részletesebben nem megyünk bele ebbe a fájlba, a stílusok szabványos HTML-formátumúak.

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 stíluslapfájlt hotels.css fájlként 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 elkészültek. Csak a vezérlő marad, hogy mindent összekössön.

Metódusok definiálása

Ebben a lépésben módosítsa a Kezdőlap-vezérlő tartalmát.

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

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 minden 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 fel paramétereket: ü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);
    }

Észlelje a aszinkron deklarációt a metódus, valamint a await hívást a RunQueryAsync számára. 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óanyagban később tesztelni fogsz a Hiba nézetet.

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

A RunQueryAsync metódus hozzáadása

Az 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, majd egy hívással kezdeményezheti ő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 egyezni a szállodai osztály tulajdonságnevével. Ha kihagyja a Kijelölés lehetőséget, a rendszer az összes felfedetlen mezőt visszaadja, ami nem hatékony lehet, ha csak az összes lehetséges mező egy részhalmaza érdekli.

A keresés aszinkron hívása a kérést ( searchText-ként modellezett) és a választ ( searchResult modellben) fogalmazza meg. A kód hibakeresése esetén a SearchResult osztály alkalmas töréspont beállítására, ha meg kell vizsgálnia a model.resultList tartalmát. Azt kell tapasztalnia, hogy ez intuitív, és 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 a "luxus" szinonimájaként kezelné az "öt csillagot", és visszaadná ezeket az eredményeket. A szinonimák támogatása az Azure Cognitive Searchben érhető el, de ez az oktatóanyag-sorozat nem foglalkozik ezzel.
Próbálja meg beírni a "forró" szót 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", "napfény", "kilátás", és bármi. Látni fogja, hogy az 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 a kívánt módon 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 írja be a Throw new Exception() sort. Ez a kivétel hibaüzenetet fog eredményezni a szöveg keresésekor.
Futtassa az alkalmazást, írja be a "sáv" kifejezést keresési szövegként, és kattintson a keresés ikonra. A kivételnek hiba né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 elemet , ha elégedett a hibakezeléssel.

Főbb tanulságok

Vegye figyelembe a projekt alábbi tanulságait:

Az Azure Cognitive Search-hívások tömörek, és könnyen értelmezhetők az eredmények.
Az aszinkron hívások kis fokú összetettséget adnak a vezérlőhöz, de az ajánlott eljárások közé tartoznak, mivel javítják a teljesítményt.
Ez az alkalmazás egyszerű szöveges keresést hajtott végre, amelyet a searchOptionsban beállított beállítások határoznak meg. Ez az egy osztály azonban számos olyan taggal tölthető fel, amelyek növelik a keresés kifinomultságát. 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 lapozást (oldalszámozás vagy végtelen görgetés) és automatikus kiegészítést/javaslatokat. Egyéb keresési lehetőségeket (például egy adott pont adott sugarán belüli szállodák földrajzi kereséseit) és a keresési eredmények sorrendjét is figyelembe veheti.

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

Utolsó frissítés időpontja: 2022-07-01