Refit C# (Funktionsweise für Entwickler)

Typsichere API-Verfügbarkeit

Refit erkennt Fehler zur Kompilierungszeit und stellt sicher, dass Methodensignaturen den API-Endpunkten entsprechen. Die Möglichkeit von Laufzeitfehlern, die durch unpassende Endpunkte oder fehlerhafte Anfrageneinstellungen verursacht werden, wird durch diese Typensicherheit verringert.

HTTP-Client deklarativ

C#-Schnittstellen und -Attribute können von Entwicklern zur Erstellung von API-Endpunkten verwendet werden, was zu saubererem und wartbarerem HTTP-Anforderungscode führt. Dieser deklarative Ansatz abstrahiert die Komplexität der Implementierung einer HTTP-Anforderung je Client.

Automatische Serialisierung und Deserialisierung

Refit kümmert sich automatisch um die Umwandlung von C#-Objekten in JSON-Daten. Da Entwickler Anfrageträger nicht mehr manuell serialisieren oder Antworten deserialisieren müssen, wird die Datenverarbeitung deutlich vereinfacht.

Konfiguration auf der Grundlage von Attributen

Attribute werden verwendet, um HTTP-Methoden (wie GET, POST, PUT und DELETE) und Parameter zu definieren. Dies macht die Konfiguration einfach und leicht verständlich, da sie Header, Anfragekörper, Inhalt, Pfadparameter und Abfrageparameter umfasst.

Unterstützung für asynchrone Programmierung

Refit verwendet Task-basierte Methoden zur Handhabung asynchroner HTTP-Anfragen und ist so konzipiert, dass es nahtlos mit asynchronen Programmiermodellen in .NET zusammenarbeitet.

Anpassungsfähige Webbrowser

Der Kern des HTTP-Clients kann von Entwicklern angepasst werden, indem Timeout-Nummern, Standard-Header-Einstellungen und Nachrichtenkonfigurationen für Protokollierung, Authentifizierung und Wiederholungsrichtlinien geändert werden.

Integriertes Fehlermanagement

Refit verfügt über integrierte Funktionen zur Fehlerbehandlung von HTTP-Problemen, wodurch es Entwicklern leicht gemacht wird, ihre eigene benutzerdefinierte Fehlerbehandlungslogik einzubauen.

Anpassungsfähigkeit

Entwickler können mehrere Formate verwenden oder ungewöhnliche Datentypen mit Refits Unterstützung für benutzerdefinierte Serialisierungs- und Deserialisierungskonverter behandeln.

Kombinierte Integration von Dependency Injection

Refit ist eine hervorragende Ergänzung für moderne .NET-Anwendungen, die bewährte Praktiken für Abhängigkeitsinjektion (DI) befolgen, da sie einfach in DI-Anwendungen integriert werden kann.

Unterstützung bei der Verifizierung

Zur Sicherung von API-Anrufen macht Refit es einfach, Authentifizierungsheader, Schnittstellenmethoden wie Trägertoken und Basis-Authentifizierung zu konfigurieren.

Es ist einfach, ein Konsolenprojekt mit Visual Studio zu erstellen. Um eine Konsolenanwendung in Visual Studio zu erstellen, befolgen Sie diese Schritte:

Stellen Sie vor der Nutzung von Visual Studio sicher, dass es auf Ihrem Computer installiert ist.

Ein neues Projekt starten

Öffnen Sie Visual Studio und klicken Sie auf die Option "Ein neues Projekt erstellen".

Wählen Sie aus der Auswahl auf der linken Seite des Fensters "Ein neues Projekt erstellen" Ihre bevorzugte Programmiersprache (z.B. C#).

Aus der folgenden Projektreferenzvorlage können Sie die "Konsolen-App"- oder "Konsolen-App (.NET Core)"-Vorlage auswählen.

Geben Sie Ihrem Projekt einen Namen und wählen Sie den Speicherort des Projekts aus.

Wählen Sie das entsprechende .NET Framework aus. Klicken Sie dann auf "Erstellen", um das Konsolenanwendungsprojekt zu erstellen.

Erstellen Sie eine Schnittstelle für Ihre API. Um die HTTP-Methoden und Endpunkte zu definieren, verwenden Sie die Refit-Attribute.

using Refit;
using System.Threading.Tasks;

// Define the API interface
public interface IMyApi
{
    // Get user details by ID
    [Get("/users/{id}")]
    Task<User> GetUserAsync(int id);

    // Create a new user
    [Post("/users")]
    Task<User> CreateUserAsync([Body] User user);
}

// Define the User class
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Other properties...
}

using Refit;
using System.Threading.Tasks;

// Define the API interface
public interface IMyApi
{
    // Get user details by ID
    [Get("/users/{id}")]
    Task<User> GetUserAsync(int id);

    // Create a new user
    [Post("/users")]
    Task<User> CreateUserAsync([Body] User user);
}

// Define the User class
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Other properties...
}

Imports Refit
Imports System.Threading.Tasks

' Define the API interface
Public Interface IMyApi
	' Get user details by ID
	<[Get]("/users/{id}")>
	Function GetUserAsync(ByVal id As Integer) As Task(Of User)

	' Create a new user
	<Post("/users")>
	Function CreateUserAsync(<Body> ByVal user As User) As Task(Of User)
End Interface

' Define the User class
Public Class User
	Public Property Id() As Integer
	Public Property Name() As String
	' Other properties...
End Class

Erstellen und Konfigurieren des Refit-Client

Starten Sie den Refit-Client und passen Sie seine Einstellungen nach Bedarf an. Dies kann direkt in Ihrem Hauptcode oder in einem Dienst, unter anderem, an verschiedenen Stellen in Ihrer Anwendung implementiert werden.

using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the base URL of your API
        var apiClient = RestService.For<IMyApi>("https://api.example.com");

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Define the base URL of your API
        var apiClient = RestService.For<IMyApi>("https://api.example.com");

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

Imports Refit
Imports System
Imports System.Threading.Tasks

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Define the base URL of your API
		Dim apiClient = RestService.For(Of IMyApi)("https://api.example.com")

		' Use the API client to make requests
		Dim user = Await apiClient.GetUserAsync(1)
		Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}")

		' Create a new user
		Dim newUser = New User With {.Name = "John Doe"}
		Dim createdUser = Await apiClient.CreateUserAsync(newUser)
		Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}")
	End Function
End Class

Erweiterte Konfiguration

Indem Sie den zugrunde liegenden HttpClient konfigurieren, können Sie den Refit-Client weiter personalisieren. Zum Beispiel können Sie Zeitlimits festlegen, ein Header-Attribut anwenden, Standardheader hinzufügen oder Nachrichtenkonfigurationen für Wiederholungsrichtlinien, Authentifizierung und Protokollierung verwenden.

using System.Net.Http;
using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Configure HttpClient with custom handler and timeout
        var httpClient = new HttpClient(new HttpClientHandler
        {
            // Customize the HttpClientHandler as needed
        })
        {
            BaseAddress = new Uri("https://api.example.com"),
            Timeout = TimeSpan.FromSeconds(30)
        };

        // Add default headers if needed
        httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_TOKEN_HERE");

        // Create the Refit API client
        var apiClient = RestService.For<IMyApi>(httpClient);

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

using System.Net.Http;
using Refit;
using System;
using System.Threading.Tasks;

public class Program
{
    public static async Task Main(string[] args)
    {
        // Configure HttpClient with custom handler and timeout
        var httpClient = new HttpClient(new HttpClientHandler
        {
            // Customize the HttpClientHandler as needed
        })
        {
            BaseAddress = new Uri("https://api.example.com"),
            Timeout = TimeSpan.FromSeconds(30)
        };

        // Add default headers if needed
        httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_TOKEN_HERE");

        // Create the Refit API client
        var apiClient = RestService.For<IMyApi>(httpClient);

        // Use the API client to make requests
        var user = await apiClient.GetUserAsync(1);
        Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}");

        // Create a new user
        var newUser = new User { Name = "John Doe" };
        var createdUser = await apiClient.CreateUserAsync(newUser);
        Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}");
    }
}

Imports System.Net.Http
Imports Refit
Imports System
Imports System.Threading.Tasks

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Configure HttpClient with custom handler and timeout
		Dim httpClient As New HttpClient(New HttpClientHandler ) With {
			.BaseAddress = New Uri("https://api.example.com"),
			.Timeout = TimeSpan.FromSeconds(30)
		}

		' Add default headers if needed
		httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_TOKEN_HERE")

		' Create the Refit API client
		Dim apiClient = RestService.For(Of IMyApi)(httpClient)

		' Use the API client to make requests
		Dim user = Await apiClient.GetUserAsync(1)
		Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}")

		' Create a new user
		Dim newUser = New User With {.Name = "John Doe"}
		Dim createdUser = Await apiClient.CreateUserAsync(newUser)
		Console.WriteLine($"Created User ID: {createdUser.Id}, Name: {createdUser.Name}")
	End Function
End Class

Sie können typensichere und wartbare RESTful-API-Nutzung erreichen, indem Sie einen Refit-Client in C# erstellen und konfigurieren, indem Sie diese Anweisungen befolgen.

Konvertierung von HTML in PDF

IronPDF ermöglicht es Ihnen, hochwertige PDF-Dokumente unter Verwendung von HTML-Inhalt zu erstellen, einschließlich CSS und JavaScript. Diese Funktionalität ist sehr hilfreich, um PDFs aus dynamischen Inhalten oder Webseiten zu erstellen.

Bearbeiten und Manipulieren von PDFs

IronPDF bietet Modifikationstools für bereits vorhandene PDF-Dokumente. Es ist möglich, Seiten aus einem PDF zu extrahieren, Text, Bilder, Wasserzeichen oder Anmerkungen hinzuzufügen und mehrere PDFs in ein Dokument zu kombinieren.

Eine PDF-Datei von Grund auf neu erstellen

Mit dem IronPDF-API können Sie Text, Bilder, Formen und andere Objekte zu neuen PDF-Dokumenten programmatisch hinzufügen. Dies ermöglicht es, PDF-Rechnungen, Berichte und andere dokumentenbasierte Ausgaben dynamisch zu generieren.

Sicherheit von PDFs

Es ist möglich, PDF-Dokumente mit IronPDF zu verschlüsseln und Passwort-Sicherheit hinzuzufügen, um den Zugriff zu verwalten und sensible Daten zu schützen.

Formulare im PDF-Format

Durch das Ausfüllen von Formularfeldern können Benutzer mit PDF-Dokumenten interagieren, indem sie PDF-Formulare mit IronPDF erstellen und ausfüllen.

Textextraktionen

IronPDF erleichtert die einfache Suche, Analyse und Manipulation von Textdaten, indem es den Textinhalt aus PDF-Dokumenten extrahiert.

Transformation in Bildformate

IronPDF ist für Situationen geeignet, in denen Bilder anstelle von PDFs erforderlich sind, da es PDF-Dokumente in gängige Bildformate wie PNG, JPEG und BMP konvertieren kann.