Tutorial: Erstellen Ihrer ersten Such-App in Azure Cognitive Search mit dem .NET SDK

Artikel
07/01/2022

In diesem Tutorial erfahren Sie, wie Sie eine Web-App erstellen, die Ergebnisse aus einem Suchindex mithilfe von Azure Cognitive Search und Visual Studio abfragt und zurückgibt.

In diesem Tutorial lernen Sie Folgendes:

Einrichten einer Entwicklungsumgebung
Modellieren von Datenstrukturen
Erstellen einer Webseite zum Erfassen von Abfrageeingaben und Anzeigen von Ergebnissen
Definieren einer Suchmethode
Testen der App

Außerdem wird beschrieben, wie einfach die Durchführung eines Suchaufrufs ist. Die wichtigen Anweisungen im Code sind in den folgenden wenigen Zeilen enthalten:

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

Mit einem einzigen Aufruf wird der Suchindex abgefragt, und die Ergebnisse werden zurückgegeben.

Übersicht

In diesem Tutorial wird „hotels-sample-index“ verwendet. Diesen Index können Sie in Ihrem eigenen Suchdienst ganz schnell selbst erstellen. Eine entsprechende Anleitung finden Sie in der Schnellstartanleitung zum Importieren von Daten. Der Index enthält fiktive Hoteldaten, die in jedem Suchdienst als integrierte Datenquelle verfügbar sind.

In der ersten Lektion dieses Tutorials werden eine grundlegende Abfragestruktur und eine Suchseite erstellt, die dann in den weiteren Lektionen mit Paginierung, Facetten und Vorschlagssuche versehen wird.

Eine fertige Version des Codes finden Sie im folgenden Projekt:

1-basic-search-page (GitHub)

Voraussetzungen

Neuer oder bereits vorhandener Suchdienst
Im Suchdienst gehosteter Beispielindex (hotels-sample).
Visual Studio
Azure.Cognitive.Search-Clientbibliothek (Version 11)

Installieren und Ausführen des Projekts von GitHub

Wenn Sie gleich mit einer funktionierenden App arbeiten möchten, führen Sie die Schritte unten und dann den vollständigen Code aus.

Beispiel auf GitHub: Erstellen der ersten App.
Wählen Sie im Stammordner die Option Code und dann Clone (Klonen) oder Download ZIP (ZIP herunterladen) aus, um eine private lokale Kopie des Projekts zu erstellen.
Navigieren Sie in Visual Studio zur Projektmappe mit der einfachen Suchseite („1-basic-search-page“), und öffnen Sie sie. Wählen Sie anschließend die Option Ohne Debuggen starten (oder drücken Sie F5), um das Programm zu erstellen und auszuführen.
Dabei handelt es sich um einen Hotelindex. Geben Sie also einige Wörter ein, die Sie bei einer Suche nach Hotels verwenden würden (z. B. „WiFi“, „View“, „Bar“, „Parking“). Überprüfen Sie die Ergebnisse.

Die wesentlichen Komponenten für komplexere Suchvorgänge sind in dieser App enthalten. Wenn Sie mit der Cognitive Search-Entwicklung noch nicht vertraut sind, können Sie diese Anwendung Schritt für Schritt nachbauen, um den Workflow zu erlernen. Die folgenden Abschnitte zeigen Ihnen, wie das geht.

Einrichten einer Entwicklungsumgebung

Beginnen Sie mit einem Visual Studio-Projekt, um dieses Projekt von Grund auf neu zu erstellen und so die Komponenten von Azure Cognitive Search noch besser kennen zu lernen.

Wählen Sie in Visual Studio Neu>Projekt und dann ASP.NET Core-Web App (Model View Controller).
Benennen Sie das Projekt, z. B. „FirstSearchApp“, und legen Sie den Speicherort fest. Klicken Sie auf Weiter.
Akzeptieren Sie die Standardeinstellungen für Zielframework, Authentifizierungstyp und HTTPS. Klicken Sie auf Erstellen.
Installieren der Clientbibliothek Wählen Sie Tools>NuGet-Paket-Manager>NuGet-Pakete für Lösung verwalten... und dann Durchsuchen aus. Suchen Sie anschließend nach „azure.search.documents“. Installieren Sie Azure.Search.Documents (Version 11 oder höher), und akzeptieren Sie die Lizenzverträge und die Abhängigkeiten.

Initialisieren von Azure Cognitive Search

Legen Sie in diesem Schritt den Endpunkt und den Zugriffsschlüssel für die Verbindung mit dem Suchdienst fest, der den Index „hotels-sample“ bereitstellt.

