RESTful uç noktalarla HTML'den PDF'e dönüşüm, birleştirme, filigran ekleme ve dinamik şablon işleme için tutarlı belge oluşturma olanağı sağlayarak PDF oluşturma mantığını merkezileştiren bir üretime hazır .NET PDF API'si oluşturun.
Modern uygulamalarla çalışırken, .NET geliştiricileri genellikle merkezi bir PDF oluşturma hizmeti oluşturmaları gerekebilir. Faturalar, raporlar, sertifikalar veya sözleşmeler oluşturuyor olsanız da, özel bir .NET PDF API, PDF oluşturma iş akışınızı iyileştirir. Nasıl yardımcı olur? Masaüstü ve web uygulamalarınız arasında tutarlılık, sürdürülebilirlik ve ölçeklenebilirlik sağlar. Belge içeriğini, PDF sayfalarını ve PDF form alanlarını yönetmek basit olur.
Bu eğitimde, güçlü bir .NET PDF kütüphanesi olan IronPDF kullanarak ASP.NET Core ile üretime hazır bir PDF API'si oluşturmayı öğreneceksiniz. HTML'den PDF oluşturabilen, belgeleri birleştiren veya ayıran, filigran ekleyen ve Web API'nizdeki çeşitli gerçek dünya PDF senaryolarını işleyen RESTful uç noktalar oluşturacağız.
Koda dalmadan önce, özel bir PDF API oluşturmanın neden mantıklı olduğunu anlayalım:
İşe başlamaya hazır mısınız? IronPDF'nin ücretsiz deneme sürümünü indirin ve bu eğitime katılarak NET Framework projelerinizde programatik olarak PDF dosyaları oluşturun.
IronPDF, .NET geliştiricileri için önde gelen PDF kütüphanesi olarak öne çıkar ve Web API projelerinde PDF oluşturmayı basit ve güvenilir bir hale getiren kapsamlı özellikler sunar. Chrome render motoru üzerine inşa edilmiştir ve sadece birkaç kod satırıyla piksel mükemmelliğinde HTML'den PDF'e dönüşümler sağlar. Üstelik tüm JavaScript yürütmeleri ve duyarlı düzenleri korur.
IronPDF'yi .NET PDF API geliştirme için ideal kılan önemli yetenekler:
Yeni bir ASP.NET Core Web API projesi oluşturarak ve gerekli paketleri yükleyerek başlayalım.
Öncelikle, PDF oluşturma aracımızı inşa edeceğimiz projeyi oluşturalım.
dotnet new webapi -n PdfApiService
cd PdfApiServiceSonraki adım projeye IronPDF'yi NuGet üzerinden eklemektir.
Ya da, Visual Studio'daki NuGet Paket Yöneticisi Konsolunu kullanarak:
platforma özgü paketler, Docker kurulumu veya Linux yapılandırmaları dahil olmak üzere gelişmiş kurulum seçenekleri için IronPDF kurulum dokümanına göz atın.
İyi bir C# geliştirmesi, temiz ve iyi yapılandırılmış bir proje klasörünü korumayı gerektirir. Örneğin:
HTML'yi PDF biçimine dönüştüren basit bir uç nokta oluşturalım. İlk olarak, servis arayüzünü ve uygulamasını oluşturun:
Öncelikle, aşağıdakileri IPdfService.cs dosyanıza ekleyin:
public interface IPdfService
{
byte[] GeneratePdfFromHtml(string htmlContent);
byte[] GeneratePdfFromUrl(string url);
}Public Interface IPdfService
Function GeneratePdfFromHtml(htmlContent As String) As Byte()
Function GeneratePdfFromUrl(url As String) As Byte()
End InterfacePdfService.cs dosyasına şu eklemeyi yapın:
using IronPdf;
public class PdfService : IPdfService
{
private readonly ChromePdfRenderer _renderer;
public PdfService()
{
_renderer = new ChromePdfRenderer();
// Configure rendering options for optimal PDF generation in .NET
_renderer.RenderingOptions.MarginTop = 20;
_renderer.RenderingOptions.MarginBottom = 20;
_renderer.RenderingOptions.PrintHtmlBackgrounds = true;
}
public byte[] GeneratePdfFromHtml(string htmlContent)
{
// Generate PDF from HTML using the .NET PDF API
var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
return pdf.BinaryData;
}
public byte[] GeneratePdfFromUrl(string url)
{
// Convert URL to PDF in the REST API
var pdf = _renderer.RenderUrlAsPdf(url);
return pdf.BinaryData;
}
}Imports IronPdf
Public Class PdfService
Implements IPdfService
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer()
' Configure rendering options for optimal PDF generation in .NET
_renderer.RenderingOptions.MarginTop = 20
_renderer.RenderingOptions.MarginBottom = 20
_renderer.RenderingOptions.PrintHtmlBackgrounds = True
End Sub
Public Function GeneratePdfFromHtml(htmlContent As String) As Byte()
' Generate PDF from HTML using the .NET PDF API
Dim pdf = _renderer.RenderHtmlAsPdf(htmlContent)
Return pdf.BinaryData
End Function
Public Function GeneratePdfFromUrl(url As String) As Byte()
' Convert URL to PDF in the REST API
Dim pdf = _renderer.RenderUrlAsPdf(url)
Return pdf.BinaryData
End Function
End ClassPdfService HTML'i PDF'ye dönüştürmeyi yönetir. IronPDF'nin ChromePdfRenderer kullanılarak, bu sınıf sayfa kenar boşlukları ve arka plan render'lama gibi varsayılanları profesyonel sonuçlar için yapılandırır. Gelişmiş render yapılandırmaları için IronPDF'nin render seçeneklerini keşfedin.
Kontrolör ham HTML'yi geçerken, hizmet bunu yüksek kaliteli bir PDF'ye dönüştürür ve indirme için bayt verilerini geri döndürür. Ayrıca, URL to PDF conversion kullanarak tüm web sayfalarını doğrudan PDF'lere dönüştürür.
Şimdi API'niz için kontrolörü oluşturun. Bu, sisteminize PDF belgelerini indirme ve kaydetme izni veren HTML'den PDF dosyaları oluşturan bir uç nokta sağlar.
// Controllers/PdfController.cs
using Microsoft.AspNetCore.Mvc;
[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
private readonly IPdfService _pdfService;
public PdfController(IPdfService pdfService)
{
_pdfService = pdfService;
}
[HttpPost("html-to-pdf")]
public IActionResult ConvertHtmlToPdf([FromBody] HtmlRequest request)
{
try
{
var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
// Return as downloadable file
return File(pdfBytes, "application/pdf", "document.pdf");
}
catch (Exception ex)
{
return BadRequest($"Error generating PDF: {ex.Message}");
}
}
}Imports Microsoft.AspNetCore.Mvc
<ApiController>
<Route("api/[controller]")>
Public Class PdfController
Inherits ControllerBase
Private ReadOnly _pdfService As IPdfService
Public Sub New(pdfService As IPdfService)
_pdfService = pdfService
End Sub
<HttpPost("html-to-pdf")>
Public Function ConvertHtmlToPdf(<FromBody> request As HtmlRequest) As IActionResult
Try
Dim pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent)
' Return as downloadable file
Return File(pdfBytes, "application/pdf", "document.pdf")
Catch ex As Exception
Return BadRequest($"Error generating PDF: {ex.Message}")
End Try
End Function
End ClassDaha sonra, HtmlRequest.cs dosyasında şu eklemeyi yapın:
// Models/HtmlRequest.cs
public class HtmlRequest
{
public string HtmlContent { get; set; }
public string FileName { get; set; } = "document.pdf";
}' Models/HtmlRequest.vb
Public Class HtmlRequest
Public Property HtmlContent As String
Public Property FileName As String = "document.pdf"
End ClassBu, HTML'yi indirilebilir bir PDF'ye dönüştüren bir API uç noktası kurar. Biri HTML gönderdiğinde api/pdf/html-to-pdf, PdfController dönüşümü hizmete devreder.
Oluşturulduğunda, denetleyici PDF'yi indirilebilir bir dosya olarak geri verir. İstek, HTML ve isteğe bağlı bir dosya adını içeren HtmlRequest modelini kullanır. Bu, istemcilerin HTML göndermesini ve düzgün bir PDF almasını kolaylaştırır.
PDF hizmetini kaydetmek için Program.cs güncelleyin:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// Register PDF service
builder.Services.AddSingleton<IPdfService, PdfService>();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.MapControllers();
app.Run();Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
builder.Services.AddEndpointsApiExplorer()
builder.Services.AddSwaggerGen()
' Register PDF service
builder.Services.AddSingleton(Of IPdfService, PdfService)()
Dim app = builder.Build()
If app.Environment.IsDevelopment() Then
app.UseSwagger()
app.UseSwaggerUI()
End If
app.UseHttpsRedirection()
app.MapControllers()
app.Run()API'niz, istemci ihtiyaçlarına dayalı olarak PDF'leri farklı yollarla döndürebilmelidir:
[HttpPost("generate")]
public IActionResult GeneratePdf([FromBody] PdfRequest request)
{
var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
switch (request.ResponseType?.ToLower())
{
case "base64":
return Ok(new
{
data = Convert.ToBase64String(pdfBytes),
filename = request.FileName
});
case "inline":
return File(pdfBytes, "application/pdf");
default: // download
return File(pdfBytes, "application/pdf", request.FileName);
}
}Imports Microsoft.AspNetCore.Mvc
<HttpPost("generate")>
Public Function GeneratePdf(<FromBody> request As PdfRequest) As IActionResult
Dim pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent)
Select Case request.ResponseType?.ToLower()
Case "base64"
Return Ok(New With {
.data = Convert.ToBase64String(pdfBytes),
.filename = request.FileName
})
Case "inline"
Return File(pdfBytes, "application/pdf")
Case Else ' download
Return File(pdfBytes, "application/pdf", request.FileName)
End Select
End FunctionBu, esnek bir PDF oluşturma uç noktası ekler. İndirme işlemlerine zorlamak yerine, GeneratePdf yöntemi, sonuçların nasıl alınacağını seçmelerine olanak tanır: indirme olarak, tarayıcıda satır içi veya API kullanımı için Base64 kodlu olarak.
PdfRequest modeli, HtmlRequest ile bir ResponseType seçeneği ekler. Bu, kullanıcılara PDF teslimi üzerinde kontrol sağlar, böylece API'yi daha esnek hale getirir. Dosya sistemi erişimi olmadan bellekte PDF'lerin işlenmesi için, IronPDF'nin bellek akışı belgelerine bakın.
Programımızı çalıştırdığımızda, bu çıktıyı Swagger'da göreceğiz:
Hizmetimizi çeşitli PDF oluşturma senaryolarını ele alacak şekilde genişletelim:
[HttpPost("url-to-pdf")]
public async Task<IActionResult> ConvertUrlToPdf([FromBody] UrlRequest request)
{
try
{
var pdfBytes = await Task.Run(() =>
_pdfService.GeneratePdfFromUrl(request.Url));
return File(pdfBytes, "application/pdf",
$"{request.FileName ?? "website"}.pdf");
}
catch (Exception ex)
{
return BadRequest($"Failed to convert URL: {ex.Message}");
}
}
public class UrlRequest
{
public string Url { get; set; }
public string FileName { get; set; }
}Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
<HttpPost("url-to-pdf")>
Public Async Function ConvertUrlToPdf(<FromBody> request As UrlRequest) As Task(Of IActionResult)
Try
Dim pdfBytes = Await Task.Run(Function() _pdfService.GeneratePdfFromUrl(request.Url))
Return File(pdfBytes, "application/pdf", $"{If(request.FileName, "website")}.pdf")
Catch ex As Exception
Return BadRequest($"Failed to convert URL: {ex.Message}")
End Try
End Function
Public Class UrlRequest
Public Property Url As String
Public Property FileName As String
End ClassBu uç nokta, URL'leri indirilebilir PDF'lere dönüştürür. Bir POST isteği /api/pdf/url-to-pdf ulaştığında, denetleyici @--CODE-644--@@ kullanarak arka planda URL'yi PDF baytlarına dönüştürür, ardından indirme için geri gelir. Dönüştürme başarısız olursa, açık bir hata mesajı ile yanıt verir. Kimlik doğrulama gerektiren web siteleri için IronPDF'nin giriş belgelerine göz atın.
"https://www.apple.com/nz" URL'sini kullanmayı deneyin ve POST isteğini test edin. Aşağıda elde ettiğimiz çıktı:
public byte[] AddWatermarkFromFile(string filePath, string watermarkText)
{
// Load PDF directly from file
var pdf = PdfDocument.FromFile(filePath);
pdf.ApplyWatermark(
$"<h1 style='color:red;font-size:72px;'>{watermarkText}</h1>",
75,
IronPdf.Editing.VerticalAlignment.Middle,
IronPdf.Editing.HorizontalAlignment.Center
);
return pdf.BinaryData;
}Imports IronPdf
Public Function AddWatermarkFromFile(filePath As String, watermarkText As String) As Byte()
' Load PDF directly from file
Dim pdf = PdfDocument.FromFile(filePath)
pdf.ApplyWatermark(
$"<h1 style='color:red;font-size:72px;'>{watermarkText}</h1>",
75,
IronPdf.Editing.VerticalAlignment.Middle,
IronPdf.Editing.HorizontalAlignment.Center
)
Return pdf.BinaryData
End FunctionBu, bir yerel dosyayı test için manuel olarak yükler. PDF API'nizin bir PDF oluşturmasını, ardından kolayca özel filigranlar uygulamasını ayarlayabilirsiniz. Gelişmiş filigranlama seçenekleri için, resim filigranları ve özel pozisyonlandırma dahil, filigran rehberine bakın.
Gerçek dünya uygulamaları için, genellikle dinamik verilerle şablonlardan PDF'ler oluşturmanız gerekecektir:
[HttpPost("from-template")]
public IActionResult GenerateFromTemplate([FromBody] TemplateRequest request)
{
// Simple template replacement
var html = request.Template;
foreach (var item in request.Data)
{
html = html.Replace($"{{{{{item.Key}}}}}", item.Value);
}
var pdfBytes = _pdfService.GeneratePdfFromHtml(html);
return File(pdfBytes, "application/pdf", request.FileName);
}
public class TemplateRequest
{
public string Template { get; set; }
public Dictionary<string, string> Data { get; set; }
public string FileName { get; set; } = "document.pdf";
}Imports Microsoft.AspNetCore.Mvc
<HttpPost("from-template")>
Public Function GenerateFromTemplate(<FromBody> request As TemplateRequest) As IActionResult
' Simple template replacement
Dim html As String = request.Template
For Each item In request.Data
html = html.Replace($"{{{{{item.Key}}}}}", item.Value)
Next
Dim pdfBytes As Byte() = _pdfService.GeneratePdfFromHtml(html)
Return File(pdfBytes, "application/pdf", request.FileName)
End Function
Public Class TemplateRequest
Public Property Template As String
Public Property Data As Dictionary(Of String, String)
Public Property FileName As String = "document.pdf"
End ClassRazor, Handlebars veya diğer tarayıcılarla gelişmiş şablon senaryoları için IronPDF'nin HTML'den PDF'ye belgelerine göz atın. CSHTML'den PDF'e dönüşüm için MVC uygulamalarını ve Blazor uygulamaları için Razor'dan PDF dönüşümünü de explore edin. Başsız Razor render işlemi için, CSHTML başsız kılavuzuna bakın.
Bir üretim PDF API'si oluştururken, performans son derece önemlidir. İşte önemli optimizasyon stratejileri:
Projeniz I/O işlemlerini içeriyorsa, asenkron kodlamayı kullanın. PDF içeriğiniz dış kaynaklardan geldiğinde bu özellikle yardımcıdır:
RenderUrlAsPdf)Bu işlemler ileti dizelerini engelleyebilir, ancak async API ileti dizelerinin boşta beklemesini engeller. kapsamlı asenkron PDF oluşturma desenleri için, asenkron PDF oluşturma kılavuzuna bakın.
Örnek:
public async Task<byte[]> GeneratePdfFromHtmlAsync(string htmlContent)
{
return await Task.Run(() =>
{
var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
return pdf.BinaryData;
});
}Imports System.Threading.Tasks
Public Async Function GeneratePdfFromHtmlAsync(htmlContent As String) As Task(Of Byte())
Return Await Task.Run(Function()
Dim pdf = _renderer.RenderHtmlAsPdf(htmlContent)
Return pdf.BinaryData
End Function)
End FunctionParalel PDF oluşturma senaryoları için, çoklu iş parçacıklı ve paralel işleme tekniklerini keşfedin.
IronPDF'yi optimal performans için yapılandırın:
_renderer.RenderingOptions.EnableJavaScript = false; // If JS not needed
_renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
_renderer.RenderingOptions.RenderDelay = 0; // Remove if no JS
_renderer.RenderingOptions.Timeout = 30; // Set reasonable timeoutnetviewport ayarları, özel kağıt boyutları ve sayfa yönlendirmesi dahil kapsamlı render yapılandırma seçenekleri için render seçenekleri belgelerine bakın.
Her üretim API'si için güvenlik esastır. İşte basit bir API anahtar doğrulama yaklaşımı:
// Middleware/ApiKeyMiddleware.cs
public class ApiKeyMiddleware
{
private readonly RequestDelegate _next;
private const string ApiKeyHeader = "X-API-Key";
public ApiKeyMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
if (!context.Request.Headers.TryGetValue(ApiKeyHeader, out var apiKey))
{
context.Response.StatusCode = 401;
await context.Response.WriteAsync("API Key required");
return;
}
// Validate API key (in production, check against database)
var validApiKey = context.RequestServices
.GetRequiredService<IConfiguration>()["ApiKey"];
if (apiKey != validApiKey)
{
context.Response.StatusCode = 403;
await context.Response.WriteAsync("Invalid API Key");
return;
}
await _next(context);
}
}
// In Program.cs
app.UseMiddleware<ApiKeyMiddleware>();Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.Configuration
Imports System.Threading.Tasks
' Middleware/ApiKeyMiddleware.vb
Public Class ApiKeyMiddleware
Private ReadOnly _next As RequestDelegate
Private Const ApiKeyHeader As String = "X-API-Key"
Public Sub New(next As RequestDelegate)
_next = next
End Sub
Public Async Function InvokeAsync(context As HttpContext) As Task
Dim apiKey As String = Nothing
If Not context.Request.Headers.TryGetValue(ApiKeyHeader, apiKey) Then
context.Response.StatusCode = 401
Await context.Response.WriteAsync("API Key required")
Return
End If
' Validate API key (in production, check against database)
Dim validApiKey As String = context.RequestServices.GetRequiredService(Of IConfiguration)()("ApiKey")
If apiKey <> validApiKey Then
context.Response.StatusCode = 403
Await context.Response.WriteAsync("Invalid API Key")
Return
End If
Await _next(context)
End Function
End Class
' In Program.vb
app.UseMiddleware(Of ApiKeyMiddleware)()Gelişmiş kimlik doğrulama senaryoları için düşünün:
PDF'ye özgü güvenlik için, potansiyel tehlikeli içeriği kaldırmak için şifre koruması, dijital imzalar ve PDF temizleme uygulayın.
Tam bir uygulama gösteren pratik bir fatura oluşturma uç noktası oluşturalım. Bu örnek, bir üretim .NET PDF API'sının dinamik verilerle profesyonel faturalar nasıl oluşturduğunu gösteriyor.
Öncelikle, Modeller klasörünüzde yeni bir dosya oluşturun. Burada, kendiminkini Invoice.cs olarak adlandırdım. Daha sonra, aşağıdaki kodu ekleyin:
public class Invoice
{
public string InvoiceNumber { get; set; }
public DateTime Date { get; set; }
public string CustomerName { get; set; }
public string CustomerAddress { get; set; }
public List<InvoiceItem> Items { get; set; }
public decimal Tax { get; set; }
}
public class InvoiceItem
{
public string Description { get; set; }
public int Quantity { get; set; }
public decimal UnitPrice { get; set; }
public decimal Total => Quantity * UnitPrice;
}Public Class Invoice
Public Property InvoiceNumber As String
Public Property [Date] As DateTime
Public Property CustomerName As String
Public Property CustomerAddress As String
Public Property Items As List(Of InvoiceItem)
Public Property Tax As Decimal
End Class
Public Class InvoiceItem
Public Property Description As String
Public Property Quantity As Integer
Public Property UnitPrice As Decimal
Public ReadOnly Property Total As Decimal
Get
Return Quantity * UnitPrice
End Get
End Property
End ClassSonra, fatura oluşturucu için yeni bir servis dosyası oluşturun. Hizmetler klasörünüzde, aşağıdaki kodu ekleyin. InvoiceService.cs adlı bir dosya oluşturdum. Bu kod, Fatura PDF'nizin stilini ve düzenini işler:
public class InvoiceService
{
private readonly ChromePdfRenderer _renderer;
public InvoiceService()
{
_renderer = new ChromePdfRenderer();
_renderer.RenderingOptions.MarginTop = 10;
_renderer.RenderingOptions.MarginBottom = 10;
_renderer.RenderingOptions.PrintHtmlBackgrounds = true;
}
public byte[] GenerateInvoice(Invoice invoice)
{
var html = BuildInvoiceHtml(invoice);
// Add footer with page numbers
_renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
MaxHeight = 15,
HtmlFragment = "<center><i>{page} of {total-pages}</i></center>",
DrawDividerLine = true
};
var pdf = _renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
private string BuildInvoiceHtml(Invoice invoice)
{
var subtotal = invoice.Items.Sum(i => i.Total);
var taxAmount = subtotal * (invoice.Tax / 100);
var total = subtotal + taxAmount;
var itemsHtml = string.Join("", invoice.Items.Select(item =>
$@"<tr>
<td>{item.Description}</td>
<td class='text-center'>{item.Quantity}</td>
<td class='text-right'>${item.UnitPrice:F2}</td>
<td class='text-right'>${item.Total:F2}</td>
</tr>"));
return $@"
<!DOCTYPE html>
<html>
<head>
<style>
body {{font-family: Arial, sans-serif;}}
.invoice-header {{background-color: #f8f9fa;
padding: 20px;
margin-bottom: 20px;}}
table {{width: 100%;
border-collapse: collapse;}}
th, td {{padding: 10px;
border-bottom: 1px solid #ddd;}}
th {{background-color: #007bff;
color: white;}}
.text-right {{text-align: right;}}
.text-center {{text-align: center;}}
.total-section {{margin-top: 20px;
text-align: right;}}
</style>
</head>
<body>
<div class='invoice-header'>
<h1>Invoice #{invoice.InvoiceNumber}</h1>
<p>Date: {invoice.Date:yyyy-MM-dd}</p>
</div>
<div>
<h3>Bill To:</h3>
<p>{invoice.CustomerName}<br/>{invoice.CustomerAddress}</p>
</div>
<table>
<thead>
<tr>
<th>Description</th>
<th>Quantity</th>
<th>Unit Price</th>
<th>Total</th>
</tr>
</thead>
<tbody>
{itemsHtml}
</tbody>
</table>
<div class='total-section'>
<p>Subtotal: ${subtotal:F2}</p>
<p>Tax ({invoice.Tax}%): ${taxAmount:F2}</p>
<h3>Total: ${total:F2}</h3>
</div>
</body>
</html>";
}
}Son olarak, API'yi kullanarak faturalara erişmek ve oluşturmak için yeni bir Kontrolör oluşturun:
[ApiController]
[Route("api/[controller]")]
public class InvoiceController : ControllerBase
{
private readonly InvoiceService _invoiceService;
public InvoiceController(InvoiceService invoiceService)
{
_invoiceService = invoiceService;
}
[HttpPost("generate")]
public IActionResult GenerateInvoice([FromBody] Invoice invoice)
{
try
{
var pdfBytes = _invoiceService.GenerateInvoice(invoice);
var fileName = $"Invoice_{invoice.InvoiceNumber}.pdf";
return File(pdfBytes, "application/pdf", fileName);
}
catch (Exception ex)
{
return StatusCode(500, $"Error generating invoice: {ex.Message}");
}
}
}Imports Microsoft.AspNetCore.Mvc
<ApiController>
<Route("api/[controller]")>
Public Class InvoiceController
Inherits ControllerBase
Private ReadOnly _invoiceService As InvoiceService
Public Sub New(invoiceService As InvoiceService)
_invoiceService = invoiceService
End Sub
<HttpPost("generate")>
Public Function GenerateInvoice(<FromBody> invoice As Invoice) As IActionResult
Try
Dim pdfBytes = _invoiceService.GenerateInvoice(invoice)
Dim fileName = $"Invoice_{invoice.InvoiceNumber}.pdf"
Return File(pdfBytes, "application/pdf", fileName)
Catch ex As Exception
Return StatusCode(500, $"Error generating invoice: {ex.Message}")
End Try
End Function
End ClassGelişmiş fatura özellikleri için, barkodlar, QR kodları, sayfa numaraları ve özel başlıklar/altlıklar eklemeyi düşünün. Ayrıca, uzun vadeli arşivleme için PDF/A uyumluluğu uygulayabilir veya elektronik imza iş akışları ile entegre edebilirsiniz.
Bu eğitim yerel geliştirme üzerine odaklanırken, işte PDF API'nizi konteynere almanın kısa bir özeti:
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["PdfApiService.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build
FROM build AS publish
RUN dotnet publish -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
# IronPDF requires additional dependencies on Linux
RUN apt-get update && apt-get install -y \
libgdiplus \
libc6-dev \
libx11-dev \
&& rm -rf /var/lib/apt/lists/*
ENTRYPOINT ["dotnet", "PdfApiService.dll"].NET PDF API'nizin dağıtım kılavuzları için ayrıntılı bilgi için bakınız:
Hata toleranslı programlar için tutarlı hata yanıtları için küresel bir hata işleyici uygulayın:
// Middleware/ErrorHandlingMiddleware.cs
public class ErrorHandlingMiddleware
{
private readonly RequestDelegate _next;
private readonly ILogger<ErrorHandlingMiddleware> _logger;
public ErrorHandlingMiddleware(RequestDelegate next, ILogger<ErrorHandlingMiddleware> logger)
{
_next = next;
_logger = logger;
}
public async Task InvokeAsync(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
_logger.LogError(ex, "An error occurred processing request {Path}", context.Request.Path);
await HandleExceptionAsync(context, ex);
}
}
private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = ex switch
{
ArgumentNullException => 400,
UnauthorizedAccessException => 401,
_ => 500
};
var response = new
{
error = "An error occurred processing your request",
message = ex.Message,
statusCode = context.Response.StatusCode
};
await context.Response.WriteAsync(JsonSerializer.Serialize(response));
}
}' Middleware/ErrorHandlingMiddleware.vb
Public Class ErrorHandlingMiddleware
Private ReadOnly _next As RequestDelegate
Private ReadOnly _logger As ILogger(Of ErrorHandlingMiddleware)
Public Sub New(ByVal [next] As RequestDelegate, ByVal logger As ILogger(Of ErrorHandlingMiddleware))
_next = [next]
_logger = logger
End Sub
Public Async Function InvokeAsync(ByVal context As HttpContext) As Task
Try
Await _next(context)
Catch ex As Exception
_logger.LogError(ex, "An error occurred processing request {Path}", context.Request.Path)
Await HandleExceptionAsync(context, ex)
End Try
End Function
Private Shared Async Function HandleExceptionAsync(ByVal context As HttpContext, ByVal ex As Exception) As Task
context.Response.ContentType = "application/json"
context.Response.StatusCode = If(TypeOf ex Is ArgumentNullException, 400, If(TypeOf ex Is UnauthorizedAccessException, 401, 500))
Dim response = New With {
.error = "An error occurred processing your request",
.message = ex.Message,
.statusCode = context.Response.StatusCode
}
Await context.Response.WriteAsync(JsonSerializer.Serialize(response))
End Function
End ClassBelirli IronPDF sorun giderme senaryoları için bakınız:
Artık IronPDF'yi kullanarak ASP.NET Core ile farklı belge oluşturma senaryolarını ele alan sağlam bir .NET PDF API'si oluşturdunuz. Bu REST API, uygulamalarınızda merkezi PDF işlemleri için sağlam bir temel sağlar.
Öne çıkanlar:
IronPDF, geliştiricilere PDF oluşturma, PDF dosyalarını kaydetme ve HTML'yi etkili bir şekilde dönüştürme olanağı sağlar, bu da modern .NET Framework uygulamaları için gerekli PDF API'si haline getirir.
Üretim .NET PDF API'nizde IronPDF'yi uygulamaya hazır mısınız? İşte bir sonraki adımlarınız:
Bugün .NET PDF API'nizi oluşturun ve uygulama ekosisteminiz genelinde belge oluşturmayı IronPDF ile kolaylaştırın!
Curtis Chau, Bilgisayar Bilimleri alanında Lisans Derecesine (Carleton Üniversitesi) sahip ve Node.js, TypeScript, JavaScript ve React konularında uzmanlaşmış ön uç geliştirmeyle ilgileniyor. Sezgisel ve estetik açıdan hoş kullanıcı arayüzleri oluşturma tutkunu, Curtis modern çerçevelerle çalışmayı ve iyi yapılandırılmış, görsel olarak çekici kılavuzlar oluşturmayı seviyor.
IronPDF, IRONSUITE'in bir parçasıdır
Ofis belgeleriniz için 10 .NET API ürünü
PDF'nizin HTML gibi görünmesine ihtiyaç duyduğunuzda, hızlı.
