Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. Nswag C#
.NET HILFE

Nswag C# (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

APIs sind in der heutigen Softwareentwicklungsumgebung unerlässlich, da sie die Kommunikation zwischen verschiedenen Softwaresystemen und -komponenten erleichtern. Damit Entwickler APIs effizient nutzen können, muss eine umfassende und verständliche Dokumentation vorhanden sein. Zwei effektive Tools, die den C#-API-Dokumentationsworkflow unterstützen können, sind NSwag C# und IronPDF. Dieser Beitrag beschreibt, wie man NSwag verwendet, um API-Spezifikationen mit .NET Core zu erstellen und hochwertige PDF-Dokumente aus diesen Spezifikationen mit IronPDF zu erzeugen.

Wie verwendet man NSwag in C#?

  1. Erstellen Sie eine RESTful-Web-API mit Swagger UI.
  2. Erstellen Sie eine C#-Konsolenanwendung.
  3. Installieren Sie die NSwag-Bibliothek.
  4. Importieren Sie den Namespace und erstellen Sie das Objekt.
  5. Verarbeiten Sie das Swagger-JSON zu C#-Code.
  6. Führen Sie den Code aus und zeigen Sie das Ergebnis an.

NSwag verstehen

Eine .NET Swagger-Toolchain namens NSwag wurde erstellt, um die Erstellung von Swagger-Spezifikationen oder OpenAPI-Dokumenten für APIs zu erleichtern, die mit ASP.NET Web API, ASP.NET Core oder anderen .NET-Frameworks erstellt wurden.

Funktionen von NSwag

Produktion von Swagger Specs

Kontroller, Modelle und .NET-Assemblys können alle von NSwag genutzt werden, um automatisch Swagger-Spezifikationen zu erzeugen. NSwag generiert umfassende Dokumentationen, die API-Endpunkte, Anforderungs-/Antwortformulare, Authentifizierungsmethoden und mehr abdecken, indem es die Struktur des API-Codes analysiert.

Verbindung zu .NET-Projekten

Entwickler können die Swagger-Erstellung einfach in ihre Entwicklungsprozesse integrieren, indem sie NSwag mit .NET-Projekten verbinden. Entwickler können sicherstellen, dass die Dokumentation mit der Codebasis aktualisiert wird, indem sie NSwag zu einem .NET Core-Projekt hinzufügen, das automatisch Swagger-Spezifikationen erzeugt, jedes Mal, wenn das Projekt erstellt wird.

Personalisierung und Erweiterung

Mit den zahlreichen Anpassungsmöglichkeiten, die NSwag bietet, können Entwickler die generierten Swagger-Spezifikationen mühelos an ihre speziellen Bedürfnisse anpassen. Durch Konfigurationseinstellungen und Anmerkungen haben Entwickler die Kontrolle über viele Komponenten der generierten Dokumentation, einschließlich Antwortcodes, Parametererklärungen und Routenbenennungskonventionen.

Einstieg mit NSwag

Einrichten von NSwag in C# Console App

Die NSwag-Basisclass-Bibliothek enthält den Kern, Annotationen und den Code-Generierungs-Namespace, der durch Installation aus NuGet verfügbar sein sollte. Um NSwag in eine C#-Anwendung zu integrieren, um Code und Swagger-Spezifikationen zu erzeugen, und wie NSwag die Effizienz des Entwicklungsprozesses verbessern kann.

NSwag C# (Wie es für Entwickler funktioniert): Abbildung 1 - Browsen Sie nach NSwag im Visual Studio-Paket-Manager und installieren Sie es

Implementierung von NSwag in Windows Console und Forms

Durch die automatisierte Generierung von Clients können Entwickler effizient Code für den Zugriff auf APIs direkt aus ihren Desktop-Apps erstellen, indem sie NSwag in eine Windows-Desktop-Anwendung integrieren. Beim Entwickeln von Desktop-Anwendungen, die mit Onlinediensten oder RESTful-APIs kommunizieren, kann dies sehr hilfreich sein.

NSwag kann in Webanwendungen verwendet werden, um API-Dokumentationen für interne APIs zu generieren und Client-Code für den Verbrauch externer APIs zu erstellen. Dies unterstützt Entwickler dabei, die Frontend- und Backend-Komponenten ihrer Anwendungen konsistent zu halten.

NSwag C# Beispiel

Hier ist ein Beispielcode, der Ihnen zeigt, wie Sie NSwag verwenden, um C#-Clientcode zu erzeugen:

using NSwag.CodeGeneration.CSharp;
using NSwag;
using System.Reflection;
using System.CodeDom.Compiler;
using Microsoft.CodeAnalysis;
using System.Net.Http;
using System.IO;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        using (var wclient = new System.Net.WebClient())
        {
            // Create JSON file data from the Swagger .NET Core web API
            var document = await OpenApiDocument.FromJsonAsync(wclient.DownloadString("http://localhost:5013/swagger/v1/swagger.json"));
            var settings = new CSharpClientGeneratorSettings
            {
                ClassName = "Weather",
                CSharpGeneratorSettings = { Namespace = "Demo" }
            };

            var generator = new CSharpClientGenerator(document, settings);
            var code = generator.GenerateFile();
            var assembly = CompileCode(code);
            var clientType = assembly.GetType("Demo.WeatherClient"); // Replace with your actual client class name
            using (var httpClient = new HttpClient())
            {
                var client = (IApiClient)Activator.CreateInstance(clientType, httpClient);
                var result = await client.GetWeatherForecastAsync();
                foreach (var item in result)
                {
                    Console.WriteLine($"Date: {item.Date} F: {item.TemperatureF} C: {item.TemperatureC} Summary: {item.Summary}");
                }
            }
        }
    }

    static Assembly CompileCode(string code)
    {
        using (var memoryStream = new MemoryStream())
        {
            var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
            var references = new List<MetadataReference>
            {
                MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location),
                MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "Microsoft.AspNetCore.Mvc.dll")),
                MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Private.CoreLib.dll"))
            };

            var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("ApiClient")
                .WithOptions(new Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
                .AddReferences(references)
                .AddSyntaxTrees(Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(code));

            var emitResult = compilation.Emit(memoryStream);
            if (!emitResult.Success)
            {
                Console.WriteLine("Compilation errors:");
                foreach (var diagnostic in emitResult.Diagnostics)
                {
                    Console.WriteLine(diagnostic);
                }
                return null;
            }
            memoryStream.Seek(0, SeekOrigin.Begin);
            return Assembly.Load(memoryStream.ToArray());
        }
    }

    public interface IApiClient
    {
        // Replace with your actual method name and return type
        Task<List<WeatherForecast>> GetWeatherForecastAsync();
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public int TemperatureF { get; set; }
        public string Summary { get; set; }
    }
}
using NSwag.CodeGeneration.CSharp;
using NSwag;
using System.Reflection;
using System.CodeDom.Compiler;
using Microsoft.CodeAnalysis;
using System.Net.Http;
using System.IO;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        using (var wclient = new System.Net.WebClient())
        {
            // Create JSON file data from the Swagger .NET Core web API
            var document = await OpenApiDocument.FromJsonAsync(wclient.DownloadString("http://localhost:5013/swagger/v1/swagger.json"));
            var settings = new CSharpClientGeneratorSettings
            {
                ClassName = "Weather",
                CSharpGeneratorSettings = { Namespace = "Demo" }
            };

            var generator = new CSharpClientGenerator(document, settings);
            var code = generator.GenerateFile();
            var assembly = CompileCode(code);
            var clientType = assembly.GetType("Demo.WeatherClient"); // Replace with your actual client class name
            using (var httpClient = new HttpClient())
            {
                var client = (IApiClient)Activator.CreateInstance(clientType, httpClient);
                var result = await client.GetWeatherForecastAsync();
                foreach (var item in result)
                {
                    Console.WriteLine($"Date: {item.Date} F: {item.TemperatureF} C: {item.TemperatureC} Summary: {item.Summary}");
                }
            }
        }
    }

    static Assembly CompileCode(string code)
    {
        using (var memoryStream = new MemoryStream())
        {
            var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
            var references = new List<MetadataReference>
            {
                MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location),
                MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "Microsoft.AspNetCore.Mvc.dll")),
                MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Private.CoreLib.dll"))
            };

            var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("ApiClient")
                .WithOptions(new Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
                .AddReferences(references)
                .AddSyntaxTrees(Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(code));

            var emitResult = compilation.Emit(memoryStream);
            if (!emitResult.Success)
            {
                Console.WriteLine("Compilation errors:");
                foreach (var diagnostic in emitResult.Diagnostics)
                {
                    Console.WriteLine(diagnostic);
                }
                return null;
            }
            memoryStream.Seek(0, SeekOrigin.Begin);
            return Assembly.Load(memoryStream.ToArray());
        }
    }

    public interface IApiClient
    {
        // Replace with your actual method name and return type
        Task<List<WeatherForecast>> GetWeatherForecastAsync();
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public int TemperatureF { get; set; }
        public string Summary { get; set; }
    }
}
$vbLabelText   $csharpLabel

Für die API, die wir verwenden möchten, geben wir die URL der Swagger-Spezifikation (swaggerUrl) an. Dann wird der generierte und ausgeführte Clientcode in einer DLL-Assembly definiert. OpenApiDocument wird verwendet, um das Swagger-Dokument asynchron von der angegebenen URL mit FromJsonAsync zu laden. Um den generierten Clientcode zu ändern, passen wir die Einstellungen des Codegenerators (CSharpClientGeneratorSettings) an. In diesem Beispiel sind der Klassenname und der Namespace des erzeugten Clientcodes angegeben.

Aus dem geladenen Swagger-Dokument konstruieren wir eine Instanz von CSharpClientGenerator und verwenden sie, um den Clientcode zu erzeugen. Der erstellte Clientcode wird am angegebenen Ausgabepfad gespeichert. Wir reagieren auf etwaige Ausnahmen oder Fehler, die während des Verfahrens auftreten können, indem wir die relevanten Benachrichtigungen auf der Konsole anzeigen.

NSwag C# (Wie es für Entwickler funktioniert): Abbildung 2 - Konsolenausgabe des obigen Codes

NSwag Betrieb

Generierung von Client-Code

NSwag kann eine Swagger-Spezifikation verwenden, um Client-Code in vielen Sprachen zu generieren, darunter Java, TypeScript und C#. Dies erleichtert es den Entwicklern, APIs in ihren Anwendungen zu verwenden.

Erzeugung von Server-Code

Mithilfe einer Swagger-Spezifikation als Basis kann NSwag auch Server-Code, wie ASP.NET Core-Kontroller, erstellen. Dies hilft, serverseitigen Code für API-Implementierungen schnell zu erstellen.

Erstellung einer interaktiven API-Dokumentation

Mit einer gegebenen Swagger-Spezifikation kann NSwag interaktive API-Dokumentationen erzeugen, wie Swagger UI. Diese Dokumentation bietet eine benutzerfreundliche Oberfläche zum Erkunden und Testen von API-Endpunkten.

Proxy-Klassen erstellen

Um sich mit SOAP-basierten APIs zu integrieren, kann NSwag Proxy-Klassen erzeugen. Dies ermöglicht es Programmierern, mit generiertem Client-Code auf SOAP-Dienste aus ihren Anwendungen zuzugreifen.

Überprüfung von Swagger-Spezifikationen

NSwag ist in der Lage, Swagger-Spezifikationen zu verifizieren, um sicherzustellen, dass sie dem OpenAPI/Swagger-Standard entsprechen. Dies erleichtert das Erkennen von Fehlern oder Abweichungen in der API-Dokumentation.

Integration von NSwag mit IronPDF

Entwickler können den Workflow für API-Dokumentationen verbessern, indem sie die Vorteile beider Technologien durch Integration von NSwag mit IronPDF nutzen. Entwickler können umfassende, offline-fähige .NET-Web-API-Dokumentationen produzieren, die leicht zugänglich und teilbar sind, indem sie NSwag verwenden, um Swagger-Spezifikationen zu erzeugen und IronPDF, um sie in PDFs zu konvertieren. Zum Integrationsprozess gehören die folgenden Verfahren:

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
$vbLabelText   $csharpLabel

IronPDF installieren

  • Starten Sie das Visual Studio-Projekt.
  • Wählen Sie "Tools" > "NuGet-Paket-Manager" > "Paket-Manager-Konsole".
  • Öffnen Sie Ihr Befehlszeilenfenster und geben Sie im Paketmanager-Konsolenfenster den folgenden Befehl ein:
Install-Package IronPdf
  • Alternativ können Sie IronPDF verwenden, indem Sie den NuGet-Paket-Manager für Lösungen nutzen.
  • Erkunden und wählen Sie das IronPDF-Paket aus den Suchergebnissen aus und klicken Sie dann auf die Option "Installieren". Visual Studio kümmert sich um den Download und die Installation in Ihrem Namen.

NSwag C# (Wie es für Entwickler funktioniert): Abbildung 3 - Installieren Sie IronPDF mithilfe der Verwaltung von NuGet-Paketen für die Lösung, indem Sie IronPDF in der Suchleiste des NuGet-Paketmanagers suchen, dann das Projekt auswählen und auf die Installationsschaltfläche klicken.

  • NuGet wird das IronPDF-Paket und alle Abhängigkeiten, die für Ihr Projekt erforderlich sind, installieren.
  • Nach der Installation kann IronPDF für Ihr Projekt genutzt werden.

