Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. NSwag C#
.NET AIDE

Nswag C# (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Les API sont essentielles dans l'environnement de développement logiciel d'aujourd'hui car elles facilitent la communication entre divers systèmes et composants logiciels. Pour que les développeurs utilisent efficacement les API, il doit y avoir une documentation approfondie et compréhensible. Deux outils efficaces qui peuvent aider le flux de travail de documentation API C# sont NSwag C# et IronPDF. Ce post discutera de comment utiliser NSwag pour générer des spécifications API avec .NET Core et produire des documents PDF de haute qualité à partir de ces spécifications en utilisant IronPDF.

Comment utiliser NSwag en C#

  1. Créer une API web RESTful en utilisant Swagger UI.
  2. Créer une application console C#.
  3. Installer la bibliothèque NSwag.
  4. Importer l'espace de noms et créer l'objet.
  5. Traiter le JSON Swagger en code C#.
  6. Exécuter le code et afficher le résultat.

Comprendre NSwag

Un ensemble d'outils .NET Swagger appelé NSwag a été créé pour faciliter la création de spécifications Swagger, ou de documents OpenAPI, pour les API construites en utilisant ASP.NET Web API, ASP.NET Core, ou d'autres frameworks .NET.

Caractéristiques de NSwag

Production de Spécifications Swagger

Les contrôleurs, les modèles, et les assemblées .NET peuvent tous être utilisés par NSwag pour produire automatiquement des spécifications Swagger. NSwag génère une documentation complète qui couvre les points d'accès de l'API, les formats de requête/réponse, les techniques d'authentification, et plus en analysant la structure du code de l'API.

Connectivité aux Projets .NET

Les développeurs peuvent facilement inclure la génération Swagger dans leurs processus de développement en intégrant NSwag avec des projets .NET. Les développeurs peuvent s'assurer que la documentation est mise à jour avec le code source en ajoutant NSwag à un projet .NET Core, ce qui produira automatiquement les spécifications Swagger chaque fois que le projet est construit.

Personnalisation et Expansion

Avec la large gamme de possibilités de personnalisation offertes par NSwag, les développeurs peuvent facilement adapter les spécifications Swagger générées pour répondre à leurs besoins uniques. Les développeurs ont le contrôle de nombreux composants de la documentation générée, y compris les codes de réponse, les explications des paramètres, et les conventions de nommage des routes, grâce aux paramètres de configuration et aux annotations.

Prise en main avec NSwag

Configuration de NSwag dans une Application Console C

La bibliothèque de classes de base NSwag comprend le noyau, l'annotation, et l'espace de noms de génération de code, qui devrait être disponible en installant à partir de NuGet. Pour intégrer NSwag dans une application C# pour générer du code et des spécifications Swagger, et comment NSwag peut améliorer l'efficacité du processus de développement.

NSwag C# (Comment ça Marche pour les Développeurs) : Figure 1 - Chercher NSwag dans le Gestionnaire de Paquets Visual Studio et l'installer

Implémentation de NSwag dans les Consoles et Formulaires Windows

Grâce à la génération automatique de clients, les développeurs peuvent produire efficacement du code pour accéder à des API directement depuis leurs applications de bureau en intégrant NSwag dans une application de bureau Windows. Lors du développement d'applications de bureau qui communiquent avec des services en ligne ou des API RESTful, cela peut être très utile.

NSwag peut être utilisé dans les applications web pour générer la documentation d'API pour les API internes et le code client pour consommer des API externes. Cela aide les développeurs à maintenir la cohérence des composants frontend et backend de leurs applications.

Exemple de NSwag C

Voici un exemple de code qui vous montre comment utiliser NSwag pour produire du code client C# :

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; }
    }
}
Imports NSwag.CodeGeneration.CSharp
Imports NSwag
Imports System.Reflection
Imports System.CodeDom.Compiler
Imports Microsoft.CodeAnalysis
Imports System.Net.Http
Imports System.IO
Imports System.Collections.Generic
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		Using wclient = 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"))
			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
			Using 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 Using
		End Using
	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 = New List(Of MetadataReference) From {MetadataReference.CreateFromFile(GetType(Object).GetTypeInfo().Assembly.Location), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "Microsoft.AspNetCore.Mvc.dll")), MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Private.CoreLib.dll"))}

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

			Dim emitResult = compilation.Emit(memoryStream)
			If Not emitResult.Success Then
				Console.WriteLine("Compilation errors:")
				For Each diagnostic In emitResult.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
		' Replace with your actual method name and return type
		Function GetWeatherForecastAsync() As Task(Of List(Of WeatherForecast))
	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

Pour l'API que nous souhaitons utiliser, nous spécifions l'URL de la spécification Swagger (swaggerUrl). Ensuite, le code client généré et exécuté dans un assemblage DLL est défini. OpenApiDocument est utilisé pour charger le document Swagger de manière asynchrone à partir de l'URL donnée, en utilisant FromJsonAsync. Pour modifier le code client généré, nous ajustons les paramètres du générateur de code (CSharpClientGeneratorSettings). Dans cet exemple, le nom de la classe et l'espace de noms du code client produit sont spécifiés.

