Führen Sie einen CURL-Aufruf in C# durch

1. Verwenden Sie HttpWebRequest oder HttpWebResponse, um einen CURL-Aufruf in C# zu tätigen
2. Verwenden Sie WebClient, um einen CURL-Aufruf in C# zu tätigen
3. Verwenden Sie HttpClient, um einen CURL-Aufruf in C# zu tätigen
4. Abschluss

Die Client-URL (cURL) ist der De-facto-Standard für die API-Dokumentation in C#. Es erfordert eine Konvertierung von einem Format in ein anderes.

Daher ist die Umwandlung von JSON in eine C#-Klasse ein recht beliebter Ansatz. Das Antwortobjekt aus dem Web oder Host wird ebenfalls in eine C#-Klasse konvertiert, um es entwicklerfreundlicher zu machen.

In diesem Artikel werden drei Ansätze zum Ausführen eines cURL-Aufrufs in C# erläutert.

Erstellen Sie eine Kommunikation mit dem Server, indem Sie den Standort und die Daten angeben, die Sie mit cURL in C# senden möchten. Da die URL jedem cURL-Befehl folgt, ruft sie immer einige Daten ab und gibt die HTML-Quelle für eine cURL zurück.

cURL ist sehr portabel und mit fast jedem Betriebssystem und angeschlossenen Gerät kompatibel. In C# ist cURL nützlich zum Testen von Endpunkten und liefert Details darüber, was genau gesendet oder empfangen wurde, was gut für die Fehlerprotokollierung und das Debugging ist.

Da cURL libcurl verwendet, unterstützt es die gleiche Bandbreite gängiger Internetprotokolle wie libcurl.

Verwenden Sie HttpWebRequest oder HttpWebResponse, um einen CURL-Aufruf in C# zu tätigen

Die Klasse HttpWebRequest unterstützt die in WebRequest definierten Methoden und Eigenschaften. Seine zusätzlichen Eigenschaften und Methoden ermöglichen es den Benutzern, direkt mit Servern über HTTP zu interagieren.

Verwenden Sie die Methode WebRequest.Create, um neue HttpWebRequest-Objekte zu initialisieren. Verwenden Sie die Methode GetResponse, um eine synchrone Anfrage an die Ressource zu stellen, die in der Eigenschaft RequestUri angegeben ist.

Es gibt eine HttpWebResponse zurück, die das Response-Objekt enthält. Bei einem geschlossenen Response-Objekt werden die verbleibenden Daten angereichert.

Es handelt sich um eine Keep-Alive- oder Pipeline-Anfrage; Es müssen nur wenige Daten in kurzen Intervallen empfangen werden. In C# enthält das .NET-Framework ein neues Sicherheitsfeature, das unsichere Verschlüsselungs- und Hashalgorithmen für Verbindungen und Ziele blockiert, die standardmäßig das sicherere Verhalten erhalten.

// create a separate class

// Include the `System.Net` and `System.IO` into your C# project and install NuGet `Newtonsoft.Json`
// package before executing the C# code.
using System.Net;
using System.IO;
using Newtonsoft.Json;

namespace cURLCall {
  public class gta_allCustomersResponse {
    public static void gta_AllCustomers() {
      var httpWebRequest = (HttpWebRequest)WebRequest.Create(
          "https://api.somewhere.com/desk/external_api/v1/customers.json");
      httpWebRequest.ContentType = "application/json";
      httpWebRequest.Accept = "*/*";
      httpWebRequest.Method = "GET";
      httpWebRequest.Headers.Add("Authorization", "Basic reallylongstring");

      var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();

      using (var streamReader = new StreamReader(httpResponse.GetResponseStream())) {
        gta_allCustomersResponse answer =
            JsonConvert.DeserializeObject<gta_allCustomersResponse>(streamReader.ReadToEnd());
        // return answer;
      }
    }
  }
}

Rufen Sie die Methode gta_AllCustomers() der Klasse gta_allCustomersResponse im Hauptformular auf, um einen cURL-Aufruf durchzuführen.

using static cURLCall.gta_allCustomersResponse;

gta_AllCustomers();

Die HttpWebResponse unterstützt HTTP-spezifische Benutzer der Eigenschaften und Methoden der WebResponse-Klasse, um einen cURL-Aufruf in C# durchzuführen. Erstellen Sie eine Instanz der Klasse HttpWebResponse und schließen Sie die Antwort, indem Sie die Methoden Stream.Close oder HttpWebResponse.Close aufrufen, und geben Sie die Verbindung zur Wiederverwendung frei, sobald die Antwort erfolgreich empfangen wurde.

Verwenden Sie WebClient, um einen CURL-Aufruf in C# zu tätigen

Die Klasse WebClient stellt Datenumwandlungs- oder Empfangsmethoden über die lokale oder Internetressource bereit, die durch einen URI identifiziert wird. Es verwendet die Klasse WebRequest, um den Zugriff auf Ressourcen bereitzustellen.

