REST-ClientREST client

In diesem Tutorial lernen Sie verschiedene Features in .NET Core und der Sprache C# kennen.This tutorial teaches you a number of features in .NET Core and the C# language. Es werden die folgenden Themen abgedeckt:You'll learn:

  • Die Grundlagen zur .NET Core-CLIThe basics of the .NET Core CLI.
  • Eine Übersicht über die Features der Sprache C#An overview of C# Language features.
  • Verwalten von Abhängigkeiten mit NuGetManaging dependencies with NuGet
  • HTTP-KommunikationHTTP Communications
  • Verarbeiten von JSON-InformationenProcessing JSON information
  • Verwalten der Konfiguration mit AttributenManaging configuration with Attributes.

Sie erstellen eine Anwendung, die HTTP-Anforderungen an einen REST-Dienst in GitHub ausgibt.You'll build an application that issues HTTP Requests to a REST service on GitHub. Sie lesen Informationen im JSON-Format ein und konvertieren das JSON-Paket in C#-Objekte.You'll read information in JSON format, and convert that JSON packet into C# objects. Abschließend lernen Sie die Arbeit mit C#-Objekten kennen.Finally, you'll see how to work with C# objects.

In diesem Tutorial werden viele Features abgedeckt.There are many features in this tutorial. Gehen wir sie einzeln an.Let's build them one by one.

Wenn Sie lieber das letzte Beispiel für dieses Artikels befolgen möchten, können Sie es herunterladen.If you prefer to follow along with the final sample for this article, you can download it. Anweisungen zum Herunterladen finden Sie unter Beispiele und Lernprogramme.For download instructions, see Samples and Tutorials.

VoraussetzungenPrerequisites

Sie müssen Ihren Computer zur Ausführung von .NET Core einrichten.You'll need to set up your machine to run .NET core. Die Installationsanweisungen finden Sie auf der Seite .NET Core-Downloads.You can find the installation instructions on the .NET Core Downloads page. Sie können diese Anwendung unter Windows, Linux, macOS oder in einem Docker-Container ausführen.You can run this application on Windows, Linux, or macOS, or in a Docker container. Sie müssen Ihren bevorzugten Code-Editor installieren.You'll need to install your favorite code editor. In den folgenden Beschreibungen wird Visual Studio Code verwendet. Hierbei handelt es sich um einen plattformübergreifenden Open Source-Editor.The descriptions below use Visual Studio Code, which is an open source, cross platform editor. Sie können jedoch auch ein beliebiges anderes Tool verwenden, mit dem Sie vertraut sind.However, you can use whatever tools you are comfortable with.

Erstellen der AnwendungCreate the Application

Im ersten Schritt wird eine neue Anwendung erstellt.The first step is to create a new application. Öffnen Sie eine Eingabeaufforderung, und erstellen Sie ein neues Verzeichnis für Ihre Anwendung.Open a command prompt and create a new directory for your application. Legen Sie das Verzeichnis als aktuelles Verzeichnis fest.Make that the current directory. Geben Sie den folgenden Befehl in ein Konsolenfenster ein:Enter the following command in a console window:

dotnet new console --name WebAPIClient

Hierdurch werden die Startdateien für eine einfache „Hello World“-Anwendung erstellt.This creates the starter files for a basic "Hello World" application. Der Projektname lautet „WebAPIClient“.The project name is "WebAPIClient". Da es sich hier um ein neues Projekt handelt, ist keine der Abhängigkeiten vorhanden.As this is a new project, none of the dependencies are in place. Mit der ersten Ausführung wird das .NET Core-Framework heruntergeladen, ein Entwicklungszertifikat installiert und der NuGet-Paket-Manager ausgeführt, um die fehlenden Abhängigkeiten wiederherzustellen.The first run will download the .NET Core framework, install a development certificate, and run the NuGet package manager to restore missing dependencies.

Bevor Sie Änderungen vornehmen, geben Sie cd in das Verzeichnis „WebAPIClient“ und dotnet run (siehe Hinweis) an der Eingabeaufforderung ein, um die Anwendung auszuführen.Before you start making modifications, cd into the "WebAPIClient" directory and type dotnet run (see note) at the command prompt to run your application. dotnet run führt automatisch dotnet restore aus, wenn Ihrer Umgebung Abhängigkeiten fehlen.dotnet run automatically performs dotnet restore if your environment is missing dependencies. Wenn Ihre Anwendung neu erstellt werden muss, wird auch dotnet build ausgeführt.It also performs dotnet build if your application needs to be rebuilt. Nach dem ersten Setup müssen Sie nur dann dotnet restore oder dotnet build ausführen, wenn es für Ihr Projekt sinnvoll ist.After your initial setup, you will only need to run dotnet restore or dotnet build when it makes sense for your project.

Hinzufügen von neuen AbhängigkeitenAdding New Dependencies

Eines der wichtigsten Entwurfsziele für .NET Core ist die Minimierung der Größe der .NET-Installation.One of the key design goals for .NET Core is to minimize the size of the .NET installation. Wenn eine Anwendung zusätzliche Bibliotheken für bestimmte Features benötigt, fügen Sie diese abhängigen Komponenten Ihrer C#-Projektdatei (*.csproj) hinzu.If an application needs additional libraries for some of its features, you add those dependencies into your C# project (*.csproj) file. Beispielweise müssen Sie das System.Runtime.Serialization.Json-Paket hinzufügen, damit Ihre Anwendung JSON-Antworten verarbeiten kann.For our example, you'll need to add the System.Runtime.Serialization.Json package, so your application can process JSON responses.

Sie benötigen das System.Runtime.Serialization.Json-Paket für diese Anwendung.You'll need the System.Runtime.Serialization.Json package for this application. Fügen Sie es Ihrem Projekt hinzu, indem Sie den folgenden .NET CLI-Befehl ausführen:Add it to your project by running the following .NET CLI command:

dotnet add package System.Text.Json

Ausführen von WebanforderungenMaking Web Requests

Jetzt können Sie damit beginnen, Daten aus dem Web abzurufen.Now you're ready to start retrieving data from the web. In dieser Anwendung lesen Sie Informationen aus der GitHub-API ein.In this application, you'll read information from the GitHub API. Beginnen wir damit, Informationen zu den Projekten unterhalb der Kategorie .NET Foundation einzulesen.Let's read information about the projects under the .NET Foundation umbrella. Hierzu senden Sie zunächst eine Anforderung an die GitHub-API, um Informationen zu den Projekten abzurufen.You'll start by making the request to the GitHub API to retrieve information on the projects. Der verwendete Endpunkt ist https://api.github.com/orgs/dotnet/repos.The endpoint you'll use is: https://api.github.com/orgs/dotnet/repos. Sie möchten alle Informationen zu diesen Projekten abrufen, deshalb verwenden Sie eine HTTP GET-Anforderung.You want to retrieve all the information about these projects, so you'll use an HTTP GET request. Ihr Browser verwendet ebenfalls HTTP GET-Anforderungen, deshalb können Sie diese URL in Ihren Browser einfügen, um zu sehen, welche Informationen abgerufen und verarbeitet werden.Your browser also uses HTTP GET requests, so you can paste that URL into your browser to see what information you'll be receiving and processing.

Sie verwenden die HttpClient -Klasse zum Ausführen der Webanforderungen.You use the HttpClient class to make web requests. Wie alle modernen .NET-APIs unterstützt HttpClient nur asynchrone Methoden für APIs mit langer Ausführungszeit.Like all modern .NET APIs, HttpClient supports only async methods for its long-running APIs. Sie beginnen mit dem Erstellen einer asynchronen Methode.Start by making an async method. Sie vervollständigen die Implementierung, wenn Sie die Funktionalität der Anwendung erstellen.You'll fill in the implementation as you build the functionality of the application. Öffnen Sie zunächst die Datei program.cs in Ihrem Projektverzeichnis, und fügen Sie der Program-Klasse die folgende Methode hinzu:Start by opening the program.cs file in your project directory and adding the following method to the Program class:

private static async Task ProcessRepositories()
{
}

Sie müssen am Anfang Ihrer Main-Methode eine using-Anweisung hinzufügen, damit der C#-Compiler den Task-Typ erkennt:You'll need to add a using directive at the top of your Main method so that the C# compiler recognizes the Task type:

using System.Threading.Tasks;

Wenn Sie zu diesem Zeitpunkt Ihr Projekt erstellen, erhalten Sie eine Warnung für diese Methode, weil sie keine await-Operatoren enthält und synchron ausgeführt wird.If you build your project at this point, you'll get a warning generated for this method, because it does not contain any await operators and will run synchronously. Ignorieren Sie dies für den Moment. Sie fügen await-Operatoren hinzu, wenn Sie die Methode vervollständigen.Ignore that for now; you'll add await operators as you fill in the method.

Aktualisieren Sie als Nächstes die Methode Main, um die Methode ProcessRepositories aufzurufen.Next, update the Main method to call the ProcessRepositories method. Die ProcessRepositories-Methode gibt einen Task zurück. Sie dürfen das Programm nicht beenden, bevor dieser Task abgeschlossen wurde.The ProcessRepositories method returns a task, and you shouldn't exit the program before that task finishes. Daher müssen Sie die Signatur von Main ändern.Therefore, you must change the signature of Main. Fügen Sie den async-Modifizierer hinzu, und ändern Sie den Rückgabetyp in Task.Add the async modifier, and change the return type to Task. Fügen Sie dann im Textkörper der Methode einen Aufruf von ProcessRepositorieshinzu.Then, in the body of the method, add a call to ProcessRepositories. Fügen Sie diesem Methodenaufruf das Schlüsselwort await hinzu:Add the await keyword to that method call:

static async Task Main(string[] args)
{
    await ProcessRepositories();
}

Sie verfügen jetzt über ein Programm, das keinerlei Vorgänge ausführt, aber asynchron arbeitet.Now, you have a program that does nothing, but does it asynchronously. Es gibt aber noch Raum zur Verbesserung.Let's improve it.

Zunächst benötigen Sie ein Objekt, das dazu fähig ist, Daten aus dem Web abzurufen. Hierfür können Sie HttpClient verwenden.First you need an object that is capable to retrieve data from the web; you can use a HttpClient to do that. Dieses Objekt verarbeitet die Anforderung und die Antworten.This object handles the request and the responses. Instanziieren Sie eine einzelne Instanz dieses Typs in der Klasse Program innerhalb der Datei Program.cs.Instantiate a single instance of that type in the Program class inside the Program.cs file.

namespace WebAPIClient
{
    class Program
    {
        private static readonly HttpClient client = new HttpClient();

        static async Task Main(string[] args)
        {
            //...
        }
    }
}

Kehren wir zur ProcessRepositories-Methode zurück und erstellen eine erste Version der Methode:Let's go back to the ProcessRepositories method and fill in a first version of it:

private static async Task ProcessRepositories()
{
    client.DefaultRequestHeaders.Accept.Clear();
    client.DefaultRequestHeaders.Accept.Add(
        new MediaTypeWithQualityHeaderValue("application/vnd.github.v3+json"));
    client.DefaultRequestHeaders.Add("User-Agent", ".NET Foundation Repository Reporter");

    var stringTask = client.GetStringAsync("https://api.github.com/orgs/dotnet/repos");

    var msg = await stringTask;
    Console.Write(msg);
}

Damit eine Kompilierung möglich ist, müssen Sie am Anfang der Datei außerdem zwei neue using-Anweisungen hinzufügen:You'll need to also add two new using directives at the top of the file for this to compile:

using System.Net.Http;
using System.Net.Http.Headers;

Diese erste Version führt eine Webanforderung aus, um die Liste aller Repositorys unterhalb der dotnet foundation-Organisation einzulesen.This first version makes a web request to read the list of all repositories under the dotnet foundation organization. (Die GitHub-ID für die .NET Foundation lautet dotnet.) In den ersten Zeilen wird HttpClient für diese Anforderung eingerichtet.(The GitHub ID for the .NET Foundation is dotnet.) The first few lines set up the HttpClient for this request. Zunächst wird der HttpClient so konfiguriert, dass er die GitHub-JSON-Antworten akzeptiert.First, it is configured to accept the GitHub JSON responses. Das Format ist einfach JSON.This format is simply JSON. In der nächsten Zeile wird ein Benutzer-Agent-Header für alle Anforderungen von diesem Objekt hinzugefügt.The next line adds a User Agent header to all requests from this object. Diese zwei Header werden vom GitHub-Servercode überprüft und sind erforderlich, um Informationen aus GitHub abzurufen.These two headers are checked by the GitHub server code, and are necessary to retrieve information from GitHub.

Nachdem Sie den HttpClient konfiguriert haben, führen Sie eine Webanforderung aus und rufen die Antwort ab.After you've configured the HttpClient, you make a web request and retrieve the response. In dieser ersten Version verwenden Sie die bequeme HttpClient.GetStringAsync(String)-Methode.In this first version, you use the HttpClient.GetStringAsync(String) convenience method. Diese Hilfsmethode startet einen Task zum Ausführen der Webanforderung. Wenn die Anforderung zurückgegeben wird, liest sie den Antwortstream und extrahiert den Inhalt aus dem Stream.This convenience method starts a task that makes the web request, and then when the request returns, it reads the response stream and extracts the content from the stream. Der Antwortkörper wird als String zurückgegeben.The body of the response is returned as a String. Die Zeichenfolge ist verfügbar, wenn der Task abgeschlossen wurde.The string is available when the task completes.

Die letzten zwei Zeilen dieser Methode warten auf den Task und geben dann die Antwort an die Konsole aus.The final two lines of this method await that task, and then print the response to the console. Erstellen Sie die App, und führen Sie sie aus.Build the app, and run it. Die Buildwarnung wird jetzt nicht mehr angezeigt, weil ProcessRepositories jetzt einen await-Operator enthält.The build warning is gone now, because the ProcessRepositories now does contain an await operator. Sie sehen eine umfangreiche Textanzeige im JSON-Format.You'll see a long display of JSON formatted text.

Verarbeiten des JSON-ErgebnissesProcessing the JSON Result

Zu diesem Zeitpunkt haben Sie Code geschrieben, mit dem eine Antwort von einem Webserver abgerufen und der Text angezeigt wird, der in dieser Antwort enthalten ist.At this point, you've written the code to retrieve a response from a web server, and display the text that is contained in that response. Konvertieren wir jetzt diese JSON-Antwort in C#-Objekte.Next, let's convert that JSON response into C# objects.

Die System.Text.Json.JsonSerializer-Klasse serialisiert Objekte in JSON und deserialisiert JSON in-Objekte.The System.Text.Json.JsonSerializer class serializes objects to JSON and deserializes JSON into objects. Definieren Sie zunächst eine Klasse, die das repo-JSON-Objekt darstellt, das von der GitHub-API zurückgegeben wird:Start by defining a class to represent the repo JSON object returned from the GitHub API:

using System;

namespace WebAPIClient
{
    public class Repository
    {
        public string name { get; set; }
    }
}

Platzieren Sie den obigen Code in einer neuen Datei namens „repo.cs“.Put the above code in a new file called 'repo.cs'. Diese Version der Klasse repräsentiert die einfachste Möglichkeit zum Verarbeiten von JSON-Daten.This version of the class represents the simplest path to process JSON data. Der Klassenname und der Membername stimmen mit den im JSON-Paket verwendeten Namen überein, statt den C#-Konventionen zu folgen.The class name and the member name match the names used in the JSON packet, instead of following C# conventions. Sie beheben dies später, indem Sie einige Konfigurationsattribute angeben.You'll fix that by providing some configuration attributes later. Diese Klasse veranschaulicht ein weiteres wichtiges Feature der JSON-Serialisierung und -Deserialisierung: Nicht alle Felder im JSON-Paket sind Teil dieser Klasse.This class demonstrates another important feature of JSON serialization and deserialization: Not all the fields in the JSON packet are part of this class. Das JSON-Serialisierungsprogramm ignoriert Informationen, die nicht im verwendeten Klassentyp enthalten sind.The JSON serializer will ignore information that is not included in the class type being used. Dieses Feature vereinfacht es, Typen zu erstellen, die nur mit einem Teilsatz der Felder im JSON-Paket funktionieren.This feature makes it easier to create types that work with only a subset of the fields in the JSON packet.

Nun, da Sie den Typ erstellt haben, deserialisieren wir ihn.Now that you've created the type, let's deserialize it.

Als Nächstes verwenden Sie das Serialisierungsprogramm, um JSON-Daten in C#-Objekte zu konvertieren.Next, you'll use the serializer to convert JSON into C# objects. Ersetzen Sie den Aufruf von GetStringAsync(String) in Ihrer ProcessRepositories-Methode durch die folgenden Zeilen:Replace the call to GetStringAsync(String) in your ProcessRepositories method with the following lines:

var streamTask = client.GetStreamAsync("https://api.github.com/orgs/dotnet/repos");
var repositories = await JsonSerializer.DeserializeAsync<List<Repository>>(await streamTask);

Sie verwenden neue Namespaces, sodass Sie diesen ebenfalls am Anfang der Datei hinzufügen müssen:You're using new namespaces, so you'll need to add it at the top of the file as well:

using System.Collections.Generic;
using System.Text.Json;

Beachten Sie, dass Sie jetzt GetStreamAsync(String) anstelle von GetStringAsync(String) verwenden.Notice that you're now using GetStreamAsync(String) instead of GetStringAsync(String). Das Serialisierungsprogramm verwendet anstelle einer Zeichenfolge einen Stream als Quelle.The serializer uses a stream instead of a string as its source. Erläutern wir einige Features von C#, die in der zweiten Zeile des Codeausschnitts oben verwendet werden.Let's explain a couple features of the C# language that are being used in the second line of the preceding code snippet. Das erste Argument für JsonSerializer.DeserializeAsync<TValue>(Stream, JsonSerializerOptions, CancellationToken) ist ein await-Ausdruck.The first argument to JsonSerializer.DeserializeAsync<TValue>(Stream, JsonSerializerOptions, CancellationToken) is an await expression. (Die anderen beiden Parameter sind optional und werden im Codeausschnitt ausgelassen.) Await-Ausdrücke können fast überall in Ihrem Code auftauchen, auch wenn sie bisher nur als Teil einer Zuweisungsanweisung verwendet wurden.(The other two parameters are optional and are omitted in the code snippet.) Await expressions can appear almost anywhere in your code, even though up to now, you've only seen them as part of an assignment statement. Die Deserialize-Methode ist generisch. Dies bedeutet, dass Sie Typargumente für die Art von Objekten angeben müssen, die aus dem JSON-Text erstellt werden sollen.The Deserialize method is generic, which means you must supply type arguments for what kind of objects should be created from the JSON text. In diesem Beispiel deserialisieren Sie in ein List<Repository>, bei dem es sich um ein weiteres generisches Objekt handelt, das System.Collections.Generic.List<T>-Objekt.In this example, you're deserializing to a List<Repository>, which is another generic object, the System.Collections.Generic.List<T>. Die List<>-Klasse speichert eine Sammlung von Objekten.The List<> class stores a collection of objects. Das Typargument deklariert den Typ der in List<> gespeicherten Objekte.The type argument declares the type of objects stored in the List<>. Der JSON-Text stellt eine Sammlung von Repositoryobjekten dar, sodass das Typargument Repository ist.The JSON text represents a collection of repo objects, so the type argument is Repository.

Dieser Abschnitt ist fast fertig.You're almost done with this section. Nachdem Sie nun die JSON-Daten in C#-Objekte konvertiert haben, lassen Sie uns den Namen jedes Repositorys anzeigen.Now that you've converted the JSON to C# objects, let's display the name of each repository. Ersetzen Sie diese Zeilen:Replace the lines that read:

var msg = await stringTask;   //**Deleted this
Console.Write(msg);

...durch die folgenden:with the following:

foreach (var repo in repositories)
    Console.WriteLine(repo.name);

Kompilieren Sie die Anwendung, und führen Sie sie aus.Compile and run the application. Die Anwendung gibt die Namen der Repositorys aus, die Teil der .NET Foundation sind.It will print the names of the repositories that are part of the .NET Foundation.

Steuern der SerialisierungControlling Serialization

Bevor Sie weitere Features hinzufügen, wenden wir uns der name-Eigenschaft mithilfe des [JsonPropertyName]-Attributs zu.Before you add more features, let's address the name property by using the [JsonPropertyName] attribute. Ändern Sie die Deklaration des name-Felds in „repo.cs“ folgendermaßen ab:Make the following changes to the declaration of the name field in repo.cs:

[JsonPropertyName("name")]
public string Name { get; set; }

Um das [JsonPropertyName]-Attribut verwenden zu können, müssen Sie den System.Text.Json.Serialization-Namespace zu den using-Anweisungen hinzufügen:To use [JsonPropertyName] attribute, you will need to add the System.Text.Json.Serialization namespace to the using directives:

using System.Text.Json.Serialization;

Diese Änderung bedeutet, dass Sie den Code ändern müssen, mit dem der Name jedes Repositorys in „program.cs“ geschrieben wird:This change means you need to change the code that writes the name of each repository in program.cs:

Console.WriteLine(repo.Name);

Führen Sie dotnet run aus, um sicherzustellen, dass die Zuordnungen richtig sind.Execute dotnet run to make sure you've got the mappings correct. Es sollte dieselbe Ausgabe angezeigt werden wie zuvor.You should see the same output as before.

Führen wir eine weitere Änderung durch, bevor wir neue Features hinzufügen.Let's make one more change before adding new features. Die ProcessRepositories-Methode kann die asynchrone Arbeit erledigen und eine Auflistung der Repositorys zurückgeben.The ProcessRepositories method can do the async work and return a collection of the repositories. Geben wir die List<Repository> über diese Methode zurück, und verschieben wir den Code zum Schreiben dieser Informationen in die Main-Methode.Let's return the List<Repository> from that method, and move the code that writes the information into the Main method.

Ändern Sie die Signatur von ProcessRepositories, um einen Task zurückzugeben, dessen Ergebnis eine Liste mit Repository-Objekten ist:Change the signature of ProcessRepositories to return a task whose result is a list of Repository objects:

private static async Task<List<Repository>> ProcessRepositories()

Geben Sie anschließend einfach die Repositorys zurück, nachdem die JSON-Antwort verarbeitet wurde:Then, just return the repositories after processing the JSON response:

var streamTask = client.GetStreamAsync("https://api.github.com/orgs/dotnet/repos");
var repositories = await JsonSerializer.DeserializeAsync<List<Repository>>(await streamTask);
return repositories;

Der Compiler generiert das Task<T>-Objekt für die Rückgabe, weil Sie diese Methode als async markiert haben.The compiler generates the Task<T> object for the return because you've marked this method as async. Ändern wir dann die Main-Methode, sodass sie diese Ergebnisse erfasst und den Namen jedes Repositorys an die Konsole schreibt.Then, let's modify the Main method so that it captures those results and writes each repository name to the console. Ihre Main-Methode sieht nun folgendermaßen aus:Your Main method now looks like this:

public static async Task Main(string[] args)
{
    var repositories = await ProcessRepositories();

    foreach (var repo in repositories)
        Console.WriteLine(repo.Name);
}

Einlesen weiterer InformationenReading More Information

Zum Abschluss verarbeiten wir einige weitere Eigenschaften im JSON-Paket, das von der GitHub-API gesendet wird.Let's finish this by processing a few more of the properties in the JSON packet that gets sent from the GitHub API. Sie müssen nicht alle Informationen abrufen, aber das Hinzufügen einiger Eigenschaften veranschaulicht einige weitere Features von C#.You won't want to grab everything, but adding a few properties will demonstrate a few more features of the C# language.

Beginnen wir damit, ein paar weitere einfache Typen in die Definition der Repository-Klasse einzufügen.Let's start by adding a few more simple types to the Repository class definition. Fügen Sie diese Eigenschaften zu dieser Klasse hinzu:Add these properties to that class:

[JsonPropertyName("description")]
public string Description { get; set; }

[JsonPropertyName("html_url")]
public Uri GitHubHomeUrl { get; set; }

[JsonPropertyName("homepage")]
public Uri Homepage { get; set; }

[JsonPropertyName("watchers")]
public int Watchers { get; set; }

Diese Eigenschaften verfügen über integrierte Konvertierungen vom Zeichenfolgentyp (dieser ist in den JSON-Paketen enthalten) in den Zieltyp.These properties have built-in conversions from the string type (which is what the JSON packets contain) to the target type. Der Uri -Typ ist Ihnen möglicherweise neu.The Uri type may be new to you. Er repräsentiert einen URI, oder in diesem Fall eine URL.It represents a URI, or in this case, a URL. Im Fall der Uri- und int-Typen wird über die Serialisierungsaktion eine Ausnahme ausgelöst, wenn das JSON-Paket Daten enthält, die nicht in den Zieltyp konvertiert werden können.In the case of the Uri and int types, if the JSON packet contains data that does not convert to the target type, the serialization action will throw an exception.

Aktualisieren Sie nach dem Hinzufügen die Main-Methode, um diese Elemente anzuzeigen:Once you've added these, update the Main method to display those elements:

foreach (var repo in repositories)
{
    Console.WriteLine(repo.Name);
    Console.WriteLine(repo.Description);
    Console.WriteLine(repo.GitHubHomeUrl);
    Console.WriteLine(repo.Homepage);
    Console.WriteLine(repo.Watchers);
    Console.WriteLine();
}

