.NET-HILFE

Nswag C# (Wie es für Entwickler funktioniert)

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Chipego Kalinda

6. Juni 2024

Teilen Sie:

Einführung

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, müssen gründliche und verständliche Dokumente vorhanden sein. Zwei effektive Tools, die den Arbeitsablauf der C#-API-Dokumentation unterstützen können, sind NSwag C# und IronPDF. Dieser Beitrag wird erläutern, wie Sie NSwag verwenden, um API-Spezifikationen mit .NET Core zu generieren und aus diesen Spezifikationen hochwertige PDF-Dokumente mit IronPDF zu erstellen.

Wie man NSwag in C# verwendet

Erstellen Sie eine Restful Web API mit Swagger UI.
Erstellen Sie eine C#-Konsolenanwendung.
Installieren Sie die NSwag-Bibliothek.
Importieren Sie den Namespace und erstellen Sie das Objekt.
Verarbeiten Sie den Swagger JSON zu C# Code.
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, die mit ASP.NET Web API, ASP.NET Core oder anderen .NET Frameworks erstellt wurden, zu erleichtern.

Merkmale von NSwag

Produktion von Swagger specs

Controller, Modelle und .NET-Assemblies können alle von NSwag verwendet werden, um automatisch Swagger-Spezifikationen zu erstellen. NSwag erstellt eine umfassende Dokumentation, die API-Endpunkte, Anfrage-/Antwortformulare, Authentifizierungstechniken und vieles mehr abdeckt, indem die Struktur des API-Codes untersucht wird.

Konnektivität zu .NET-Projekten

Entwickler können die Swagger-Generierung einfach in ihre Entwicklungsprozesse integrieren, indem sie NSwag in .NET-Projekte einbinden. Entwickler können sicherstellen, dass die Dokumentation mit der Codebasis aktualisiert wird, indem sie NSwag zu einem .NET Core-Projekt hinzufügen, das bei jeder Erstellung des Projekts automatisch Swagger-Spezifikationen erstellt.

Personalisierung und Erweiterung

Mit den vielfältigen Anpassungsmöglichkeiten, die NSwag bietet, können Entwickler die generierten Swagger-Spezifikationen leicht an ihre individuellen Bedürfnisse anpassen. Die Entwickler haben über Konfigurationseinstellungen und Anmerkungen die Kontrolle über viele Komponenten der generierten Dokumentation, einschließlich Antwortcodes, Parametererklärungen und Benennungskonventionen für Routen.

Erste Schritte mit NSwag

Einrichten von NSwag in einer C#-Konsolenanwendung

Die NSwag Base Class Library umfasst den Core-, Annotation- und Code-Generierungs-Namensraum, der durch Installation von NuGet verfügbar sein sollte. NSwag in eine C#-Anwendung zu integrieren, um Code und Swagger-Spezifikationen zu generieren, und wie NSwag die Effizienz des Entwicklungsprozesses verbessern kann.

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

Implementierung von NSwag in Windows Console und Forms

Durch die automatische Client-Generierung können Entwickler effizient Code für den Zugriff auf APIs direkt aus ihren Desktop-Anwendungen heraus erstellen, indem sie NSwag in eine Windows-Desktop-Anwendung integrieren. Bei der Entwicklung von Desktop-Anwendungen, die mit Online-Diensten oder RESTful-APIs kommunizieren, kann sie sehr hilfreich sein.

NSwag kann in Webanwendungen verwendet werden, um API-Dokumentation für interne APIs und Client-Code für die Nutzung externer APIs zu erstellen. Dies hilft Entwicklern dabei, die Frontend- und Backend-Komponenten ihrer Anwendungen konsistent zu halten.

NSwag C# Beispiel

Hier ist ein Codebeispiel, das Ihnen zeigt, wie Sie mit NSwag C#-Client-Code erzeugen können:

using NSwag.CodeGeneration.CSharp;
using NSwag;
using System.Reflection;
using System.CodeDom.Compiler;
using Microsoft.CodeAnalysis;
class Program
{
    static async Task Main(string[] args)
    {
        System.Net.WebClient 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"));
        wclient.Dispose();
        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
        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);
            List<MetadataReference> references = new List<MetadataReference>();
            references.Add(MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location));
            references.Add(MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "Microsoft.AspNetCore.Mvc.dll")));
            references.Add(MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Web.Http.dll")));
            var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("ApiClient")
                .AddReferences(Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
                .AddSyntaxTrees(Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(code)).AddReferences(references);
            var emitResult = compilation.Emit(memoryStream);
            if (!emitResult.Success)
            {
                var diagnostics = emitResult.Diagnostics;
                Console.WriteLine("Compilation errors:");
                foreach (var diagnostic in diagnostics)
                {
                    Console.WriteLine(diagnostic);
                }
                return null;
            }
            memoryStream.Seek(0, SeekOrigin.Begin);
            return Assembly.Load(memoryStream.ToArray());
        }
    }
    public interface IApiClient
    {
        Task<List<WeatherForecast>> GetWeatherForecastAsync(); // Replace with your actual method name and return type
    }
    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;
class Program
{
    static async Task Main(string[] args)
    {
        System.Net.WebClient 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"));
        wclient.Dispose();
        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
        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);
            List<MetadataReference> references = new List<MetadataReference>();
            references.Add(MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location));
            references.Add(MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "Microsoft.AspNetCore.Mvc.dll")));
            references.Add(MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Web.Http.dll")));
            var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("ApiClient")
                .AddReferences(Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
                .AddSyntaxTrees(Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(code)).AddReferences(references);
            var emitResult = compilation.Emit(memoryStream);
            if (!emitResult.Success)
            {
                var diagnostics = emitResult.Diagnostics;
                Console.WriteLine("Compilation errors:");
                foreach (var diagnostic in diagnostics)
                {
                    Console.WriteLine(diagnostic);
                }
                return null;
            }
            memoryStream.Seek(0, SeekOrigin.Begin);
            return Assembly.Load(memoryStream.ToArray());
        }
    }
    public interface IApiClient
    {
        Task<List<WeatherForecast>> GetWeatherForecastAsync(); // Replace with your actual method name and return type
    }
    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public int TemperatureF { get; set; }
        public string Summary { get; set; }
    }
}

Imports NSwag.CodeGeneration.CSharp
Imports NSwag
Imports System.Reflection
Imports System.CodeDom.Compiler
Imports Microsoft.CodeAnalysis
Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		Dim wclient As New System.Net.WebClient()
		' Create JSON file data from the Swagger net core web API
		Dim document = Await OpenApiDocument.FromJsonAsync(wclient.DownloadString("http://localhost:5013/swagger/v1/swagger.json"))
		wclient.Dispose()
		Dim settings = New CSharpClientGeneratorSettings With {
			.ClassName = "Weather",
			.CSharpGeneratorSettings = { [Namespace] = "Demo" }
		}
		Dim generator = New CSharpClientGenerator(document, settings)
		Dim code = generator.GenerateFile()
		Dim assembly = CompileCode(code)
		Dim clientType = assembly.GetType("Demo.WeatherClient") ' Replace with your actual client class name
		Dim httpClient As New HttpClient()
		Dim client = DirectCast(Activator.CreateInstance(clientType, httpClient), IApiClient)
		Dim result = Await client.GetWeatherForecastAsync()
		For Each item In result
			Console.WriteLine($"Date: {item.Date} F: {item.TemperatureF} C: {item.TemperatureC} Summary: {item.Summary}")
		Next item
	End Function
	Private Shared Function CompileCode(ByVal code As String) As System.Reflection.Assembly
		Using memoryStream As New MemoryStream()
			Dim assemblyPath = Path.GetDirectoryName(GetType(Object).Assembly.Location)
			Dim references As New List(Of MetadataReference)()
			references.Add(MetadataReference.CreateFromFile(GetType(Object).GetTypeInfo().Assembly.Location))
			references.Add(MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "Microsoft.AspNetCore.Mvc.dll")))
			references.Add(MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Web.Http.dll")))
			Dim compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("ApiClient").AddReferences(Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(GetType(Object).Assembly.Location)).AddSyntaxTrees(Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseSyntaxTree(code)).AddReferences(references)
			Dim emitResult = compilation.Emit(memoryStream)
			If Not emitResult.Success Then
				Dim diagnostics = emitResult.Diagnostics
				Console.WriteLine("Compilation errors:")
				For Each diagnostic In diagnostics
					Console.WriteLine(diagnostic)
				Next diagnostic
				Return Nothing
			End If
			memoryStream.Seek(0, SeekOrigin.Begin)
			Return System.Reflection.Assembly.Load(memoryStream.ToArray())
		End Using
	End Function
	Public Interface IApiClient
		Function GetWeatherForecastAsync() As Task(Of List(Of WeatherForecast)) ' Replace with your actual method name and return type
	End Interface
	Public Class WeatherForecast
		Public Property [Date]() As DateTime
		Public Property TemperatureC() As Integer
		Public Property TemperatureF() As Integer
		Public Property Summary() As String
	End Class
End Class

$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 Client-Code in einer DLL-Assembly definiert. OpenApiDocument wird verwendet. Um das Swagger-Dokument asynchron von der angegebenen URL zu laden, verwenden Sie FromJsonAsync. Um den generierten Clientcode zu ändern, passen wir die Einstellungen des Code-Generators an (CSharpClientGeneratorSettings). In diesem Beispiel werden der Klassenname und der Namespace des erzeugten Client-Codes angegeben.

Aus dem geladenen Swagger-Dokument erstellen wir eine Instanz von CSharpClientGenerator und verwenden diese, um den Client-Code zu erzeugen (Client-Code). Der erstellte Client-Code wird in dem angegebenen Ausgabepfad gespeichert. Wir reagieren auf alle Ausnahmen oder Fehler, die während des Verfahrens auftreten können, und zeigen die entsprechenden Meldungen auf der Konsole an.

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

NSwag Betrieb

Client-Code generieren

NSwag kann eine Swagger-Spezifikation verwenden, um Client-Code in vielen Sprachen zu generieren, darunter Java, TypeScript und C#. Dies macht es für Entwickler einfach, APIs in ihren Anwendungen zu verwenden.

Erzeugen von Server-Code

Auf der Grundlage einer Swagger-Spezifikation kann NSwag auch Servercode erzeugen, z. B. ASP.NET Core-Controller. Dies hilft, serverseitigen Code für API-Implementierungen schnell zu erstellen.

Erstellung einer interaktiven API-Dokumentation

Ausgehend von einer Swagger-Spezifikation kann NSwag eine interaktive API-Dokumentation, z. B. Swagger UI, erstellen. Diese Dokumentation bietet eine einfach zu bedienende Schnittstelle zum Erkunden und Testen von API-Endpunkten.

Erzeugen von Proxy-Klassen

Zur Integration mit SOAP-basierten APIs kann NSwag Proxy-Klassen erzeugen. Dies ermöglicht es Programmierern, produzierten Client-Code für den Zugriff auf SOAP-Dienste innerhalb ihrer Anwendungen zu verwenden.

Überprüfung der Swagger-Spezifikationen

NSwag ist in der Lage, Swagger-Spezifikationen zu verifizieren, um sicherzustellen, dass sie dem OpenAPI/Swagger-Standard entsprechen. Dadurch wird es einfacher, Fehler oder Unstimmigkeiten in der API-Dokumentation zu erkennen.

Integration von NSwag in IronPDF

Entwickler können den Arbeitsablauf für API-Dokumentation verbessern, indem sie die Vorteile beider Technologien durch die Integration von NSwag mit IronPDF nutzen. Entwickler können gründliche, offline-bereite .NET-Web-API-Dokumentationen erstellen, die mit NSwag zur Generierung von Swagger-Spezifikationen und IronPDF zur Umwandlung in PDFs leicht verfügbar und teilbar sind. Die folgenden Verfahren sind Teil des Integrationsprozesses:

IronPDF zeichnet sich durch die HTML-zu-PDF-Konvertierung aus und gewährleistet eine präzise Erhaltung der ursprünglichen Layouts und Stile. Es ist perfekt geeignet, um PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen zu erstellen. Mit Unterstützung von HTML-Dateien, URLs und rohen HTML-Zeichenfolgen produziert IronPDF mühelos 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");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

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

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

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

$vbLabelText $csharpLabel

IronPDF installieren

Starten Sie das Visual Studio-Projekt.
Wählen Sie "Werkzeuge" > "NuGet Package Manager" > "Package Manager Console".
Öffnen Sie die Eingabeaufforderung und geben Sie in der Paketmanager-Konsole den folgenden Befehl ein:

Install-Package IronPdf

Alternativ können Sie IronPDF auch mit dem NuGet Package Manager for Solutions installieren.
Wählen Sie das IronPDF-Paket aus den Suchergebnissen aus und klicken Sie dann auf die Option "Installieren". Visual Studio übernimmt den Download und die Installation für Sie.
NuGet installiert das IronPDF-Paket und alle für Ihr Projekt erforderlichen Abhängigkeiten.
Nach der Installation kann IronPDF für Ihr Projekt verwendet werden.

Installation über die NuGet-Website

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

DLL zur Installation verwenden

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

Um die ZIP-Datei mit der DLL zu erhalten, entpacken Sie sie und binden Sie die DLL in Ihr Projekt ein.

Umsetzung der Logik

Durch die Nutzung von NSwag können Entwickler API-Dokumentation und Client-Code zur Nutzung von APIs schneller erstellen, indem sie CodeGeneration.CSharp in Verbindung mit IronPDF verwenden. Die folgenden Schritte sind Teil des Integrationsworkflows:

Clientcode generieren: Um C#-Clientcode aus Swagger-Spezifikationen zu erstellen, verwenden Sie NSwag.CodeGeneration.CSharp. Die Erstellung von Client-Klassen und Methoden für die Kommunikation mit den API-Endpunkten wird in diesem Schritt automatisiert.
Verwenden Sie NSwag, um Daten zu erhalten: Um JSON-Dokumentation aus Swagger-Spezifikationen zu erzeugen, verwenden Sie CodeGeneration.CSharp. In dieser Phase werden die Anfrage-/Antwortformate, Authentifizierungstechniken und API-Client-Endpunkte in eine für Menschen lesbare Dokumentation umgewandelt.
JSON in PDF umwandeln: Um das generierte Code-Ergebnis in ein PDF-Dokument umzuwandeln, verwenden Sie IronPDF. In dieser Phase wird der HTML-Text in ein ausgefeiltes PDF-Dokument umgewandelt, das für die Weitergabe und Verteilung bereit ist.
Verbessern Sie die PDF-Dokumentation: Fügen Sie mehr Inhalte zur PDF-Dokumentation mit IronPDF hinzu, wie z. B. Kopfzeilen, Fußzeilen, Wasserzeichen oder einzigartiges Branding. In dieser Phase können die Entwickler das Erscheinungsbild und das Branding der PDF-Dokumentation nach ihrem Geschmack gestalten.

using IronPdf;
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 IronPdf.HtmlToPdf();
var PDF = Renderer.RenderHtmlAsPdf(sb.ToString());
// Save PDF to file
PDF.SaveAs("output.pdf");
Console.WriteLine("PDF generated successfully!");
Console.ReadKey();

using IronPdf;
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 IronPdf.HtmlToPdf();
var PDF = Renderer.RenderHtmlAsPdf(sb.ToString());
// Save PDF to file
PDF.SaveAs("output.pdf");
Console.WriteLine("PDF generated successfully!");
Console.ReadKey();

Imports IronPdf
Private sb As New StringBuilder()

For Each item In result
	sb.Append($"<p>Date: {item.Date} F: {item.TemperatureF} C: {item.TemperatureC} Summary: {item.Summary}</p>")
Next item
Dim Renderer = New IronPdf.HtmlToPdf()
Dim PDF = Renderer.RenderHtmlAsPdf(sb.ToString())
' Save PDF to file
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 in Absätze ein. Anschließend wird der Pfad der Ausgabedatei für das PDF festgelegt und der Benutzer darüber informiert, dass ein PDF erfolgreich erstellt wurde.

Nachfolgend sehen Sie das Ergebnis des obigen Codes.

NSwag C# (Wie es für Entwickler funktioniert): Abbildung 4 - Beispielausgabe aus dem oben genannten Code

Schlussfolgerung

CodeGeneration NSwag-Technologien wie CSharp und IronPDF arbeiten gut zusammen, um die Produktion von Client-Code und die Prozesse der API-Dokumentation zu optimieren. Entwickler können die Erstellung von API-gesteuerten Lösungen beschleunigen, die Erstellung von API-Dokumentation automatisieren und professionell aussehende PDF-Publikationen erstellen, indem sie diese Werkzeuge in C#-Anwendungen integrieren. NSwag.CodeGeneration.CSharp mit IronPDF bietet Entwicklern eine komplette Lösung zur effizienten Dokumentation von APIs und zur Erzeugung von Client-Code in C#, egal ob sie Desktop-, Web- oder Cloud-basierte Apps entwickeln.

Das $749 Lite-Paket umfasst eine unbefristete Lizenz, ein Jahr Software-Wartung und ein Upgrade für die Bibliothek. IronPDF bietet eine kostenlose Lizenz mit zeitlichen und räumlichen Beschränkungen für die Weitergabe an. Die Benutzer können die Lösung während der Testphase ohne Wasserzeichen testen. Für zusätzliche Informationen zu Preis und Lizenz siehe bitte die Lizenzinformationen von IronPDF. Gehen Sie zur Iron Software-Bibliotheksseite für zusätzliche Informationen über die Produktbibliotheken von Iron Software.

Chipego Kalinda

Jetzt mit dem Ingenieurteam chatten

Software-Ingenieur

Chipego hat eine natürliche Fähigkeit zum Zuhören, die ihm hilft, Kundenprobleme zu verstehen und intelligente Lösungen anzubieten. Er trat dem Iron Software-Team 2023 bei, nachdem er einen Bachelor of Science in Informationstechnologie erworben hatte. IronPDF und IronOCR sind die beiden Produkte, auf die sich Chipego konzentriert hat, aber sein Wissen über alle Produkte wächst täglich, da er neue Wege findet, Kunden zu unterstützen. Er genießt die Zusammenarbeit bei Iron Software, da Teammitglieder aus dem gesamten Unternehmen ihre unterschiedlichen Erfahrungen einbringen und so zu effektiven, innovativen Lösungen beitragen. Wenn Chipego nicht an seinem Schreibtisch sitzt, kann man ihn oft bei einem guten Buch oder beim Fußballspielen antreffen.

< PREVIOUS
Dapper C# (Wie es für Entwickler funktioniert)

NÄCHSTES >
Flunt C# (Wie es für Entwickler funktioniert)