À partir du document Swagger chargé, nous construisons une instance de CSharpClientGenerator et l'utilisons pour produire le code client. Le code client créé est enregistré sur le chemin de sortie désigné. Nous répondons à toute exception ou erreur qui pourrait survenir pendant la procédure, affichant les notifications pertinentes sur la console.

NSwag C# (Comment ça Marche pour les Développeurs) : Figure 2 - Sortie de la console du code ci-dessus

Fonctionnement de NSwag

Génération de Code Client

NSwag peut utiliser une spécification Swagger pour générer du code client dans de nombreuses langues, y compris Java, TypeScript, et C#. Cela facilite l'utilisation des API par les développeurs dans leurs applications.

Génération de Code Serveur

En utilisant une spécification Swagger comme base, NSwag peut également produire du code serveur, tel que des contrôleurs ASP.NET Core. Cela aide à mettre en place rapidement le code côté serveur pour les implémentations d'API.

Production de Documentation Interactive d'API

Étant donné une spécification Swagger, NSwag peut produire une documentation interactive d'API, telle que Swagger UI. Une interface facile à utiliser est fournie par cette documentation pour explorer et tester les points d'accès de l'API.

Production de Classes Proxy

Pour s'intégrer avec les API basées sur SOAP, NSwag peut produire des classes proxy. Cela permet aux programmeurs d'utiliser le code client produit pour accéder aux services SOAP depuis leurs applications.

Vérification des Spécifications Swagger

NSwag est capable de vérifier les spécifications Swagger pour s'assurer qu'elles respectent la norme OpenAPI/Swagger. Cela facilite la détection de toute erreur ou discordance dans la documentation d'API.

Intégration de NSwag avec IronPDF

Les développeurs peuvent améliorer le flux de travail pour la documentation d'API en utilisant les avantages des deux technologies en intégrant NSwag avec IronPDF. Les développeurs peuvent produire une documentation d'API web .NET complète, prête à être consultée hors ligne et facilement partageable, en utilisant NSwag pour générer des spécifications Swagger et IronPDF pour les transformer en PDF. Les procédures suivantes font partie du processus d'intégration :

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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

Installer IronPDF

  • Démarrez le projet Visual Studio.
  • Choisissez "Outils" > "Gestionnaire de packages NuGet" > "Console du gestionnaire de packages".
  • Ouvrez votre invite de commande et dans la Console du Gestionnaire de Paquets, tapez la commande suivante :
Install-Package IronPdf
  • Alternativement, vous pouvez installer IronPDF en utilisant le gestionnaire de packages NuGet pour solutions.
  • Explorez et sélectionnez le paquet IronPDF parmi les résultats de recherche, puis cliquez sur l'option "Installer". Visual Studio gérera le téléchargement et l'installation en votre nom.

NSwag C# (Comment ça Marche pour les Développeurs) : Figure 3 - Installer IronPDF en utilisant le Gérer le Paquet NuGet pour Solution en recherchant IronPdf dans la barre de recherche de NuGet Package Manager, puis sélectionner le projet et cliquer sur le bouton Installer.

  • NuGet installera le paquet IronPDF et toutes les dépendances requises pour votre projet.
  • Après l'installation, IronPDF peut être utilisé pour votre projet.

Installation via le site Web NuGet

Pour des informations supplémentaires concernant les fonctionnalités d'IronPDF, sa compatibilité, et ses téléchargements disponibles, consultez la page IronPDF sur NuGet.

Utiliser DLL pour installer

Alternativement, vous pouvez intégrer IronPDF directement dans votre projet en utilisant son fichier DLL. Pour télécharger le fichier ZIP contenant le DLL, cliquez sur le lien de téléchargement IronPDF. Décompressez le fichier et ajoutez le DLL à votre projet.

Implémentation de la logique

En utilisant NSwag, les développeurs peuvent créer une documentation API ainsi que du code client pour utiliser des API plus rapidement en utilisant CodeGeneration.CSharp en conjonction avec IronPDF. Les étapes suivantes font partie du flux de travail d'intégration :

  1. Générer du Code Client: Pour créer du code client C# à partir des spécifications Swagger, utilisez NSwag.CodeGeneration.CSharp. La création de classes et de méthodes clientes pour communiquer avec les points d'accès de l'API est automatisée à cette étape.
  2. Utiliser NSwag pour Obtenir des Données: Pour produire une documentation JSON à partir des spécifications Swagger, utilisez CodeGeneration.CSharp. À cette étape, les formats de requête/réponse, les techniques d'authentification, et les points d'accès client de l'API sont créés en documentation lisible par l'homme.
  3. Convertir JSON en PDF: Pour convertir le résultat de code généré en un document PDF, utilisez IronPDF. Dans cette étape, le texte HTML est converti en un document PDF fini prêt pour être partagé et distribué.
  4. Améliorer la Documentation PDF: Ajoutez plus de contenu à la documentation PDF à l'aide d'IronPDF, comme des en-têtes, des pieds de page, des filigranes, ou une marque spécifique. Cette étape donne aux développeurs la possibilité de personnaliser l'apparence et la marque de la documentation PDF pour répondre à leurs préférences.
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();
Imports IronPdf
Imports System.Text
Imports System.Collections.Generic

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 HtmlToPdf()
Dim pdf = renderer.RenderHtmlAsPdf(sb.ToString())
pdf.SaveAs("output.pdf")
Console.WriteLine("PDF generated successfully!")
Console.ReadKey()
$vbLabelText   $csharpLabel

Le code ci-dessus accède aux données récupérées à partir de l'objet résultat et ajoute les champs Date, TemperatureF, TemperatureC, et Résumé dans des paragraphes en boucle. Il spécifie ensuite le chemin du fichier de sortie pour le PDF, puis avertit l'utilisateur qu'un PDF a été généré avec succès.

Voici le résultat du code ci-dessus.

NSwag C# (Comment ça Marche pour les Développeurs) : Figure 4 - Exemple de sortie du code ci-dessus

Conclusion

CodeGeneration Les technologies NSwag comme CSharp et IronPDF travaillent bien ensemble pour rationaliser la production de code client et les processus de documentation API. Les développeurs peuvent accélérer la création de solutions orientées API, automatiser la création de documentation API, et produire des publications PDF d'apparence professionnelle en intégrant ces outils dans des applications C#. NSwag.CodeGeneration.CSharp avec IronPDF offre aux développeurs une solution complète pour documenter efficacement les API et produire du code client en C#, qu'ils développent des applications de bureau, web, ou basées sur le cloud.

Le pack Lite comprend une licence perpétuelle, un an de maintenance logicielle, et une mise à niveau de la bibliothèque. IronPDF offre des licences gratuites avec des restrictions sur la redistribution et le temps. Les utilisateurs peuvent évaluer la solution pendant la période d'essai sans avoir à voir un filigrane. Pour des informations supplémentaires sur le prix et la licence, veuillez consulter les informations de licence d'IronPDF. Rendez-vous sur la page des bibliothèques Iron Software pour plus d'informations sur les bibliothèques de produits Iron Software.

Questions Fréquemment Posées

Comment NSwag peut-il aider à générer des spécifications d'API en C# ?

NSwag peut générer automatiquement des spécifications d'API, appelées documents Swagger ou OpenAPI, à partir de projets .NET Core. Cela garantit que la documentation de l'API est toujours synchronisée avec la base de code.

Quel est le processus pour convertir des spécifications Swagger en documents PDF ?

Pour convertir des spécifications Swagger en documents PDF, vous pouvez utiliser IronPDF. Tout d'abord, générez la spécification Swagger en utilisant NSwag, puis utilisez IronPDF pour convertir le contenu HTML de ces spécifications en PDF de haute qualité.

Comment puis-je intégrer NSwag dans un projet .NET ?

L'intégration de NSwag dans un projet .NET implique d'installer la bibliothèque NSwag via NuGet, de la configurer pour générer des spécifications Swagger pendant le processus de construction, et d'utiliser les spécifications générées pour la documentation et la génération de code.

NSwag peut-il générer à la fois du code client et serveur à partir d'une spécification Swagger ?

Oui, NSwag peut générer du code client dans des langages comme C#, Java et TypeScript, ainsi que du code côté serveur comme des contrôleurs ASP.NET Core, le tout à partir d'une seule spécification Swagger.

Comment IronPDF améliore-t-il le workflow de documentation API ?

IronPDF améliore le workflow de documentation API en permettant aux développeurs de convertir la documentation API basée sur HTML en documents PDF professionnels et partageables, rendant l'information accessible hors ligne.

Quelles étapes sont nécessaires pour utiliser IronPDF dans un projet Visual Studio ?

Pour utiliser IronPDF dans un projet Visual Studio, installez-le via le gestionnaire de packages NuGet en cherchant IronPDF et en cliquant sur 'Installer', ou utilisez la console du gestionnaire de packages avec la commande Install-Package IronPdf.

Comment la documentation interactive d'une API peut-elle être générée à l'aide de NSwag ?

NSwag peut générer une documentation interactive d'une API en produisant une interface utilisateur Swagger, qui fournit une interface conviviale pour explorer et tester les points d'extrémité de l'API directement dans le navigateur.

Quels sont les avantages d'utiliser NSwag pour la documentation d'API ?

NSwag automatise la génération de la documentation d'API, garantissant qu'elle est toujours à jour avec la base de code. Il prend également en charge la création de documentation interactive et de code côté client, rationalisant ainsi le processus de développement.

Comment IronPDF travaille-t-il avec le contenu HTML pour créer des PDF ?

IronPDF convertit le contenu HTML, y compris CSS et JavaScript, en format PDF en utilisant son moteur de rendu, ce qui le rend idéal pour créer des documents précis et prêts à être utilisés hors ligne à partir de contenu basé sur le web.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit