Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. Swashbuckle ASP .NET Core
.NET HILFE

Swashbuckle ASP .NET Core (Wie es für Entwickler funktioniert)

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

Swashbuckle ist ein C# .NET Core NuGet-Paket, das hilft, RESTful Web-APIs automatisch zu dokumentieren. In diesem Blog werden wir die Swashbuckle ASP.NET Core und IronPDF Installationsanweisungen NuGet-Pakete erkunden, die die moderne Entwicklung von ASP.NET Core Web-APIs ermöglichen. Zusammen bieten sie eine Vielzahl von Funktionen, die mit minimalem Code erreicht werden können.

Die API-Dokumentationsseiten werden mit dem Swagger-UI-Tool angezeigt, das eine aus dem Web-API-Projekt generierte swagger.json Datei verwendet. Das generierte JSON-Dokument folgt dem Open API-Standard. Swashbuckle ist als NuGet-Paket Swashbuckle.AspNetCore verfügbar, das bei Installation und Konfiguration automatisch das Swagger JSON freilegt. Das Swagger UI-Tool liest die Swagger JSON-Datei, die aus XML-Kommentaren generiert wird, die auf den APIs geschrieben sind. Zusätzlich kann eine XML-Dokumentationsdatei erstellt werden, indem sie in der Projektdatei aktiviert wird. XML-Kommentare werden in eine XML-Dokumentationsdatei konvertiert, aus der das Swagger JSON generiert wird. Dann liest die Swagger-Middleware das JSON und stellt Swagger JSON-Endpunkte bereit.

Implementierung in einem .NET Core Web API-Projekt

Lassen Sie uns mit einem Web-API-Projekt beginnen:

dotnet new webapi -n SwashbuckleDemo
cd SwashbuckleDemo
dotnet build
dotnet add package Swashbuckle.AspNetCore --version 6.5.0
dotnet build
dotnet new webapi -n SwashbuckleDemo
cd SwashbuckleDemo
dotnet build
dotnet add package Swashbuckle.AspNetCore --version 6.5.0
dotnet build
SHELL

Hier erstellen wir ein Web-API-Projekt namens "SwashbuckleDemo" und installieren dann das Swashbuckle-Paket in das .NET Core Web-API-Projekt über die Paket-Manager-Konsole.

Swagger-Middleware konfigurieren

Konfigurieren Sie die Swagger-Dienste in der Startup.cs Datei.

using System.Reflection;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Builder;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Other service configurations...

        // Register the Swagger generator
        services.AddSwaggerGen(c =>
        {
            c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });

            // Optionally, include XML comments for additional information
            var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
            var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
            c.IncludeXmlComments(xmlPath);
        });
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        // Other app configurations...

        // Enable middleware to serve generated Swagger as a JSON endpoint.
        app.UseSwagger();

        // Enable Swagger UI (HTML, JS, CSS, etc.), specifying the Swagger JSON endpoint.
        app.UseSwaggerUI(c =>
        {
            c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
        });
    }
}
using System.Reflection;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Builder;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Other service configurations...

        // Register the Swagger generator
        services.AddSwaggerGen(c =>
        {
            c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });

            // Optionally, include XML comments for additional information
            var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
            var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
            c.IncludeXmlComments(xmlPath);
        });
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        // Other app configurations...

        // Enable middleware to serve generated Swagger as a JSON endpoint.
        app.UseSwagger();

        // Enable Swagger UI (HTML, JS, CSS, etc.), specifying the Swagger JSON endpoint.
        app.UseSwaggerUI(c =>
        {
            c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
        });
    }
}
$vbLabelText   $csharpLabel

Fügen Sie einen Controller für todo-Liste-APIs hinzu:

using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

// Example to define an entity class
public class Todo
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsComplete { get; set; }
}

// Example to define a DbContext class
public class TodoDb : DbContext
{
    public DbSet<Todo> Todos => Set<Todo>();
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "SwashbuckleDemo!");

app.MapGet("/todoitems", async (TodoDb db) =>
    await db.Todos.ToListAsync());

app.MapGet("/todoitems/complete", async (TodoDb db) =>
    await db.Todos.Where(t => t.IsComplete).ToListAsync());

app.MapGet("/todoitems/{id}", async (int id, TodoDb db) =>
    await db.Todos.FindAsync(id) is Todo todo
        ? Results.Ok(todo)
        : Results.NotFound());

app.MapPost("/todoitems", async (Todo todo, TodoDb db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();
    return Results.Created($"/todoitems/{todo.Id}", todo);
});

app.MapPut("/todoitems/{id}", async (int id, Todo inputTodo, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id);
    if (todo is null) return Results.NotFound();
    todo.Name = inputTodo.Name;
    todo.IsComplete = inputTodo.IsComplete;
    await db.SaveChangesAsync();
    return Results.NoContent();
});

app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) =>
{
    if (await db.Todos.FindAsync(id) is Todo todo)
    {
        db.Todos.Remove(todo);
        await db.SaveChangesAsync();
        return Results.Ok(todo);
    }

    return Results.NotFound();
});

app.Run();
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

// Example to define an entity class
public class Todo
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsComplete { get; set; }
}

// Example to define a DbContext class
public class TodoDb : DbContext
{
    public DbSet<Todo> Todos => Set<Todo>();
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "SwashbuckleDemo!");

app.MapGet("/todoitems", async (TodoDb db) =>
    await db.Todos.ToListAsync());

app.MapGet("/todoitems/complete", async (TodoDb db) =>
    await db.Todos.Where(t => t.IsComplete).ToListAsync());

app.MapGet("/todoitems/{id}", async (int id, TodoDb db) =>
    await db.Todos.FindAsync(id) is Todo todo
        ? Results.Ok(todo)
        : Results.NotFound());

app.MapPost("/todoitems", async (Todo todo, TodoDb db) =>
{
    db.Todos.Add(todo);
    await db.SaveChangesAsync();
    return Results.Created($"/todoitems/{todo.Id}", todo);
});

app.MapPut("/todoitems/{id}", async (int id, Todo inputTodo, TodoDb db) =>
{
    var todo = await db.Todos.FindAsync(id);
    if (todo is null) return Results.NotFound();
    todo.Name = inputTodo.Name;
    todo.IsComplete = inputTodo.IsComplete;
    await db.SaveChangesAsync();
    return Results.NoContent();
});

app.MapDelete("/todoitems/{id}", async (int id, TodoDb db) =>
{
    if (await db.Todos.FindAsync(id) is Todo todo)
    {
        db.Todos.Remove(todo);
        await db.SaveChangesAsync();
        return Results.Ok(todo);
    }

    return Results.NotFound();
});

app.Run();
$vbLabelText   $csharpLabel

Ein Controller kann auch wie unten hinzugefügt werden:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System;
using System.Linq;

namespace RestFullMinimalApi.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherForecastController> _logger;

        public WeatherForecastController(ILogger<WeatherForecastController> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// Retrieves WeatherForecast
        /// </summary>
        /// <remarks>Awesomeness!</remarks>
        /// <response code="200">Retrieved</response>
        /// <response code="404">Not found</response>
        /// <response code="500">Oops! Can't lookup your request right now</response>
        [HttpGet(Name = "GetWeatherForecast")]
        public IEnumerable<WeatherForecast> Get()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public string Summary { get; set; }
    }
}
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System;
using System.Linq;

namespace RestFullMinimalApi.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherForecastController> _logger;

        public WeatherForecastController(ILogger<WeatherForecastController> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// Retrieves WeatherForecast
        /// </summary>
        /// <remarks>Awesomeness!</remarks>
        /// <response code="200">Retrieved</response>
        /// <response code="404">Not found</response>
        /// <response code="500">Oops! Can't lookup your request right now</response>
        [HttpGet(Name = "GetWeatherForecast")]
        public IEnumerable<WeatherForecast> Get()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }

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

Der obige Code ist auf GitHub - Swashbuckle Demo verfügbar.

Swashbuckle bietet die folgenden Funktionen

Swagger UI-Werkzeug

Swashbuckle ASP .NET Core (Wie es für Entwickler funktioniert): Abbildung 1 - Swagger-UI-Tool

Swagger UI ist von der Basis-URL der Web-API-Anwendung unter "/swagger/index.html" verfügbar. Es listet alle REST-APIs aus dem Code auf. Der Swagger-Generator liest die JSON-Datei und füllt die Benutzeroberfläche aus.

Swagger JSON

Swashbuckle.AspNetCore generiert automatisch die Swagger JSON-Datei, die Informationen über die API-Struktur enthält, einschließlich Details wie Endpunkte, Anforderungs- und Antworttypen und mehr. Diese JSON-Datei kann von anderen Werkzeugen und Diensten verwendet werden, die den Swagger/OpenAPI-Standard unterstützen.

Die Swagger JSON-Datei ist von der Basis-URL der Web-API-Anwendung unter "/swagger/v1/swagger.json" verfügbar.

Swashbuckle ASP .NET Core (Wie es für Entwickler funktioniert): Abbildung 2 - Die Swagger JSON-Datei.

Code-Anmerkungen

Entwickler können XML-Kommentare und Attribute in ihren ASP.NET Core-Controllern verwenden, um zusätzliche Informationen für die Swagger-Dokumentation bereitzustellen. Dies umfasst Beschreibungen, Beispiele und andere Metadaten, die die generierte Swagger-Dokumentation verbessern.

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    /// <summary>
    /// Retrieves WeatherForecast
    /// </summary>
    /// <remarks>Awesomeness!</remarks>
    /// <response code="200">Retrieved</response>
    /// <response code="404">Not found</response>
    /// <response code="500">Oops! Can't lookup your request right now</response>
    [HttpGet(Name = "GetWeatherForecast")]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}
[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    /// <summary>
    /// Retrieves WeatherForecast
    /// </summary>
    /// <remarks>Awesomeness!</remarks>
    /// <response code="200">Retrieved</response>
    /// <response code="404">Not found</response>
    /// <response code="500">Oops! Can't lookup your request right now</response>
    [HttpGet(Name = "GetWeatherForecast")]
    public IEnumerable<WeatherForecast> Get()
    {
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = Random.Shared.Next(-20, 55),
            Summary = Summaries[Random.Shared.Next(Summaries.Length)]
        })
        .ToArray();
    }
}
$vbLabelText   $csharpLabel

Konfigurationsoptionen

Swashbuckle.AspNetCore bietet verschiedene Konfigurationsoptionen, um anzupassen, wie die Swagger-Dokumentation generiert wird. Entwickler können steuern, welche APIs dokumentiert werden, Namenskonventionen konfigurieren und andere Einstellungen anpassen.

Hier sind einige der wichtigsten Konfigurationsoptionen, die von Swashbuckle.AspNetCore bereitgestellt werden:

SwaggerGen Optionen

c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
$vbLabelText   $csharpLabel

Diese Zeile gibt die Swagger-Dokumentversion an und enthält Metadaten wie Titel und Version Ihrer API.

c.IncludeXmlComments(xmlPath);
c.IncludeXmlComments(xmlPath);
$vbLabelText   $csharpLabel

Diese Option ermöglicht es Ihnen, XML-Kommentare aus Ihrem Code einzubeziehen, um zusätzliche Informationen in der Swagger-Dokumentation bereitzustellen. Die xmlPath Variable sollte auf den Speicherort Ihrer XML-Kommentardatei verweisen.

c.DescribeAllParametersInCamelCase();
c.DescribeAllParametersInCamelCase();
$vbLabelText   $csharpLabel

Diese Option konfiguriert den Swagger-Generator, Parametername in camelCase zu verwenden.

c.OperationFilter<CustomOperationFilter>();
c.OperationFilter<CustomOperationFilter>();
$vbLabelText   $csharpLabel

Sie können benutzerdefinierte Operationsfilter registrieren, um die Swagger-Dokumentation für bestimmte Operationen zu ändern. CustomOperationFilter ist eine Klasse, die IOperationFilter implementiert.

Swagger UI Optionen

c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
$vbLabelText   $csharpLabel

Diese Zeile konfiguriert das Swagger UI, um Dokumentation anzuzeigen. Der erste Parameter ist die URL der Swagger JSON-Datei und der zweite Parameter ist ein benutzerfreundlicher Name für die API-Version.

c.RoutePrefix = "swagger";
c.RoutePrefix = "swagger";
$vbLabelText   $csharpLabel

Sie können das Routen-Präfix für das Swagger UI festlegen. In diesem Beispiel wird das Swagger UI unter /swagger verfügbar sein.

c.DocExpansion(DocExpansion.None);
c.DocExpansion(DocExpansion.None);
$vbLabelText   $csharpLabel

Diese Option steuert, wie das Swagger UI die API-Dokumentation anzeigt. DocExpansion.None klappt standardmäßig alle Operationen zusammen.

SwaggerOptionen

c.SerializeAsV2 = true;
c.SerializeAsV2 = true;
$vbLabelText   $csharpLabel

Diese Option gibt an, ob das Swagger-Dokument im 2.0-Format (true) oder im 3.0-Format (false) serialisiert werden soll. Setzen Sie es auf true, wenn Sie Swagger 2.0 verwenden möchten.

c.DisplayOperationId();
c.DisplayOperationId();
$vbLabelText   $csharpLabel

Diese Option zeigt die Vorgangs-ID im Swagger UI an, was für das Debugging und das Verstehen der Architektur Ihrer API nützlich sein kann.

c.OAuthClientId("swagger-ui");
c.OAuthClientId("swagger-ui");
$vbLabelText   $csharpLabel

Wenn Ihre API OAuth-Authentifizierung verwendet, können Sie die OAuth-Client-ID für Swagger UI konfigurieren.

Die Swashbuckle.AspNetCore-Bibliothek ist anpassbar; kombinieren Sie Optionen und Filter, um die Swagger-Dokumentation anzupassen. Die Swashbuckle.AspNetCore-Bibliothek ist hochgradig anpassbar, und Sie können die Swagger-Dokumentation auf Ihre speziellen Bedürfnisse zugeschnitten durch die Kombination verschiedener Optionen und Filter abstimmen. Bitte immer auf die offizielle Dokumentation oder IntelliSense in Ihrer Entwicklungsumgebung zurückgreifen, um die aktuellsten und umfassendsten Informationen zu den verfügbaren Optionen zu erhalten.

Einführung in IronPDF

IronPDF-Produktübersicht ist die C# PDF-Bibliothek von Iron Software-Website, die hilft, PDF-Dokumente zu lesen und zu erstellen. Es kann formatierten Dokumente mit Stilinformationen problemlos in PDF umwandeln. IronPDF kann mühelos PDFs aus HTML-Inhalten generieren. Es kann HTML-Inhalte von einer URL herunterladen und dann PDFs generieren.

IronPDF ist ein großartiges Tool zum Konvertieren von Webseiten, URLs und HTML in PDFs, die die Quelle perfekt replizieren. Es ist ideal, um PDFs von Online-Inhalten wie Berichten und Rechnungen zu erstellen und mühelos PDF-Versionen jeder Webseite zu erzeugen.

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

Installation

Installieren Sie IronPDF über NuGet mit den NuGet Paketverwaltungsdetails oder der Visual Studio-Installationsanleitung Paketverwaltungs-Konsole.

Geben Sie in die Paketverwaltungs-Konsole den Befehl ein:

Install-Package IronPdf

Verwendung von Visual Studio

Swashbuckle ASP .NET Core (So funktioniert es für Entwickler): Abb. 3 - Öffnen Sie Ihr Projekt in Visual Studio. Gehen Sie zum Menü Werkzeuge, wählen Sie NuGet-Paket-Manager und dann NuGet-Pakete für die Lösung verwalten. Suchen Sie in der NuGet-Paket-Verwaltungsschnittstelle im Durchsuchen-Tab nach dem Paket ironpdf. Wählen Sie dann die neueste Version von IronPDF und installieren Sie sie.

Nun, lassen Sie uns unsere Anwendung ändern, um die Funktionalität hinzuzufügen, Website-Inhalte als PDF-Datei herunterzuladen.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace RestFullMinimalApi.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherForecastController> _logger;

        public WeatherForecastController(ILogger<WeatherForecastController> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// Retrieves WeatherForecast
        /// </summary>
        /// <remarks>Awesomeness!</remarks>
        /// <response code="200">Retrieved</response>
        /// <response code="404">Not found</response>
        /// <response code="500">Oops! Can't lookup your request right now</response>
        [HttpGet(Name = "GetWeatherForecast")]
        public IEnumerable<WeatherForecast> Get()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }

        /// <summary>
        /// Retrieves WeatherForecast as Pdf
        /// </summary>
        /// <remarks>Awesomeness!</remarks>
        /// <response code="200">Retrieved</response>
        /// <response code="404">Not found</response>
        /// <response code="500">Oops! Can't lookup your request right now</response>
        [HttpGet("download", Name = "DownloadWeatherForecast")]
        public IActionResult GetWeatherPdf()
        {
            var results = Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            }).ToArray();

            var html = GetHtml(results);
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(html);
            var fileName = "WeatherReport.pdf";
            pdf.SaveAs(fileName);

            var stream = new FileStream(fileName, FileMode.Open);
            // Return the PDF file for download
            return new FileStreamResult(stream, "application/octet-stream") { FileDownloadName = fileName };
        }

        private static string GetHtml(WeatherForecast[] weatherForecasts)
        {
            string header = @"
<html>
<head><title>WeatherForecast</title></head>
<body>
<h1>WeatherForecast</h1>
";

            var footer = @"
</body>
</html>";

            var htmlContent = header;
            foreach (var weather in weatherForecasts)
            {
                htmlContent += $@"
    <h2>{weather.Date}</h2>
    <p>Summary: {weather.Summary}</p>
    <p>Temperature in Celsius: {weather.TemperatureC}</p>
    <p>Temperature in Fahrenheit: {weather.TemperatureF}</p>
";
            }
            htmlContent += footer;
            return htmlContent;
        }
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public string Summary { get; set; }

        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
    }
}
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace RestFullMinimalApi.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        private readonly ILogger<WeatherForecastController> _logger;

        public WeatherForecastController(ILogger<WeatherForecastController> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// Retrieves WeatherForecast
        /// </summary>
        /// <remarks>Awesomeness!</remarks>
        /// <response code="200">Retrieved</response>
        /// <response code="404">Not found</response>
        /// <response code="500">Oops! Can't lookup your request right now</response>
        [HttpGet(Name = "GetWeatherForecast")]
        public IEnumerable<WeatherForecast> Get()
        {
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }

        /// <summary>
        /// Retrieves WeatherForecast as Pdf
        /// </summary>
        /// <remarks>Awesomeness!</remarks>
        /// <response code="200">Retrieved</response>
        /// <response code="404">Not found</response>
        /// <response code="500">Oops! Can't lookup your request right now</response>
        [HttpGet("download", Name = "DownloadWeatherForecast")]
        public IActionResult GetWeatherPdf()
        {
            var results = Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            }).ToArray();

            var html = GetHtml(results);
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf(html);
            var fileName = "WeatherReport.pdf";
            pdf.SaveAs(fileName);

            var stream = new FileStream(fileName, FileMode.Open);
            // Return the PDF file for download
            return new FileStreamResult(stream, "application/octet-stream") { FileDownloadName = fileName };
        }

        private static string GetHtml(WeatherForecast[] weatherForecasts)
        {
            string header = @"
<html>
<head><title>WeatherForecast</title></head>
<body>
<h1>WeatherForecast</h1>
";

            var footer = @"
</body>
</html>";

            var htmlContent = header;
            foreach (var weather in weatherForecasts)
            {
                htmlContent += $@"
    <h2>{weather.Date}</h2>
    <p>Summary: {weather.Summary}</p>
    <p>Temperature in Celsius: {weather.TemperatureC}</p>
    <p>Temperature in Fahrenheit: {weather.TemperatureF}</p>
";
            }
            htmlContent += footer;
            return htmlContent;
        }
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureC { get; set; }
        public string Summary { get; set; }

        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
    }
}
$vbLabelText   $csharpLabel

Hier verwenden wir die Wetterdaten, um eine HTML-Zeichenfolge zu generieren, die dann verwendet wird, um ein PDF-Dokument zu erstellen.

HTML-Inhalt

Swashbuckle ASP .NET Core (Wie es für Entwickler funktioniert): Abbildung 4 - HTML-Inhalt für Wettervorhersage.

Und der PDF-Bericht sieht so aus:

Swashbuckle ASP .NET Core (Wie es für Entwickler funktioniert): Abbildung 5 - HTML zu PDF-Ausgabedatei: WeatherReport.pdf

Der komplette Code ist auf GitHub - Swashbuckle Demo Quellcode zu finden.
Das Dokument hat ein kleines Wasserzeichen für Testlizenzen, das mit einer gültigen Lizenz entfernt werden kann.

Lizenzierung (Kostenlose Testversion verfügbar)

Für das obige Codebeispiel ist ein Lizenzschlüssel erforderlich. Platzieren Sie diesen Schlüssel in der appsettings.json Datei.

{
    "IronPdf": {
        "LicenseKey": "your license key"
    }
}

Eine Testlizenz ist für Entwickler nach der Registrierung bei IronPDF Testregistrierung verfügbar. Für eine Testlizenz wird keine Kreditkarte benötigt. Registrieren Sie sich mit Ihrer E-Mail für eine kostenlose Testversion.

Abschluss

Das Verständnis von Swashbuckle und IronPDF ermöglicht es Ihnen, API-Dokumentations- und PDF-Erstellungsmöglichkeiten effektiv in Ihre ASP.NET Core-Anwendungen zu integrieren. IronPDF bietet auch eine umfassende Dokumentation für Erste Schritte zusammen mit verschiedenen Beispielcode für die PDF-Erstellung.

Zusätzlich können Sie verwandte Softwareprodukte von Iron Software erkunden, die Ihnen helfen, Ihre Programmierkenntnisse zu erweitern und den modernen Anforderungen von Anwendungen gerecht zu werden.

Häufig gestellte Fragen

Wie kann ich RESTful Web-APIs in ASP.NET Core mit Swashbuckle dokumentieren?

Swashbuckle kann verwendet werden, um RESTful Web-APIs zu dokumentieren, indem Swagger-Dokumentation aus XML-Kommentaren im Code generiert wird. Sie müssen das Swashbuckle.AspNetCore-Paket installieren und in der `Startup.cs`-Datei Ihres ASP.NET Core-Projekts konfigurieren.

Welche Schritte sind erforderlich, um Swashbuckle für ein neues ASP.NET Core-Web-API-Projekt einzurichten?

Um Swashbuckle einzurichten, installieren Sie zunächst das Swashbuckle.AspNetCore NuGet-Paket. Konfigurieren Sie dann die Swagger-Middleware in der `Startup.cs`-Datei, indem Sie `services.AddSwaggerGen()` in der `ConfigureServices`-Methode und `app.UseSwagger()` zusammen mit `app.UseSwaggerUI()` in der `Configure`-Methode hinzufügen.

Wie kann ich HTML-Inhalte in einer .NET Core-Anwendung in eine PDF-Datei umwandeln?

Sie können HTML-Inhalte in einer .NET Core-Anwendung mit IronPDF in PDF-Dateien umwandeln. Diese Bibliothek ermöglicht es, HTML-Zeichenfolgen, Dateien und URLs mithilfe von Methoden wie `RenderHtmlAsPdf` und `RenderUrlAsPdf` in PDF-Dokumente zu konvertieren.

Was sind die Vorteile der Verwendung von Swashbuckle in der API-Entwicklung?

Swashbuckle vereinfacht die API-Dokumentation durch das automatische Generieren von Swagger-kompatibler Dokumentation, was zur Aufrechterhaltung klarer und konsistenter API-Dokumentationsstandards beiträgt. Es bietet auch eine benutzerfreundliche Oberfläche zur Erkundung und zum Testen von APIs über die Swagger UI.

Wie integriere ich PDF-Generierungsfähigkeiten in ein ASP.NET Core-Projekt?

Die Integration der PDF-Erstellung in ein ASP.NET Core-Projekt kann mit IronPDF erreicht werden. Installieren Sie die IronPDF-Bibliothek über NuGet und verwenden Sie deren Methoden, um PDFs aus verschiedenen Inhaltstypen zu generieren. Stellen Sie sicher, dass Ihr Projekt die erforderlichen using-Direktiven und alle Lizenzschlüssel enthält.

Welche Konfigurationsoptionen stehen zur Anpassung der Swagger-Dokumentation in Swashbuckle zur Verfügung?

Swashbuckle bietet verschiedene Konfigurationsoptionen zur Anpassung der Swagger-Dokumentation, einschließlich der Einstellung der API-Versionsverwaltung, der Aktivierung von XML-Kommentaren, der Definition von Parameternamenskonventionen und der Anpassung des Erscheinungsbildes und Verhaltens der Swagger UI.

Wie kann ich häufig auftretende Probleme beim Einsatz von Swashbuckle in einem ASP.NET Core-Projekt beheben?

Häufige Probleme bei Swashbuckle können behoben werden, indem sichergestellt wird, dass die XML-Dokumentation in den Projekteigenschaften aktiviert ist, die korrekten Paketversionen überprüft und die korrekte Einrichtung in der `Startup.cs`-Datei verifiziert wird, einschließlich der richtigen Reihenfolge der Middleware.

Welche Funktionen bietet IronPDF für die PDF-Generierung in C#?

IronPDF bietet Funktionen wie das Konvertieren von HTML, URLs und ASP.NET-Inhalten in PDFs, das Hinzufügen von Kopf- und Fußzeilen, das Zusammenführen von PDFs und das Manipulieren vorhandener PDF-Dateien. Es ist eine umfassende Bibliothek zur Handhabung von PDF-Operationen in C#-Projekten.

Wie unterstützt IronPDF die Lizenzierung für kommerzielle Nutzung?

IronPDF unterstützt die Lizenzierung durch einen kommerziellen Lizenzschlüssel. Sie können IronPDF mit einer kostenlosen Testversion ausprobieren und den Lizenzschlüssel in Ihrer Projektkonfiguration einbinden, typischerweise innerhalb der `appsettings.json`-Datei unter dem Abschnitt `IronPDF`.

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 Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me