Im letzten Schritt fügen wir jetzt die Informationen für den letzten Pushvorgang hinzu.As a final step, let's add the information for the last push operation. Diese Informationen werden in der JSON-Antwort folgendermaßen formatiert:This information is formatted in this fashion in the JSON response:

2016-02-08T21:27:00Z

Dieses Format verwendet die koordinierte Weltzeit (UTC), sodass Sie einen DateTime-Wert erhalten, dessen Kind-Eigenschaft Utc lautet.That format is in Coordinated Universal Time (UTC) so you'll get a DateTime value whose Kind property is Utc. Wenn Sie ein Datum in Ihrer Ortszeit bevorzugen, müssen Sie eine benutzerdefinierte Methode für die Konvertierung schreiben.If you prefer a date represented in your time zone, you'll need to write a custom conversion method. Definieren Sie zunächst eine public-Eigenschaft, die die UTC-Darstellung von Datum und Uhrzeit in Ihrer Repository-Klasse enthält, und eine LastPush readonly-Eigenschaft, die das konvertierte Datum in Ortszeit zurückgibt:First, define a public property that will hold the UTC representation of the date and time in your Repository class and a LastPush readonly property that returns the date converted to local time:

[JsonPropertyName("pushed_at")]
public DateTime LastPushUtc { get; set; }

public DateTime LastPush => LastPushUtc.ToLocalTime();

Gehen wir die soeben definierten neuen Konstrukte einzeln durch.Let's go over the new constructs we just defined. Die LastPush-Eigenschaft wird mit einem Ausdruckskörpermember für die get-Zugriffsmethode definiert.The LastPush property is defined using an expression-bodied member for the get accessor. Es ist kein set-Accessor vorhanden.There is no set accessor. Durch Auslassen der set-Zugriffsmethode definieren Sie eine schreibgeschützte Eigenschaft in C#.Omitting the set accessor is how you define a read-only property in C#. (Ja, Sie können lesegeschützte Eigenschaften in C# erstellen, aber ihr Wert ist begrenzt.)(Yes, you can create write-only properties in C#, but their value is limited.)

Abschließend fügen Sie eine weitere Ausgabeanweisung in der Konsole hinzu. Jetzt können Sie diese Anwendung erstellen und erneut ausführen:Finally, add one more output statement in the console, and you're ready to build and run this app again:

Console.WriteLine(repo.LastPush);

Ihre Version sollte nun der abgeschlossenen Version entsprechen.Your version should now match the finished sample.

SchlussbemerkungConclusion

In diesem Tutorial wurde gezeigt, wie Sie Webanforderungen ausführen, das Ergebnis analysieren und Eigenschaften dieser Ergebnisse anzeigen.This tutorial showed you how to make web requests, parse the result, and display properties of those results. Sie haben außerdem neue Pakete als abhängige Komponenten in Ihr Projekt eingefügt.You've also added new packages as dependencies in your project. Sie haben einige der Features von C# kennengelernt, die objektorientierte Verfahren unterstützen.You've seen some of the features of the C# language that support object-oriented techniques.

Sie müssen dotnet restore nicht ausführen, da der Befehl implizit von allen Befehlen ausgeführt wird, die eine Wiederherstellung erfordern. Zu diesen zählen z. B. dotnet new, dotnet build, dotnet run, dotnet test, dotnet publish und dotnet pack.You don't have to run dotnet restore because it's run implicitly by all commands that require a restore to occur, such as dotnet new, dotnet build, dotnet run, dotnet test, dotnet publish, and dotnet pack. Verwenden Sie die Option --no-restore, um die implizite Wiederherstellung zu deaktivieren.To disable implicit restore, use the --no-restore option.

In bestimmten Fällen eignet sich der dotnet restore-Befehl dennoch. Dies ist etwa bei Szenarios der Fall, in denen die explizite Wiederherstellung sinnvoll ist. Beispiele hierfür sind Continuous Integration-Builds in Azure DevOps Services oder Buildsysteme, die den Zeitpunkt für die Wiederherstellung explizit steuern müssen.The dotnet restore command is still useful in certain scenarios where explicitly restoring makes sense, such as continuous integration builds in Azure DevOps Services or in build systems that need to explicitly control when the restore occurs.

Informationen zum Verwalten von NuGet-Feeds finden Sie in der dotnet restoreDokumentation.For information about how to manage NuGet feeds, see the dotnet restore documentation.