Öffnen Sie appsettings.json, und ersetzen Sie die Standardzeilen durch die Suchdienst-URL (im Format https://<service-name>.search.windows.net) sowie durch einen Administrator- oder Abfrage-API-Schlüssel Ihres Suchdiensts. Da Sie keinen Index erstellen oder aktualisieren müssen, können Sie für dieses Tutorial den Abfrageschlüssel verwenden.
```
{
    "SearchServiceUri": "<YOUR-SEARCH-SERVICE-URI>",
    "SearchServiceQueryApiKey": "<YOUR-SEARCH-SERVICE-API-KEY>"
}
```
Wählen Sie im Projektmappen-Explorer die Datei aus, und ändern Sie in „Eigenschaften“ die Einstellung In Ausgabeverzeichnis kopieren in Kopieren, wenn neuer.

Modellieren von Datenstrukturen

Modelle (C#-Klassen) werden verwendet, um für Daten die Kommunikation zwischen dem Client (View), dem Server (Controller) und auch der Azure-Cloud über die MVC-Architektur (Model, View, Controller) zu ermöglichen. Normalerweise spiegeln diese Modelle die Struktur der Daten wider, auf die zugegriffen wird.

In diesem Schritt erstellen Sie ein Modell der Datenstrukturen des Suchindexes und die Suchzeichenfolgen, die in der View-Controller-Kommunikation verwendet wird. Im Index „Hotels“ hat jedes Hotel viele Zimmer, und jedes Hotel verfügt über eine mehrteilige Adresse. Insgesamt wird ein Hotel durch eine hierarchische und verschachtelte Datenstruktur dargestellt. Sie benötigen drei Klassen, um die einzelnen Komponenten zu erstellen.

Die Klassen Hotel, Address, und Room werden als komplexe Typen bezeichnet. Dies ist ein wichtiges Feature von Azure Cognitive Search. Komplexe Typen können über viele Ebenen mit Klassen und Unterklassen verfügen und ermöglichen die Darstellung von deutlich komplexeren Datenstrukturen, als wenn einfache Typen (Klasse, die nur primitive Member enthält) verwendet werden.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Modelle>Hinzufügen>Neues Element.

Wählen Sie Klasse aus, und benennen Sie das Element „Hotel.cs“. Ersetzen Sie den gesamten Inhalt von „Hotel.cs“ durch den folgenden Code. Beachten Sie die Member Address und Room der Klasse. Da es sich bei diesen Feldern selbst um Klassen handelt, benötigen Sie auch hierfür Modelle.

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

Wiederholen Sie die gleichen Schritte zum Erstellen eines Modells für die Address-Klasse, und geben Sie der Datei den Namen „Address.cs“. Ersetzen Sie den Inhalt durch den folgenden Code.

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

Führen Sie den Prozess noch einmal durch, um die Room-Klasse zu erstellen, und geben Sie der Datei den Namen „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; }
    }
}

Das letzte Modell, das Sie in diesem Tutorial erstellen, ist die Klasse mit dem Namen SearchData. Diese stellt die Benutzereingabe (searchText) und die Ausgabe der Suche (resultList) dar. Der Typ der Ausgabe SearchResults<Hotel> ist entscheidend. Dieser Typ stimmt nämlich genau mit den Ergebnissen der Suche überein, und diesen Verweis müssen Sie an die Ansicht (View) übergeben. Ersetzen Sie die Standardvorlage durch den folgenden Code.
```
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;
    }
}
```

Erstellen einer Webseite

Projektvorlagen verfügen über eine Reihe von Clientansichten, die sich im Ordner Ansichten befinden. Die Ansichten richten sich jeweils nach der Version von Core .NET, die Sie verwenden (in diesem Beispiel 3.1). In diesem Tutorial ändern Sie Index.cshtml so, dass die Elemente einer Suchseite enthalten sind.

Löschen Sie den gesamten Inhalt von „Index.cshtml“, und erstellen Sie die Datei in den folgenden Schritten neu.

Das Tutorial verwendet zwei kleine Bilder in der Ansicht: ein Azure-Logo und ein Lupensymbol („azure-logo.png“ und „search.png“). Kopieren Sie die Bilder aus dem GitHub-Projekt in den Ordner wwwroot/images in Ihrem Projekt.
In der ersten Zeile der Datei „Index.cshtml“ sollte auf das Modell verwiesen werden, das für die Kommunikation der Daten zwischen dem Client (View) und dem Server (Controller) verwendet wird. Dies ist das zuvor erstellte Modell SearchData. Fügen Sie diese Zeile der Datei „Index.cshtml“ hinzu.
```
@model FirstAzureSearchApp.Models.SearchData
```
Die Standardmethode besteht darin, einen Titel für die Ansicht einzugeben. Die nächsten Zeilen sollten also wie folgt lauten:
```
@{
    ViewData["Title"] = "Home Page";
}
```
Geben Sie nach dem Titel einen Verweis auf ein HTML-Stylesheet ein, das Sie in Kürze erstellen.
```
<head>
    <link rel="stylesheet" href="~/css/hotels.css" />
</head>
```

Der Hauptteil der Ansicht behandelt zwei Anwendungsfälle. Zuerst muss bei der ersten Verwendung eine leere Seite bereitgestellt werden, bevor Suchtext eingegeben wird. Zweitens müssen zusätzlich zum Textfeld für die Suche die Ergebnisse verarbeitet werden, damit diese vom Benutzer mehrfach genutzt werden können.

Zum Behandeln dieser beiden Fälle müssen Sie überprüfen, ob das für die Ansicht bereitgestellte Modell NULL ist. Ein NULL-Modell gibt den ersten Anwendungsfall (die erste Ausführung der App) an. Fügen Sie der Datei „Index.cshtml“ Folgendes hinzu, und lesen Sie sich die Kommentare durch.

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

Fügen Sie das Stylesheet hinzu. Wählen Sie in Visual Studio Datei>Neu>Datei und dann Stylesheet aus (wobeiAllgemein ausgewählt ist).

Ersetzen Sie den Standardcode durch Folgendes. Wir gehen auf diese Datei nicht näher ein. Bei den Formaten handelt es sich um HTML-Standardformate.

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

Speichern Sie die Stylesheetdatei als „hotels.css“ im Ordner wwwroot/css neben der Standarddatei „site.css“.

Unsere Ansicht ist nun fertig. An diesem Punkt sind die Modelle und die Ansichten vollständig. Jetzt muss nur noch der Controller erstellt werden, um alles zu verbinden.

Methoden definieren

In diesem Schritt ändern Sie den Inhalt von Home Controller.

Öffnen Sie die Datei „HomeController.cs“, und ersetzen Sie die using-Anweisungen durch Folgendes.

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;

Hinzufügen von Index-Methoden

In einer MVC-App ist die Index() -Methode eine Methode für die Standardaktion eines Controllers. Sie öffnet die HTML-Indexseite. Die Standardmethode, die keine Parameter akzeptiert, wird in diesem Tutorial für den Anwendungsfall des Anwendungsstarts verwendet, d. h. dem Rendern einer leeren Suchseite.

In diesem Abschnitt erweitern wir die-Methode, um einen zweiten Anwendungsfall zu unterstützen: das Rendern der Seite, wenn ein Benutzer den Suchtext eingegeben hat. Um diesen Fall zu unterstützen, wird die index-Methode so erweitert, dass sie ein Modell als Parameter akzeptiert.

Fügen Sie die folgende Methode nach der Index() -Standardmethode hinzu.

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

Achten Sie auf die async-Deklaration der Methode und den await-Aufruf von RunQueryAsync. Diese Schlüsselwörter sorgen dafür, dass Aufrufe asynchron erfolgen, sodass Threads auf dem Server nicht blockieren.

Für den catch-Block wird das erstellte Standardfehlermodell verwendet.

Fehlerbehandlung und andere Standardansichten und -methoden

Je nach verwendeter .NET Core-Version wird jeweils eine andere Gruppe von Standardansichten erstellt. Bei .NET Core 3.1 lauten die Standardansichten beispielsweise „Index“, „Privacy“ und „Error“. Sie können diese Standardseiten beim Ausführen der App anzeigen und dann untersuchen, wie sie im Controller verarbeitet werden.

Sie testen die Ansicht „Error“ zu einem späteren Zeitpunkt dieses Tutorials.

Im GitHub-Beispiel werden die nicht verwendeten Ansichten und die zugehörigen Aktionen gelöscht.

Hinzufügen der RunQueryAsync-Methode

Der Azure Cognitive Search-Aufruf ist in unserer RunQueryAsync-Methode gekapselt.

Fügen Sie zuerst einige statische Variablen zum Einrichten des Azure-Diensts und einen Aufruf für deren Initialisierung hinzu.

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

Fügen Sie nun die eigentliche RunQueryAsync-Methode hinzu.
```
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);
}
```
Bei dieser Methode stellen Sie zuerst sicher, dass unsere Azure-Konfiguration initiiert wurde, und legen Sie dann einige Suchoptionen fest. Die Option Select gibt an, welche Felder in den Ergebnissen zurückgegeben werden, und entspricht daher den Eigenschaftsnamen in der hotel-Klasse. Wenn Sie Select weglassen, werden alle nicht ausgeblendeten Felder zurückgegeben. Dies ist nicht effizient, wenn nur ein Teil der verfügbaren Felder relevant ist.

Der asynchrone Suchvorgang formuliert die Anforderung (modelliert als searchText) und die Antwort (modelliert als searchResult). Wenn Sie diesen Code debuggen, ist die SearchResult-Klasse eine gute Wahl für das Festlegen eines Breakpoints, um den Inhalt von model.resultList zu untersuchen. Dies ist ein intuitiver Vorgang, bei dem Sie nur die gewünschten Daten und nicht noch viele weitere Informationen zusätzlich erhalten.

Testen der App

Überprüfen wir nun, ob die App richtig ausgeführt wird.

Wählen Sie Debuggen>Ohne Debuggen starten aus, oder drücken Sie F5. Wenn die App erwartungsgemäß ausgeführt wird, sollten Sie die Ausgangsindexansicht erhalten.
Geben Sie eine Abfragezeichenfolge ein, z. B. „beach“ (oder anderen Text, der Ihnen gerade einfällt), und klicken Sie auf das Suchsymbol, um die Anforderung zu senden.
Versuchen Sie, „five star“ einzugeben. Beachten Sie, dass diese Abfrage keine Ergebnisse zurückgibt. Bei einer anspruchsvolleren Suche würde „five star“ als Synonym für „luxury“ erkannt werden, und die entsprechenden Ergebnisse würden angezeigt werden. Unterstützung für Synonyme ist in Azure Cognitive Search verfügbar, wird in dieser Tutorialreihe jedoch nicht behandelt.
Versuchen Sie, „hot“ als Suchtext einzugeben. Es werden keine Einträge zurückgegeben, die das Wort „hotel“ enthalten. Bei unserer Suche wird nur nach ganzen Wörtern gesucht, aber es werden trotzdem einige Ergebnisse zurückgegeben.
Versuchen Sie es mit anderen Wörtern: „pool“, „sunshine“, „view“ usw. Dies ist eine sehr einfache Funktion von Azure Cognitive Search, die aber trotzdem in überzeugender Manier ausgeführt wird.

Testen von Edgebedingungen und -fehlern

Es ist wichtig zu überprüfen, ob unsere Features für die Fehlerbehandlung wie gewünscht funktionieren, auch wenn gerade keine Fehler zu beobachten sind.

Geben Sie in der Index-Methode nach dem try { -Aufruf die Zeile Throw new Exception() ein. Diese Ausnahme erzwingt einen Fehler, wenn Sie nach Text suchen.
Führen Sie die App aus, geben Sie „bar“ als Suchtext ein, und klicken Sie auf das Suchsymbol. Die Ausnahme sollte in der Fehleransicht angezeigt werden.

Wichtig

Es wird als Sicherheitsrisiko angesehen, interne Fehlernummern auf Fehlerseiten zurückzugeben. Falls Ihre App für die allgemeine Nutzung bestimmt ist, befolgen Sie die sicheren und bewährten Methoden dazu, was beim Auftreten eines Fehlers zurückgegeben werden soll.
Entfernen Sie Throw new Exception(), wenn Sie der Meinung sind, dass die Fehlerbehandlung wie gewünscht durchgeführt wird.

Wesentliche Punkte

Beachten Sie die folgenden Erkenntnisse aus diesem Projekt:

Ein Azure Cognitive Search-Aufruf ist kompakt, und es ist einfach, die Ergebnisse zu interpretieren.
Mit asynchronen Aufrufen wird dem Controller ein geringer Grad an Komplexität hinzugefügt, aber dies ist die bewährte Methode, die die Leistung steigert.
Mit dieser App wurde eine einfache Textsuche durchgeführt, die gemäß der Einrichtung von searchOptions definiert wurde. Diese eine Klasse kann aber mit vielen Membern aufgefüllt werden, die der Erweiterung der Suche dienen. Mit etwas mehr Arbeit können Sie diese App erheblich leistungsstärker machen.

Nächste Schritte

Um die Benutzerfreundlichkeit zu erhöhen, fügen Sie weitere Features hinzu, insbesondere eine Paginierung (entweder Seitenzahlen oder unendliches Scrollen) und AutoVervollständigen/Vorschläge. Außerdem sollten Sie die Verwendung von anderen Suchoptionen (z. B. geografische Suchen nach Hotels innerhalb eines bestimmten Radius um einen bestimmten Punkt) und die Sortierung von Suchergebnissen erwägen.

Diese nächsten Schritte werden in den folgenden Tutorials behandelt. Wir beginnen mit der Paginierung.

C#-Tutorial: Suchergebnispaginierung – Azure Cognitive Search