Der WebClient ist eine Abstraktion auf höherer Ebene, die auf HttpWebRequest aufbaut, um die häufigsten Aufgaben für einen cURL-Aufruf in C# zu vereinfachen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using Newtonsoft.Json;

namespace cURLCall {
  public static class StaticItems {
    public static string EndPoint = "http://localhost:8088/api/";
  }

  public class CityInfo {
    public int CityID { get; set; }
    public int CountryID { get; set; }
    public int StateID { get; set; }
    public string Name { get; set; }
    public decimal Latitude { get; set; }
    public decimal Longitude { get; set; }
  }

  public class receiveData {
    public List<CityInfo> CityGet() {
      try {
        using (WebClient webClient = new WebClient()) {
          webClient.BaseAddress = StaticItems.EndPoint;
          var json = webClient.DownloadString("City/CityGetForDDL");
          var list = JsonConvert.DeserializeObject<List<CityInfo>>(json);
          return list.ToList();
        }
      } catch (WebException ex) {
        throw ex;
      }
    }
  }
  public class ReturnMessageInfo {
    public ReturnMessageInfo CitySave(CityInfo city) {
      ReturnMessageInfo result = new ReturnMessageInfo();
      try {
        using (WebClient webClient = new WebClient()) {
          webClient.BaseAddress = StaticItems.EndPoint;
          var url = "City/CityAddUpdate";
          webClient.Headers.Add(
              "user-agent",
              "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)");
          webClient.Headers[HttpRequestHeader.ContentType] = "application/json";
          string data = JsonConvert.SerializeObject(city);
          var response = webClient.UploadString(url, data);
          result = JsonConvert.DeserializeObject<ReturnMessageInfo>(response);
          return result;
        }
      } catch (Exception ex) {
        throw ex;
      }
    }
  }
}

Klassen wie FileWebRequest und FtpWebRequest erben von WebRequest. Im Allgemeinen können Sie WebRequest verwenden, um eine Anfrage zu stellen und die Rückgabe je nach Anfrage entweder in HttpWebRequest, FileWebRequest oder FtpWebRequest umzuwandeln.

Es ist eine der idealen Methoden, um einen cURL-Aufruf zu tätigen, indem allgemeine Vorgänge zum Senden und Empfangen von Daten von einer durch einen URI identifizierten Ressource bereitgestellt werden.

Verwenden Sie HttpClient, um einen CURL-Aufruf in C# zu tätigen

Die Klasse HttpClient ist so konzipiert, dass sie viel besser ist als jede andere Klasse, die Methoden zum Senden von HTTP-Anforderungen und zum Empfangen von HTTP-Antworten von einer durch einen URI identifizierten Ressource bietet. Seine Instanz ist eine Sammlung von Einstellungen, die auf alle Anforderungen angewendet werden, die als Sitzung zum Senden von HTTP-Anforderungen fungieren.

Zudem verwendet jede HttpClient-Instanz bei jedem cURL-Aufruf ihren Verbindungspool.

In C# soll HttpClient einmal instanziiert und während der gesamten Lebensdauer einer Anwendung wiederverwendet werden. Als API auf höherer Ebene umschließt HttpClient die Funktionalität auf niedrigerer Ebene auf jeder verfügbaren Plattform (einschließlich Plattformen, auf denen es ausgeführt wird).

Darüber hinaus ist das Verhalten dieser Klasse anpassbar, um einen erheblichen Leistungsvorteil zu erzielen, insbesondere für HTTP-Anforderungen. Laufzeitkonfigurationsoptionen in .NET können HttpClient konfigurieren, um sein Verhalten anzupassen.

using System;
using System.Text;
using System.Threading.Tasks;
using System.Net.Http;
using Newtonsoft.Json;

class UserInfo {
  public string UserName { get; set; }
  public string Email { get; set; }

  public override string ToString() {
    return $"{UserName}: {Email}";
  }
}

class cURLCall {
  static async Task Main(string[] args) {
    var user = new UserInfo();
    user.UserName = "My Name";
    user.Email = "myname4321@exp.com";

    var json = JsonConvert.SerializeObject(person);
    var data = new StringContent(json, Encoding.UTF8, "application/json");

    var url = "https://httpbin.org/post";
    var client = new HttpClient();

    var response = await client.PostAsync(url, data);

    string result = response.Content.ReadAsStringAsync().Result;

    // processed user info thorugh HttpClient
    Console.WriteLine(result);
  }
}

Die Klasse HttpClient hat eine bessere Unterstützung für die Handhabung verschiedener Antworttypen und bietet auch eine bessere Unterstützung für asynchrone Operationen als die zuvor erwähnten Optionen.

Abschluss

Dieser Artikel hat Ihnen drei nützliche Methoden zum Ausführen eines cURL-Aufrufs in C# beigebracht. Sie können jetzt den C#-Code verwenden, um cURL-Aufrufe durchzuführen, um Ihre Endpunkte zu testen und Fehler in Ihren C#-Anwendungen zu beheben.