Megosztás a következőn keresztül:

HTTP-kérések létrehozása a HttpClient-osztálysal

Ebből a cikkből megtudhatja, hogyan hozhat létre HTTP-kéréseket, és hogyan kezelheti a válaszokat a HttpClient osztálysal.

Fontos

A cikkben szereplő összes PÉLDA HTTP-kérés az alábbi URL-címek egyikét célozza meg:

A HTTP-végpontok általában JavaScript Object Notation (JSON) adatokat adnak vissza, de nem mindig. Az opcionális System.Net.Http.Json NuGet-csomag számos bővítménymetódust biztosít HttpClient és HttpContent objektumokhoz, amelyek automatikus szerializálást és deszerializálást hajtanak végre a System.Text.Json 📦 NuGet-csomag használatával. A cikkben szereplő példák felhívják a figyelmet azokra a helyekre, ahol ezek a bővítmények elérhetők.

Tipp.

A cikkben hivatkozott összes forráskód elérhető a GitHubon: .NET Docs adattárban.

HttpClient-objektum létrehozása

A cikkben szereplő példák többsége ugyanazt a HttpClient példányt használja újra, így egyszer konfigurálhatja a példányt, és felhasználhatja a többi példához. HttpClient objektum létrehozásához használja a HttpClient osztálykonstruktort. További információkért tekintse meg a HttpClient használatának irányelveit.

// HttpClient lifecycle management best practices:
// https://learn.microsoft.com/dotnet/fundamentals/networking/http/httpclient-guidelines#recommended-use
private static HttpClient sharedClient = new()
{
    BaseAddress = new Uri("https://jsonplaceholder.typicode.com"),
};

A kód a következő feladatokat hajtja végre:

  • Egy új HttpClient példányt hozzon létre static változóként. A irányelvekszerint az ajánlott módszer a HttpClient példányok újrafelhasználása az alkalmazás életciklusa során.
  • Állítsa a HttpClient.BaseAddress tulajdonságot "https://jsonplaceholder.typicode.com"értékre.

Ez a HttpClient példány az alapcímet használja a későbbi kérések elvégzéséhez. Más konfigurációk alkalmazásához vegye figyelembe a következő API-kat:

Tipp.

Másik lehetőségként létrehozhat HttpClient példányokat egy gyári mintaalapú megközelítéssel, amellyel tetszőleges számú ügyfelet konfigurálhat, és függőséginjektálási szolgáltatásként használhatja őket. További információ: HTTP-ügyfél-előállító a .NET-tel.

HTTP-kérés létrehozása

HTTP-kérés indításához hívja meg az alábbi API-metódusok bármelyikét:

HTTP-metódus Alkalmazásprogramozási interfész (API)
GET HttpClient.GetAsync
GET HttpClient.GetByteArrayAsync
GET HttpClient.GetStreamAsync
GET HttpClient.GetStringAsync
POST HttpClient.PostAsync
PUT HttpClient.PutAsync
PATCH HttpClient.PatchAsync
DELETE HttpClient.DeleteAsync
†USER SPECIFIED HttpClient.SendAsync

†A USER SPECIFIED kérés azt jelzi, hogy a SendAsync metódus bármilyen érvényes HttpMethod objektumot elfogad.

Figyelmeztetés

A HTTP-kérések létrehozása hálózati I/O-kötött munka. Létezik szinkron HttpClient.Send metódus, de a javaslat az aszinkron API-k használata, hacsak nincs rá jó oka.

Feljegyzés

Amikor Android-eszközöket céloz meg (például .NET MAUI fejlesztéssel), hozzá kell adnia a android:usesCleartextTraffic="true" definíciót a <application></application> fájl szakaszához. Ez a beállítás lehetővé teszi a tiszta szöveges forgalmat, például a HTTP-kéréseket, amelyek egyébként alapértelmezés szerint le vannak tiltva az Android biztonsági szabályzatai miatt. Vegye figyelembe a következő példa XML-beállításokat:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  <application android:usesCleartextTraffic="true"></application>
  <!-- omitted for brevity -->
</manifest>

További információ: Clear-text hálózati forgalom engedélyezése a localhost tartomány számára.

HTTP-tartalom ismertetése

A HttpContent típus egy HTTP-entitás törzsét és a megfelelő tartalomfejléceket jelöli. A szövegtörzset (POST, PUT, PATCH) igénylő HTTP-metódusok (vagy kérésmetelyek) esetében a HttpContent osztály használatával adja meg a kérés törzsét. A legtöbb példa bemutatja, hogyan készítse elő az StringContent alosztályt egy JSON hasznos adattal, de más alosztályok léteznek különböző tartalomtípusokhoz (MIME).

A HttpContent osztály a HttpResponseMessage osztály választörzsét is ábrázolja, amely a HttpResponseMessage.Content tulajdonságban érhető el.

HTTP GET-kérés használata

A GET kérésnek nem kellene törzset küldenie. Ez a kérés (ahogy a metódus neve is jelzi) az erőforrások adatainak lekérésére (vagy lekérésére) szolgál. HA HTTP-GET kérést szeretne küldeni egy HttpClient-példányra és egy Uri objektumra, használja a HttpClient.GetAsync metódust:

static async Task GetAsync(HttpClient httpClient)
{
    using HttpResponseMessage response = await httpClient.GetAsync("todos/3");
    
    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();
    
    var jsonResponse = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"{jsonResponse}\n");

    // Expected output:
    //   GET https://jsonplaceholder.typicode.com/todos/3 HTTP/1.1
    //   {
    //     "userId": 1,
    //     "id": 3,
    //     "title": "fugiat veniam minus",
    //     "completed": false
    //   }
}

A kód a következő feladatokat hajtja végre:

  • Küldjön egy GET kérést a "https://jsonplaceholder.typicode.com/todos/3" végpontra.
  • Győződjön meg arról, hogy a válasz sikeres.
  • Írja be a kérés részleteit a konzolra.
  • Olvassa el a válasz törzsét karakterláncként.
  • Írja be a JSON válasz törzsét a konzolra.

A WriteRequestToConsole metódus egy egyéni bővítmény, amely nem része a keretrendszernek. Ha kíváncsi a megvalósításra, vegye figyelembe a következő C#-kódot:

static class HttpResponseMessageExtensions
{
    internal static void WriteRequestToConsole(this HttpResponseMessage response)
    {
        if (response is null)
        {
            return;
        }

        var request = response.RequestMessage;
        Console.Write($"{request?.Method} ");
        Console.Write($"{request?.RequestUri} ");
        Console.WriteLine($"HTTP/{request?.Version}");        
    }
}

Ez a funkció a kérés részleteinek a konzolra való írására szolgál az alábbi formában:

<HTTP Request Method> <Request URI> <HTTP/Version>

Példaként a GET végpontra irányuló "https://jsonplaceholder.typicode.com/todos/3" kérés a következő üzenetet adja ki:

GET https://jsonplaceholder.typicode.com/todos/3 HTTP/1.1

A HTTP GET kérés létrehozása a JSON-ból

A https://jsonplaceholder.typicode.com/todos végpont egy JSON-tömböt ad vissza Todo objektumokból. JSON-struktúrájuk a következő formára hasonlít:

[
  {
    "userId": 1,
    "id": 1,
    "title": "example title",
    "completed": false
  },
  {
    "userId": 1,
    "id": 2,
    "title": "another example title",
    "completed": true
  },
]

A C# Todo objektum a következőképpen van definiálva:

public record class Todo(
    int? UserId = null,
    int? Id = null,
    string? Title = null,
    bool? Completed = null);

Ez egy record class típus, választhatóId, Titleés CompletedUserId tulajdonságokkal rendelkezik. A típusról további információt a record C# rekordtípusainak bemutatása című témakörben talál. Ha automatikusan deszerializálni szeretné GET kéréseket egy erősen típusos C# objektumba, használja a GetFromJsonAsync NuGet-csomag részét képező 📦 kiterjesztési metódust.

static async Task GetFromJsonAsync(HttpClient httpClient)
{
    var todos = await httpClient.GetFromJsonAsync<List<Todo>>(
        "todos?userId=1&completed=false");

    Console.WriteLine("GET https://jsonplaceholder.typicode.com/todos?userId=1&completed=false HTTP/1.1");
    todos?.ForEach(Console.WriteLine);
    Console.WriteLine();

    // Expected output:
    //   GET https://jsonplaceholder.typicode.com/todos?userId=1&completed=false HTTP/1.1
    //   Todo { UserId = 1, Id = 1, Title = delectus aut autem, Completed = False }
    //   Todo { UserId = 1, Id = 2, Title = quis ut nam facilis et officia qui, Completed = False }
    //   Todo { UserId = 1, Id = 3, Title = fugiat veniam minus, Completed = False }
    //   Todo { UserId = 1, Id = 5, Title = laboriosam mollitia et enim quasi adipisci quia provident illum, Completed = False }
    //   Todo { UserId = 1, Id = 6, Title = qui ullam ratione quibusdam voluptatem quia omnis, Completed = False }
    //   Todo { UserId = 1, Id = 7, Title = illo expedita consequatur quia in, Completed = False }
    //   Todo { UserId = 1, Id = 9, Title = molestiae perspiciatis ipsa, Completed = False }
    //   Todo { UserId = 1, Id = 13, Title = et doloremque nulla, Completed = False }
    //   Todo { UserId = 1, Id = 18, Title = dolorum est consequatur ea mollitia in culpa, Completed = False }
}

A kód a következő feladatokat hajtja végre:

  • Készíts egy GET kérést "https://jsonplaceholder.typicode.com/todos?userId=1&completed=false"-nek.

    A lekérdezési sztring a kérelem szűrési feltételeit jelöli. Ha a parancs sikeres, a válasz automatikusan deszerializálódik egy List<Todo> objektumba.

  • Írja be a kérés részleteit a konzolra az egyes Todo objektumokkal együtt.

HTTP POST-kérés használata

A POST kérelem adatokat küld a kiszolgálónak feldolgozás céljából. A Content-Type kérés fejléce azt jelzi, hogy milyen MIME-típust küld a törzs. HA HTTP-POST kérést szeretne küldeni egy HttpClient-példányra és egy Uri objektumra, használja a HttpClient.PostAsync metódust:

static async Task PostAsync(HttpClient httpClient)
{
    using StringContent jsonContent = new(
        JsonSerializer.Serialize(new
        {
            userId = 77,
            id = 1,
            title = "write code sample",
            completed = false
        }),
        Encoding.UTF8,
        "application/json");

    using HttpResponseMessage response = await httpClient.PostAsync(
        "todos",
        jsonContent);

    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();
    
    var jsonResponse = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"{jsonResponse}\n");

    // Expected output:
    //   POST https://jsonplaceholder.typicode.com/todos HTTP/1.1
    //   {
    //     "userId": 77,
    //     "id": 201,
    //     "title": "write code sample",
    //     "completed": false
    //   }
}

A kód a következő feladatokat hajtja végre:

  • Készítsen elő egy StringContent példányt a kérelem JSON-törzsével ("application/json"MIME típusa).
  • Küldjön egy POST kérést a "https://jsonplaceholder.typicode.com/todos" végpontra.
  • Győződjön meg arról, hogy a válasz sikeres, és írja be a kérés részleteit a konzolra.
  • Írja a válasz törzsét karakterláncként a konzolra.

A HTTP POST-kérelem létrehozása JSON-ként

A kérelemargumentumok automatikus szerializálásához POST és a válaszok erős C#-objektumokba való deszerializálásához használja a PostAsJsonAsyncSystem.Net.Http.Json NuGet-csomag részét képező bővítménymetódust.

static async Task PostAsJsonAsync(HttpClient httpClient)
{
    using HttpResponseMessage response = await httpClient.PostAsJsonAsync(
        "todos", 
        new Todo(UserId: 9, Id: 99, Title: "Show extensions", Completed: false));

    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();

    var todo = await response.Content.ReadFromJsonAsync<Todo>();
    Console.WriteLine($"{todo}\n");

    // Expected output:
    //   POST https://jsonplaceholder.typicode.com/todos HTTP/1.1
    //   Todo { UserId = 9, Id = 201, Title = Show extensions, Completed = False }
}

A kód a következő feladatokat hajtja végre:

  • Szerializálja a Todo-példányt JSON-ként, és küldjön egy POST kérést a "https://jsonplaceholder.typicode.com/todos" végponthoz.
  • Győződjön meg arról, hogy a válasz sikeres, és írja be a kérés részleteit a konzolra.
  • Deszerializálja a választörzset egy Todo-példányba, és írja be a Todo objektumot a konzolra.

HTTP PUT-kérés használata

A PUT kérések módszere lecserélhet egy meglévő erőforrást, vagy létrehozhat egy újat a kérés törzsének tartalmával. HA HTTP-PUT kérést szeretne küldeni egy HttpClient-példányra és egy Uri objektumra, használja a HttpClient.PutAsync metódust:

static async Task PutAsync(HttpClient httpClient)
{
    using StringContent jsonContent = new(
        JsonSerializer.Serialize(new 
        {
            userId = 1,
            id = 1,
            title = "foo bar",
            completed = false
        }),
        Encoding.UTF8,
        "application/json");

    using HttpResponseMessage response = await httpClient.PutAsync(
        "todos/1",
        jsonContent);

    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();
    
    var jsonResponse = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"{jsonResponse}\n");

    // Expected output:
    //   PUT https://jsonplaceholder.typicode.com/todos/1 HTTP/1.1
    //   {
    //     "userId": 1,
    //     "id": 1,
    //     "title": "foo bar",
    //     "completed": false
    //   }
}

A kód a következő feladatokat hajtja végre:

  • Készítsen elő egy StringContent példányt a kérelem JSON-törzsével ("application/json"MIME típusa).
  • Küldjön egy PUT kérést a "https://jsonplaceholder.typicode.com/todos/1" végpontra.
  • Győződjön meg arról, hogy a válasz sikeres, és írja meg a kérés részleteit a JSON válasz törzsével a konzolra.

A HTTP PUT-kérelem létrehozása JSON-ként

A kérelemargumentumok automatikus szerializálásához PUT és a válaszok erős C#-objektumokba való deszerializálásához használja a PutAsJsonAsyncSystem.Net.Http.Json NuGet-csomag részét képező bővítménymetódust.

static async Task PutAsJsonAsync(HttpClient httpClient)
{
    using HttpResponseMessage response = await httpClient.PutAsJsonAsync(
        "todos/5",
        new Todo(Title: "partially update todo", Completed: true));

    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();

    var todo = await response.Content.ReadFromJsonAsync<Todo>();
    Console.WriteLine($"{todo}\n");

    // Expected output:
    //   PUT https://jsonplaceholder.typicode.com/todos/5 HTTP/1.1
    //   Todo { UserId = , Id = 5, Title = partially update todo, Completed = True }
}

A kód a következő feladatokat hajtja végre:

  • Szerializálja a Todo-példányt JSON-ként, és küldjön egy PUT kérést a "https://jsonplaceholder.typicode.com/todos/5" végponthoz.
  • Győződjön meg arról, hogy a válasz sikeres, és írja be a kérés részleteit a konzolra.
  • Deszerializálja a válasz törzsét egy Todo-példányba, és írja be a Todo objektumokat a konzolra.

HTTP PATCH-kérés használata

A PATCH kérés egy meglévő erőforrás részleges frissítése. Ez a kérés nem hoz létre új erőforrást, és nem egy meglévő erőforrás cseréjére szolgál. Ehelyett ez a módszer csak részben frissíti az erőforrást. HA HTTP-PATCH kérést szeretne küldeni egy HttpClient-példányra és egy Uri objektumra, használja a HttpClient.PatchAsync metódust:

static async Task PatchAsync(HttpClient httpClient)
{
    using StringContent jsonContent = new(
        JsonSerializer.Serialize(new
        {
            completed = true
        }),
        Encoding.UTF8,
        "application/json");

    using HttpResponseMessage response = await httpClient.PatchAsync(
        "todos/1",
        jsonContent);

    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();

    var jsonResponse = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"{jsonResponse}\n");

    // Expected output
    //   PATCH https://jsonplaceholder.typicode.com/todos/1 HTTP/1.1
    //   {
    //     "userId": 1,
    //     "id": 1,
    //     "title": "delectus aut autem",
    //     "completed": true
    //   }
}

A kód a következő feladatokat hajtja végre:

  • Készítsen elő egy StringContent példányt a kérelem JSON-törzsével ("application/json"MIME típusa).
  • Küldjön egy PATCH kérést a "https://jsonplaceholder.typicode.com/todos/1" végpontra.
  • Győződjön meg arról, hogy a válasz sikeres, és írja meg a kérés részleteit a JSON válasz törzsével a konzolra.

A PATCH NuGet-csomagban lévő System.Net.Http.Json kérésekhez nem léteznek bővítési metódusok.

HTTP DELETE-kérés használata

A DELETE kérés eltávolít egy meglévő erőforrást, és a kérés idempotens, de nem biztonságos. Ugyanahhoz az erőforráshoz több DELETE kérés is ugyanazt az eredményt adja, de a kérés hatással van az erőforrás állapotára. HA HTTP-DELETE kérést szeretne küldeni egy HttpClient-példányra és egy Uri objektumra, használja a HttpClient.DeleteAsync metódust:

static async Task DeleteAsync(HttpClient httpClient)
{
    using HttpResponseMessage response = await httpClient.DeleteAsync("todos/1");
    
    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();

    var jsonResponse = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"{jsonResponse}\n");

    // Expected output
    //   DELETE https://jsonplaceholder.typicode.com/todos/1 HTTP/1.1
    //   {}
}

A kód a következő feladatokat hajtja végre:

  • Küldjön egy DELETE kérést a "https://jsonplaceholder.typicode.com/todos/1" végpontra.
  • Győződjön meg arról, hogy a válasz sikeres, és írja be a kérés részleteit a konzolra.

Tipp.

Egy DELETE kérésre adott válasz (akárcsak egy PUT kérés) tartalmazhat vagy nem tartalmazhat törzset.

A HTTP HEAD-kérelem megismerése

A HEAD kérés hasonló a GET kéréshez. Az erőforrás visszaadása helyett ez a kérés csak az erőforráshoz társított fejléceket adja vissza. A HEAD kérésre adott válasz nem ad vissza tartalmat. HA HTTP-HEAD kérést szeretne készíteni egy HttpClient-példány és egy Uri objektum alapján, használja a HttpClient.SendAsync metódust a HttpMethodHttpMethod.Headtípusával:

static async Task HeadAsync(HttpClient httpClient)
{
    using HttpRequestMessage request = new(
        HttpMethod.Head, 
        "https://www.example.com");

    using HttpResponseMessage response = await httpClient.SendAsync(request);

    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();

    foreach (var header in response.Headers)
    {
        Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
    }
    Console.WriteLine();

    // Expected output:
    //   HEAD https://www.example.com/ HTTP/1.1
    //   Accept-Ranges: bytes
    //   Age: 550374
    //   Cache-Control: max-age=604800
    //   Date: Wed, 10 Aug 2022 17:24:55 GMT
    //   ETag: "3147526947"
    //   Server: ECS, (cha / 80E2)
    //   X-Cache: HIT
}

A kód a következő feladatokat hajtja végre:

  • Küldjön egy HEAD kérést a "https://www.example.com/" végpontra.
  • Győződjön meg arról, hogy a válasz sikeres, és írja be a kérés részleteit a konzolra.
  • Iterálja át az összes válaszfejlécet, és írja az egyes fejléceket a konzolra.

A HTTP-BEÁLLÍTÁSOK kérés megismerése

A OPTIONS kérés a kiszolgáló vagy végpont által támogatott HTTP-metódusok azonosítására szolgál. HA HTTP-OPTIONS kérést szeretne készíteni egy HttpClient-példány és egy Uri objektum alapján, használja a HttpClient.SendAsync metódust a HttpMethodHttpMethod.Optionstípusával:

static async Task OptionsAsync(HttpClient httpClient)
{
    using HttpRequestMessage request = new(
        HttpMethod.Options, 
        "https://www.example.com");

    using HttpResponseMessage response = await httpClient.SendAsync(request);

    response.EnsureSuccessStatusCode()
        .WriteRequestToConsole();

    foreach (var header in response.Content.Headers)
    {
        Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
    }
    Console.WriteLine();

    // Expected output
    //   OPTIONS https://www.example.com/ HTTP/1.1
    //   Allow: OPTIONS, GET, HEAD, POST
    //   Content-Type: text/html; charset=utf-8
    //   Expires: Wed, 17 Aug 2022 17:28:42 GMT
    //   Content-Length: 0
}

A kód a következő feladatokat hajtja végre:

  • Küldjön egy OPTIONS HTTP-kérést a "https://www.example.com/" végpontnak.
  • Győződjön meg arról, hogy a válasz sikeres, és írja be a kérés részleteit a konzolra.
  • Iterálja át az összes választartalom-fejlécet, és írja be az egyes fejléceket a konzolra.

A HTTP TRACE-kérés megismerése

A TRACE kérés hasznos lehet a hibakereséshez, mivel alkalmazásszintű visszacsatolást biztosít a kérési üzenethez. HTTP-TRACE kérés létrehozásához hozzon létre egy HttpRequestMessage a HttpMethod.Trace típusával:

using HttpRequestMessage request = new(
    HttpMethod.Trace, 
    "{ValidRequestUri}");

Figyelemfelhívás

Nem minden HTTP-kiszolgáló támogatja a TRACE HTTP-metódust. Ez a módszer biztonsági rést tehet közzé, ha nem megfelelő módon használják. További információ: Open Web Application Security Project (OWASP): Cross Site Tracing.

HTTP-válasz kezelése

HTTP-válasz kezelésekor a HttpResponseMessage típussal lép kapcsolatba. A rendszer több taggal értékeli a válasz érvényességét. A HTTP-állapotkód a HttpResponseMessage.StatusCode tulajdonságban érhető el.

Tegyük fel, hogy egy ügyfélpéldányra vonatkozó kérést küld:

using HttpResponseMessage response = await httpClient.SendAsync(request);

Annak érdekében, hogy a responseOK legyen (HTTP-állapotkód: 200), kiértékelheti az értéket az alábbi példában látható módon:

if (response is { StatusCode: HttpStatusCode.OK })
{
    // Omitted for brevity...
}

Vannak más HTTP-állapotkódok is, amelyek sikeres választ jelentenek, például CREATED (HTTP-állapotkód: 201), ACCEPTED (HTTP-állapotkód: 202), NO CONTENT (HTTP-állapotkód: 204) és RESET CONTENT (HTTP-állapotkód: 205). A tulajdonság segítségével ezeket a HttpResponseMessage.IsSuccessStatusCode kódokat is kiértékelheti, ami biztosítja, hogy a válasz állapotkódja a 200–299 tartományon belül legyen:

if (response.IsSuccessStatusCode)
{
    // Omitted for brevity...
}

Ha a keretrendszernek HttpRequestException hibát kell jeleznie, meghívhatja a HttpResponseMessage.EnsureSuccessStatusCode() metódust:

response.EnsureSuccessStatusCode();

Ez a kód HttpRequestException hibát jelez, ha a válasz állapotkódja nem a 200–299 tartományon belül van.

A HTTP érvényes tartalomválaszainak felfedezése

Érvényes válasz esetén a választörzset a Content tulajdonsággal érheti el. A törzs HttpContent-példányként érhető el, amellyel streamként, bájttömbként vagy sztringként érheti el a törzset.

A következő kód a responseStream objektummal olvassa be a válasz törzsét:

await using Stream responseStream =
    await response.Content.ReadAsStreamAsync();

A válasz törzsének olvasásához különböző objektumokat használhat. A válasz törzsének olvasásához használja a responseByteArray objektumot:

byte[] responseByteArray = await response.Content.ReadAsByteArrayAsync();

A válasz törzsének olvasásához használja a responseString objektumot:

string responseString = await response.Content.ReadAsStringAsync();

Ha tudja, hogy egy HTTP-végpont JSON-t ad vissza, a választörzset bármilyen érvényes C#-objektumba deszerializálhatja a System.Net.Http.Json NuGet-csomag használatával:

T? result = await response.Content.ReadFromJsonAsync<T>();

Ebben a kódban a result érték a választörzs deszerializált típusa T.

HTTP-hibakezelés használata

Ha egy HTTP-kérés meghiúsul, a rendszer eldobja a HttpRequestException objektumot. Előfordulhat, hogy a kivétel elfogása önmagában nem elegendő. Vannak más lehetséges kivételek is, amelyeket érdemes megfontolni, hogyan kezeljük. Előfordulhat például, hogy a hívó kód egy lemondási jogkivonatot használ, amelyet a kérés befejezése előtt töröltek. Ebben a forgatókönyvben a TaskCanceledException hibát észlelheti:

using var cts = new CancellationTokenSource();
try
{
    // Assuming:
    //   httpClient.Timeout = TimeSpan.FromSeconds(10)

    using var response = await httpClient.GetAsync(
        "http://localhost:5001/sleepFor?seconds=100", cts.Token);
}
catch (OperationCanceledException ex) when (cts.IsCancellationRequested)
{
    // When the token has been canceled, it is not a timeout.
    Console.WriteLine($"Canceled: {ex.Message}");
}

Hasonlóképpen, amikor HTTP-kérést küld, ha a kiszolgáló nem válaszol a HttpClient.Timeout érték túllépése előtt, ugyanaz a kivétel lesz dobva. Ebben a forgatókönyvben felismerheti az időtúllépés tényét, ha kiértékeli a Exception.InnerException tulajdonságot a TaskCanceledException hiba észlelésénél.

try
{
    // Assuming:
    //   httpClient.Timeout = TimeSpan.FromSeconds(10)

    using var response = await httpClient.GetAsync(
        "http://localhost:5001/sleepFor?seconds=100");
}
catch (OperationCanceledException ex) when (ex.InnerException is TimeoutException tex)
{
    Console.WriteLine($"Timed out: {ex.Message}, {tex.Message}");
}

A kódban, ha a belső kivétel TimeoutException típusú, akkor időtúllépés történt, és a megszakítási token nem mondja le a kérést.

A HTTP-állapotkód kiértékeléséhez a HttpRequestException objektum elfogásakor kiértékelheti a HttpRequestException.StatusCode tulajdonságot:

try
{
    // Assuming:
    //   httpClient.Timeout = TimeSpan.FromSeconds(10)

    using var response = await httpClient.GetAsync(
        "http://localhost:5001/doesNotExist");

    response.EnsureSuccessStatusCode();
}
catch (HttpRequestException ex) when (ex is { StatusCode: HttpStatusCode.NotFound })
{
    // Handle 404
    Console.WriteLine($"Not found: {ex.Message}");
}

A kódban a EnsureSuccessStatusCode() metódus kivételt eredményez, ha a válasz nem sikeres. A HttpRequestException.StatusCode tulajdonságot ezután kiértékelik annak megállapítására, hogy a válasz 404 volt-e (HTTP-állapotkód: 404). Az HttpClient objektumon számos segédmetódus található, amelyek implicit módon meghívják a EnsureSuccessStatusCode metódust az Ön nevében.

HTTP-hiba átadása esetén vegye figyelembe a következő API-kat:

Tipp.

Az összes HttpClient metódus, amely olyan HTTP-kérések készítésére szolgál, amelyek nem adnak vissza HttpResponseMessage típust, implicit módon meghívják a EnsureSuccessStatusCode metódust az Ön nevében.

Amikor meghívja ezeket a metódusokat, kezelheti a HttpRequestException objektumot, és kiértékelheti a HttpRequestException.StatusCode tulajdonságot a válasz HTTP-állapotkódjának meghatározásához:

try
{
    // These extension methods will throw HttpRequestException
    // with StatusCode set when the HTTP request status code isn't 2xx:
    //
    //   GetByteArrayAsync
    //   GetStreamAsync
    //   GetStringAsync

    using var stream = await httpClient.GetStreamAsync(
        "https://localhost:5001/doesNotExists");
}
catch (HttpRequestException ex) when (ex is { StatusCode: HttpStatusCode.NotFound })
{
    // Handle 404
    Console.WriteLine($"Not found: {ex.Message}");
}

Előfordulhatnak olyan helyzetek, amikor a HttpRequestException objektumot a kódba kell dobnia. A HttpRequestException() konstruktor nyilvános, és használatával kivételt állíthat be egy egyéni üzenettel:

try
{
    using var response = await httpClient.GetAsync(
        "https://localhost:5001/doesNotExists");

    // Throw for anything higher than 400.
    if (response is { StatusCode: >= HttpStatusCode.BadRequest })
    {
        throw new HttpRequestException(
            "Something went wrong", inner: null, response.StatusCode);
    }
}
catch (HttpRequestException ex) when (ex is { StatusCode: HttpStatusCode.NotFound })
{
    Console.WriteLine($"Not found: {ex.Message}");
}

HTTP-proxy konfigurálása

A HTTP-proxyk kétféleképpen konfigurálhatók. A tulajdonságon HttpClient.DefaultProxy alapértelmezett érték van megadva. Másik lehetőségként megadhat egy proxyt a HttpClientHandler.Proxy tulajdonságon.

Globális alapértelmezett proxy használata

A HttpClient.DefaultProxy tulajdonság egy statikus tulajdonság, amely meghatározza az összes HttpClient példány által használt alapértelmezett proxyt, ha a konstruktoron áthaladó HttpClientHandler objektumban nincs explicit módon beállítva proxy.

A tulajdonság által visszaadott alapértelmezett példány a platformtól függően eltérő szabályok szerint inicializálható:

  • Windows: Olvassa el a proxykonfigurációt a környezeti változókból, vagy ha nincsenek definiálva változók, olvassa be a felhasználói proxybeállításokból.
  • macOS: Olvassa el a proxykonfigurációt a környezeti változókból, vagy ha nincsenek definiálva változók, olvassa el a rendszerproxy-beállításokból.
  • Linux-: Olvassa el a proxykonfigurációt a környezeti változókból, vagy ha nincsenek definiálva változók, inicializáljon egy nem konfigurált példányt az összes cím megkerüléséhez.

A DefaultProxy tulajdonság inicializálása Windows- és Unix-alapú platformokon a következő környezeti változókat használja:

  • HTTP_PROXY: A HTTP-kérelmekhez használt proxykiszolgáló.
  • HTTPS_PROXY: A HTTPS-kérelmekhez használt proxykiszolgáló.
  • ALL_PROXY: A HTTP- és/vagy HTTPS-kérelmekben használt proxykiszolgáló, ha a HTTP_PROXY és/vagy HTTPS_PROXY változók nincsenek definiálva.
  • NO_PROXY: A proxyzásból kizárandó gazdagépnevek vesszővel tagolt listája. A csillagokat nem támogatják helyettesítő karakterekként. Ha egy altartományt szeretne egyeztetni, használjon vezető pontot (.). Példák: NO_PROXY=.example.com (kezdő periódussal) egyezik www.example.com, de nem egyezik example.com. NO_PROXY=example.com (vezető pont nélkül) nem egyezik meg www.example.com. Ezt a viselkedést a jövőben újra lehet majd áttekinteni, hogy jobban illeszkedjenek más ökoszisztémákhoz.

Azokban a rendszerekben, ahol a környezeti változók megkülönböztetik a kis- és nagybetűket, a változónevek kis- vagy nagybetűk is lehetnek. Először a kisbetűs nevek lesznek bejelölve.

A proxykiszolgáló lehet gazdagépnév vagy IP-cím, amelyet opcionálisan kettőspont és portszám követ, vagy lehet egy http URL-cím, opcionálisan a proxyhitelesítéshez használt felhasználónévvel és jelszóval. Az URL-címnek httpkell kezdődnie, nem https, és nem tartalmazhat szöveget a gazdagépnév, az IP-cím vagy a port után.

A proxy konfigurálása ügyfélenként

A HttpClientHandler.Proxy tulajdonság azonosítja azt a WebProxy objektumot, amely az internetes erőforrásokra irányuló kérelmek feldolgozásához használható. Ha meg szeretné adni, hogy ne használjon proxyt, állítsa a Proxy tulajdonságot a metódus által visszaadott proxypéldányra GlobalProxySelection.GetEmptyWebProxy() .

A helyi számítógép- vagy alkalmazáskonfigurációs fájl megadhat egy alapértelmezett proxyt. Ha a Proxy tulajdonság meg van adva, akkor a Proxy tulajdonság proxybeállításai felülbírálják a helyi számítógép- vagy alkalmazáskonfigurációs fájlt, és a kezelő a megadott proxybeállításokat használja. Ha nincs megadva proxy egy konfigurációs fájlban, és a Proxy tulajdonság nincs meghatározva, a kezelő a helyi számítógéptől örökölt proxybeállításokat használja. Ha nincsenek proxybeállítások, a rendszer közvetlenül a kiszolgálónak küldi el a kérést.

Az HttpClientHandler osztály a proxy megkerülőlistát elemzi, amely joker karaktereket tartalmaz, amelyeket a helyi számítógép beállításaitól örökölt. Például a HttpClientHandler osztály a böngészők megkerülési listáját "nt*" normál kifejezésként "nt.*" elemzi. Ezért a http://nt.com URL-címe a HttpClientHandler osztály használatával megkerüli a proxyt.

Az HttpClientHandler osztály támogatja a helyi proxy megkerülését. Az osztály helyinek tekinti a célhelyet, ha az alábbi feltételek bármelyike teljesül:

  • A cél egy egyszerű nevet tartalmaz (nincs pont (.) az URL-címben.
  • A cél egy visszacsatolási címet (Loopback vagy IPv6Loopback) tartalmaz, vagy a cél egy IPAddress tulajdonságot tartalmaz, amely a helyi számítógéphez van hozzárendelve.
  • A cél tartomány utótagja megegyezik a helyi számítógép tartomány-utótagjával, a DomainName tulajdonságban meghatározottak szerint.

A proxy konfigurálásával kapcsolatos további információkért tekintse meg a következő API-kat:

Következő lépések