Installation über die NuGet-Website

Für zusätzliche Informationen zu den Funktionen, der Kompatibilität und den verfügbaren Downloads von IronPDF besuchen Sie die IronPDF-Seite auf NuGet.

DLL zum Installieren verwenden

Alternativ können Sie IronPDF direkt in Ihr Projekt einbinden, indem Sie dessen DLL-Datei verwenden. Zum Herunterladen der ZIP-Datei mit der DLL klicken Sie auf den IronPDF-Download-Link. Entpacken Sie die Datei und fügen Sie die DLL zu Ihrem Projekt hinzu.

Implementierung von Logik

Durch die Nutzung von NSwag können Entwickler API-Dokumentationen und Client-Code für die Verwendung von APIs schneller erstellen, indem sie CodeGeneration.CSharp in Kombination mit IronPDF verwenden. Die folgenden Schritte sind Teil des Integrations-Workflows:

  1. Client-Code erzeugen: Um C#-Clientcode aus Swagger-Spezifikationen zu erstellen, verwenden Sie NSwag.CodeGeneration.CSharp. In diesem Schritt wird die Erstellung von Client-Klassen und -Methoden zur Kommunikation mit den API-Endpunkten automatisiert.
  2. NSwag nutzen, um Daten zu erhalten: Um aus Swagger-Spezifikationen JSON-Dokumentationen zu erzeugen, verwenden Sie CodeGeneration.CSharp. In diesem Stadium werden die Anforderungs-/Antwortformate, Authentifizierungstechniken und API-Client-Endpunkte in menschenlesbare Dokumentationen erstellt.
  3. JSON in PDF konvertieren: Verwenden Sie IronPDF, um das erzeugte Codergebnis in ein PDF-Dokument zu konvertieren. In diesem Stadium wird der HTML-Text in ein professionell gestaltetes PDF-Dokument umgewandelt, das für das Teilen und Verteilen bereit ist.
  4. PDF-Dokumentation verbessern: Fügen Sie der PDF-Dokumentation mit IronPDF zusätzliche Inhalte hinzu, wie z.B. Kopf- und Fußzeilen, Wasserzeichen oder spezielle Markenembleme. Dieses Stadium gibt Entwicklern die Möglichkeit, das Erscheinungsbild und die Marke der PDF-Dokumentation nach ihren Vorlieben zu personalisieren.
using IronPdf;
using System.Text;
using System.Collections.Generic;

StringBuilder sb = new StringBuilder();

foreach (var item in result)
{
    sb.Append($"<p>Date: {item.Date} F: {item.TemperatureF} C: {item.TemperatureC} Summary: {item.Summary}</p>");
}

var renderer = new HtmlToPdf();
var pdf = renderer.RenderHtmlAsPdf(sb.ToString());
pdf.SaveAs("output.pdf");
Console.WriteLine("PDF generated successfully!");
Console.ReadKey();
using IronPdf;
using System.Text;
using System.Collections.Generic;

StringBuilder sb = new StringBuilder();

foreach (var item in result)
{
    sb.Append($"<p>Date: {item.Date} F: {item.TemperatureF} C: {item.TemperatureC} Summary: {item.Summary}</p>");
}

var renderer = new HtmlToPdf();
var pdf = renderer.RenderHtmlAsPdf(sb.ToString());
pdf.SaveAs("output.pdf");
Console.WriteLine("PDF generated successfully!");
Console.ReadKey();
$vbLabelText   $csharpLabel

Der obige Code greift auf die abgerufenen Daten aus dem Ergebnisobjekt zu und fügt die Felder Date, TemperatureF, TemperatureC und Summary in einer Schleife zu Absätzen hinzu. Anschließend wird der Ausgabepfad für die PDF-Datei angegeben, und der Benutzer wird benachrichtigt, dass ein PDF erfolgreich erstellt wurde.

Nachfolgend ist das Ergebnis des obigen Codes zu sehen.

NSwag C# (Wie es für Entwickler funktioniert): Abbildung 4 - Beispielausgabe des obigen Codes

Abschluss

CodeGeneration NSwag-Technologien wie CSharp und IronPDF arbeiten gut zusammen, um Client-Code-Erstellungs- und API-Dokumentationsprozesse zu optimieren. Entwickler können die Erstellung API-gesteuerter Lösungen beschleunigen, die Erstellung von API-Dokumentationen automatisieren und professionell aussehende PDF-Veröffentlichungen erzeugen, indem sie diese Tools in C#-Anwendungen integrieren. NSwag.CodeGeneration.CSharp mit IronPDF bietet Entwicklern eine umfassende Lösung zur effizienten Dokumentation von APIs und zum Erstellen von Client-Code in C#, unabhängig davon, ob sie Desktop-, Web- oder Cloud-basierte Apps entwickeln.

Das Lite-Paket enthält eine unbefristete Lizenz, ein Jahr Softwarewartung und ein Upgrade für die Bibliothek. IronPDF bietet kostenlose Lizenzen mit Einschränkungen bei der Weiterverbreitung und Zeit. Benutzer können die Lösung während der Testphase ohne Sichtbarkeit eines Wasserzeichens bewerten. Für zusätzliche Informationen zu Preis und Lizenzierung siehe IronPDF-Lizenzinformationen. Besuchen Sie die Iron Software-Bibliotheksseite für zusätzliche Informationen zu den Bibliotheken der Iron Software-Produkte.

Häufig gestellte Fragen

Wie kann NSwag bei der Generierung von API-Spezifikationen in C# helfen?

NSwag kann API-Spezifikationen, bekannt als Swagger oder OpenAPI-Dokumente, automatisch aus .NET Core-Projekten generieren. Dies stellt sicher, dass die API-Dokumentation immer mit dem Code synchronisiert ist.

Wie lautet der Prozess zur Umwandlung von Swagger-Spezifikationen in PDF-Dokumente?

Um Swagger-Spezifikationen in PDF-Dokumente zu konvertieren, können Sie IronPDF verwenden. Erzeugen Sie zuerst die Swagger-Spezifikation mit NSwag und nutzen Sie dann IronPDF, um den HTML-Inhalt dieser Spezifikationen in hochwertige PDFs umzuwandeln.

Wie kann ich NSwag in ein .NET-Projekt integrieren?

Die Integration von NSwag in ein .NET-Projekt umfasst die Installation der NSwag-Bibliothek über NuGet, deren Konfiguration zur Erzeugung von Swagger-Spezifikationen während des Build-Prozesses und die Nutzung der generierten Spezifikationen für Dokumentation und Code-Generierung.

Kann NSwag sowohl Client- als auch Server-Code aus einer Swagger-Spezifikation generieren?

Ja, NSwag kann Client-Code in Sprachen wie C#, Java und TypeScript sowie serverseitigen Code wie ASP.NET Core-Controller, alles aus einer einzigen Swagger-Spezifikation, generieren.

Wie verbessert IronPDF den Workflow der API-Dokumentation?

IronPDF verbessert den Workflow der API-Dokumentation, indem es Entwicklern ermöglicht, HTML-basierte API-Dokumentation in professionelle, teilbare PDF-Dokumente umzuwandeln, wodurch die Informationen offline zugänglich werden.

Welche Schritte sind erforderlich, um IronPDF in einem Visual Studio-Projekt zu verwenden?

Um IronPDF in einem Visual Studio-Projekt zu verwenden, installieren Sie es über den NuGet-Paket-Manager, indem Sie nach IronPDF suchen und auf 'Installieren' klicken, oder verwenden Sie die Paket-Manager-Konsole mit dem Befehl Install-Package IronPdf.

Wie kann interaktive API-Dokumentation mit NSwag generiert werden?

NSwag kann interaktive API-Dokumentationen erzeugen, indem es eine Swagger UI erstellt, die eine benutzerfreundliche Oberfläche zum Erkunden und Testen von API-Endpunkten direkt im Browser bietet.

Welche Vorteile bietet die Nutzung von NSwag für die API-Dokumentation?

NSwag automatisiert die Erstellung der API-Dokumentation, stellt sicher, dass diese immer mit dem Code auf dem neuesten Stand ist, und unterstützt zudem die Erstellung von interaktiven Dokumentationen und clientseitigem Code, was den Entwicklungsprozess vereinfacht.

Wie arbeitet IronPDF mit HTML-Inhalten zur Erstellung von PDFs?

IronPDF konvertiert HTML-Inhalte, einschließlich CSS und JavaScript, in das PDF-Format mithilfe seiner Rendering-Engine und ist daher ideal, um präzise, offline-bereite Dokumente aus web-basierten Inhalten zu erstellen.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen