A migração do fo .NET (FO .NET) para o IronPDF representa uma grande atualização para o seu processo de geração de PDFs em .NET . Este guia oferece um caminho simples e passo a passo para migrar sua base de código da linguagem de marcação XSL-FO obsoleta para a geração moderna de PDFs baseada em HTML/CSS, utilizando as habilidades que sua equipe de desenvolvimento já possui.
fo.net (FO.NET) é um port do C# de uma construção inicial do Apache FOP que converte documentos XSL-FO em PDF. É licenciado pelo Apache 2.0, mas tem várias limitações para o desenvolvimento atual:
Tecnologia Obsoleta: XSL-FO (Objetos de Formatação de Linguagem de Folhas de Estilo Extensíveis) é uma especificação W3C de 2001; o W3C fechou o Grupo de Trabalho XSL-FO em 2013 e a linguagem não teve mais desenvolvimento.
Curva de aprendizado complexa: XSL-FO requer marcação complexa baseada em XML com objetos de formatação especializados (fo:block, fo:table, fo:page-sequence, etc.).
Sem Suporte a HTML/CSS: fo.net não pode renderizar HTML ou CSS — você deve transformar HTML em XSL-FO por conta própria (normalmente via XSLT).
Abandonado/Não mantido: O pacote Fonet no nuget.org foi publicado pela última vez em abril de 2011 (v1.0.0, .NET Framework 2.0). O fork da comunidade Fonet.Standard (.NET Standard 2.0) foi publicado pela última vez em maio de 2020 (v1.0.5). O repositório CodePlex está obsoleto e os forks no GitHub (prepare/FO.NET, nholik/FO.Net, hahmed/Fo.Net) estão inativos.
Apenas para Windows na prática: A construção legada Fonet depende de APIs System.Drawing (GDI+) que efetivamente o limitam ao Windows.
Recursos Modernos Limitados: Sem motor JavaScript, sem CSS3 (flexbox/grid), sem carregamento de fontes web modernas.
Sem renderização de URL: o .NET não consegue renderizar páginas da web diretamente — requer conversão manual de HTML para XSL-FO.
| Aspecto | fo .NET (FO .NET) | IronPDF |
|---|---|---|
| Formato de entrada | XSL-FO (XML desatualizado) | HTML/CSS (padrões modernos da web) |
| Curva de Aprendizagem | Íngreme (experiência em XSL-FO) | Gentil (conhecimento de HTML/CSS) |
| Manutenção | Abandonado (último lançamento em maio de 2020) | Mantido ativamente |
| Suporte da plataforma | Somente para Windows | Cross-platform (.NET Framework 4.6.2+, .NET Core 3.1+, .NET 5/6/7/8/9+) |
| Suporte a CSS | None | CSS3 completo (Flexbox, Grid) |
| JavaScript | None | Suporte completo aJavaScript |
| Renderização de URL | Não suportado | Embutido |
| Características modernas | Limitado | Cabeçalhos, rodapés, marcas d'água, segurança |
| Documentação | Desatualizado | Tutoriais completos |
O .NET foi projetado quando se esperava que o XSL-FO se tornasse um padrão para formatação de documentos. Essa expectativa nunca se concretizou. HTML/CSS tornou-se o formato universal de documentos, enquanto o XSL-FO permaneceu uma habilidade de nicho — a maioria dos recursos de XSL-FO data de 2005–2010, tornando a manutenção cada vez mais difícil.
IronPDF permite que você use as habilidades que já possui para criar PDFs profissionais no .NET moderno.
# Create a backup branch
git checkout -b pre-ironpdf-migration
git add .
git commit -m "Backup before fo.net to IronPDF migration"# Find all fo.net references
grep -r "FonetDriver\|Fonet\|\.fo\"\|xsl-region" --include="*.cs" --include="*.csproj" .
# Find all XSL-FO template files
find . -name "*.fo" -o -name "*.xslfo" -o -name "*xsl-fo*"Antes da migração, catalogue todos os arquivos XSL-FO e anote:
fo:static-content)# Remove fo.net package
dotnet remove package Fonet
dotnet remove package FO.NET
# Install IronPDF
dotnet add package IronPdf// Before (fo.net)
using Fonet;
using Fonet.Render.Pdf;
using System.Xml;
// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;Imports IronPdf
Imports IronPdf.Rendering// Set license key at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Set license key at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"// Before (fo.net with XSL-FO)
FonetDriver driver = FonetDriver.Make();
using (FileStream output = new FileStream("output.pdf", FileMode.Create))
{
driver.Render(new StringReader(xslFoContent), output);
}
// After (IronPDF with HTML)
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("output.pdf");Imports System.IO
Imports Fonet
Imports IronPdf
' Before (fo.net with XSL-FO)
Dim driver As FonetDriver = FonetDriver.Make()
Using output As FileStream = New FileStream("output.pdf", FileMode.Create)
driver.Render(New StringReader(xslFoContent), output)
End Using
' After (IronPDF with HTML)
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("output.pdf")| para o namespace .NET | Equivalente ao IronPDF |
|---|---|
Fonet | IronPdf |
Fonet.Render.Pdf | IronPdf |
Fonet.Layout | N / D |
Fonet.Fo | N / D |
Fonet.Image | IronPdf |
| Método FonetDriver | Equivalente ao IronPDF |
|---|---|
FonetDriver.Make() | new ChromePdfRenderer() |
driver.Render(inputStream, outputStream) | renderer.RenderHtmlAsPdf(html) |
driver.Render(inputFile, outputStream) | renderer.RenderHtmlFileAsPdf(path) |
driver.BaseDirectory | RenderingOptions.BaseUrl |
driver.OnError += handler | Tente/capture em torno do render |
| fo .NET (Atributos XSL-FO) | Opções de renderização do IronPDF |
|---|---|
page-height | PaperSize ou SetCustomPaperSize() |
page-width | PaperSize |
margin-top | MarginTop |
margin-bottom | MarginBottom |
margin-left | MarginLeft |
margin-right | MarginRight |
reference-orientation | PaperOrientation |
A mudança fundamental nesta migração para o .NET é a conversão dos elementos XSL-FO em seus equivalentes HTML:
| Elemento XSL-FO | Equivalente em HTML/CSS |
|---|---|
<fo:root> | <html> |
<fo:layout-master-set> | Regra de CSS @page |
<fo:simple-page-master> | CSS @page |
<fo:page-sequence> | <body> ou <div> |
<fo:flow> | <main> ou <div> |
<fo:static-content> | HtmlHeaderFooter |
<fo:block> | <p>, <div>, <h1>-<h6> |
<fo:inline> | <span> |
<fo:table> | <table> |
<fo:table-row> | <tr> |
<fo:table-cell> | <td>, <th> |
<fo:list-block> | <ul>, <ol> |
<fo:list-item> | <li> |
<fo:external-graphic> | <img> |
<fo:page-number> | Espaço reservado {page} |
<fo:page-number-citation> | {total-pages} |
<fo:basic-link> | <a href> |
| Propriedade XSL-FO | Equivalente em CSS | Exemplo |
|---|---|---|
font-family | font-family | Mesma sintaxe |
font-size | font-size | Mesma sintaxe |
font-weight | font-weight | bold, normal, 700 |
text-align | text-align | left, center, right, justify |
color | color | Hex, RGB, nomes |
background-color | background-color | Mesma sintaxe |
space-before | margin-top | Elemento anterior |
space-after | margin-bottom | Após o elemento |
start-indent | margin-left | Recuo à esquerda |
keep-together | page-break-inside: avoid | Evitar pausas |
break-before="page" | page-break-before: always | Forçar quebra de página |
Antes (fo .NET com XSL-FO):
// NuGet: Install-Package Fonet
using Fonet;
using Fonet.Render.Pdf;
using System.IO;
using System.Xml;
class Program
{
static void Main()
{
// fo.net requires XSL-FO format, not HTML
// First convert HTML to XSL-FO (manual process)
string xslFo = @"<?xml version='1.0' encoding='utf-8'?>
<fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>
<fo:layout-master-set>
<fo:simple-page-master master-name='page'>
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference='page'>
<fo:flow flow-name='xsl-region-body'>
<fo:block>Hello World</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>";
FonetDriver driver = FonetDriver.Make();
driver.Render(new StringReader(xslFo),
new FileStream("output.pdf", FileMode.Create));
}
}' NuGet: Install-Package Fonet
Imports Fonet
Imports Fonet.Render.Pdf
Imports System.IO
Imports System.Xml
Class Program
Shared Sub Main()
' fo.net requires XSL-FO format, not HTML
' First convert HTML to XSL-FO (manual process)
Dim xslFo As String = "<?xml version='1.0' encoding='utf-8'?>" & _
"<fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>" & _
"<fo:layout-master-set>" & _
"<fo:simple-page-master master-name='page'>" & _
"<fo:region-body/>" & _
"</fo:simple-page-master>" & _
"</fo:layout-master-set>" & _
"<fo:page-sequence master-reference='page'>" & _
"<fo:flow flow-name='xsl-region-body'>" & _
"<fo:block>Hello World</fo:block>" & _
"</fo:flow>" & _
"</fo:page-sequence>" & _
"</fo:root>"
Dim driver As FonetDriver = FonetDriver.Make()
driver.Render(New StringReader(xslFo),
New FileStream("output.pdf", FileMode.Create))
End Sub
End ClassApós (IronPDF com HTML):
// NuGet: Install-Package IronPdf
using IronPdf;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
string html = "<h1>Hello World</h1><p>This is HTML content.</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim html As String = "<h1>Hello World</h1><p>This is HTML content.</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
End Sub
End ClassA abordagem IronPDF reduz mais de 25 linhas de marcação XSL-FO para apenas 4 linhas de código C# limpo. Para mais opções de conversão de HTML para PDF, consulte a documentação do IronPDF sobre HTML para PDF .
Antes (fo .NET com XSL-FO):
// NuGet: Install-Package Fonet
using Fonet;
using Fonet.Render.Pdf;
using System.IO;
class Program
{
static void Main()
{
// fo.net settings are configured in XSL-FO markup
string xslFo = @"<?xml version='1.0' encoding='utf-8'?>
<fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>
<fo:layout-master-set>
<fo:simple-page-master master-name='A4'
page-height='297mm' page-width='210mm'
margin-top='20mm' margin-bottom='20mm'
margin-left='25mm' margin-right='25mm'>
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference='A4'>
<fo:flow flow-name='xsl-region-body'>
<fo:block font-size='14pt'>Custom PDF</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>";
FonetDriver driver = FonetDriver.Make();
driver.Render(new StringReader(xslFo),
new FileStream("custom.pdf", FileMode.Create));
}
}' NuGet: Install-Package Fonet
Imports Fonet
Imports Fonet.Render.Pdf
Imports System.IO
Class Program
Shared Sub Main()
' fo.net settings are configured in XSL-FO markup
Dim xslFo As String = "<?xml version='1.0' encoding='utf-8'?>
<fo:root xmlns:fo='http://www.w3.org/1999/XSL/Format'>
<fo:layout-master-set>
<fo:simple-page-master master-name='A4'
page-height='297mm' page-width='210mm'
margin-top='20mm' margin-bottom='20mm'
margin-left='25mm' margin-right='25mm'>
<fo:region-body/>
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference='A4'>
<fo:flow flow-name='xsl-region-body'>
<fo:block font-size='14pt'>Custom PDF</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>"
Dim driver As FonetDriver = FonetDriver.Make()
driver.Render(New StringReader(xslFo),
New FileStream("custom.pdf", FileMode.Create))
End Sub
End ClassApós (IronPDF com HTML):
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Engines.Chrome;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
renderer.RenderingOptions.MarginLeft = 25;
renderer.RenderingOptions.MarginRight = 25;
string html = "<h1 style='font-size:14pt'>Custom PDF</h1>";
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("custom.pdf");
}
}' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Engines.Chrome
Module Program
Sub Main()
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25
Dim html As String = "<h1 style='font-size:14pt'>Custom PDF</h1>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("custom.pdf")
End Sub
End ModuleO IronPDF oferece opções de renderização programática em vez de incorporar a configuração na marcação XML.
Antes (fo .NET - não suportado):
// NuGet: Install-Package Fonet
using Fonet;
using System.IO;
using System.Net;
class Program
{
static void Main()
{
// fo.net does not support URL rendering directly
// Must manually download, convert HTML to XSL-FO, then render
string url = "https://example.com";
string html = new WebClient().DownloadString(url);
// Manual conversion from HTML to XSL-FO required (complex)
string xslFo = ConvertHtmlToXslFo(html); // Not built-in
FonetDriver driver = FonetDriver.Make();
driver.Render(new StringReader(xslFo),
new FileStream("webpage.pdf", FileMode.Create));
}
static string ConvertHtmlToXslFo(string html)
{
// Custom implementation required - extremely complex
throw new System.NotImplementedException();
}
}' NuGet: Install-Package Fonet
Imports Fonet
Imports System.IO
Imports System.Net
Class Program
Shared Sub Main()
' fo.net does not support URL rendering directly
' Must manually download, convert HTML to XSL-FO, then render
Dim url As String = "https://example.com"
Dim html As String = New WebClient().DownloadString(url)
' Manual conversion from HTML to XSL-FO required (complex)
Dim xslFo As String = ConvertHtmlToXslFo(html) ' Not built-in
Dim driver As FonetDriver = FonetDriver.Make()
driver.Render(New StringReader(xslFo),
New FileStream("webpage.pdf", FileMode.Create))
End Sub
Shared Function ConvertHtmlToXslFo(html As String) As String
' Custom implementation required - extremely complex
Throw New System.NotImplementedException()
End Function
End ClassApós (IronPDF - suporte integrado):
// NuGet: Install-Package IronPdf
using IronPdf;
class Program
{
static void Main()
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderUrlAsPdf("https://example.com");
pdf.SaveAs("webpage.pdf");
}
}Imports IronPdf
Class Program
Shared Sub Main()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
pdf.SaveAs("webpage.pdf")
End Sub
End ClassA renderização de URL para PDF é uma das vitórias práticas nesta migração fo.net:IronPDF lida com isso nativamente com execução de JavaScript. Saiba mais sobre a conversão de URL para PDF .
Antes (fo .NET com XSL-FO):
<fo:static-content flow-name="xsl-region-before">
<fo:block text-align="center" font-size="10pt">
Company Name - Confidential
</fo:block>
</fo:static-content>
<fo:static-content flow-name="xsl-region-after">
<fo:block text-align="right" font-size="10pt">
Page <fo:page-number/> of <fo:page-number-citation ref-id="last-page"/>
</fo:block>
</fo:static-content>Após (IronPDF):
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center; font-size:10pt;'>Company Name - Confidential</div>",
DrawDividerLine = true
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:right; font-size:10pt;'>Page {page} of {total-pages}</div>",
DrawDividerLine = true
};Imports System
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center; font-size:10pt;'>Company Name - Confidential</div>",
.DrawDividerLine = True
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:right; font-size:10pt;'>Page {page} of {total-pages}</div>",
.DrawDividerLine = True
}O IronPDF substitui definições complexas de região XSL-FO por cabeçalhos e rodapés HTML simples.
Antes (fo .NET):
// fo.net has very limited PDF security options
// Must use post-processing with another library' fo.net has very limited PDF security options
' Must use post-processing with another libraryApós (IronPDF):
using IronPdf;
public byte[] GenerateSecurePdf(string html)
{
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Set metadata
pdf.MetaData.Title = "Confidential Report";
pdf.MetaData.Author = "Company Name";
// Password protection
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user456";
// Restrict permissions
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.NoEdit;
return pdf.BinaryData;
}Imports IronPdf
Public Function GenerateSecurePdf(html As String) As Byte()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Set metadata
pdf.MetaData.Title = "Confidential Report"
pdf.MetaData.Author = "Company Name"
' Password protection
pdf.SecuritySettings.OwnerPassword = "owner123"
pdf.SecuritySettings.UserPassword = "user456"
' Restrict permissions
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint
pdf.SecuritySettings.AllowUserEdits = IronPdf.Security.PdfEditSecurity.NoEdit
Return pdf.BinaryData
End FunctionPara desempenho ideal durante sua migração fo.net, reutilize a instância ChromePdfRenderer:
// GOOD - Reuse the renderer
public class PdfService
{
private static readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();
public byte[] Generate(string html) => _renderer.RenderHtmlAsPdf(html).BinaryData;
}
// BAD - Creating new instance each time
public byte[] GenerateBad(string html)
{
var renderer = new ChromePdfRenderer(); // Wasteful
return renderer.RenderHtmlAsPdf(html).BinaryData;
}Imports System
' GOOD - Reuse the renderer
Public Class PdfService
Private Shared ReadOnly _renderer As New ChromePdfRenderer()
Public Function Generate(html As String) As Byte()
Return _renderer.RenderHtmlAsPdf(html).BinaryData
End Function
End Class
' BAD - Creating new instance each time
Public Function GenerateBad(html As String) As Byte()
Dim renderer As New ChromePdfRenderer() ' Wasteful
Return renderer.RenderHtmlAsPdf(html).BinaryData
End Functionfo .NET XSL-FO usa várias unidades. O IronPDF usa milímetros para as margens. Aqui está uma classe auxiliar:
public static class UnitConverter
{
public static double InchesToMm(double inches) => inches * 25.4;
public static double PointsToMm(double points) => points * 0.352778;
public static double PicasToMm(double picas) => picas * 4.233;
public static double CmToMm(double cm) => cm * 10;
}
// Usage
renderer.RenderingOptions.MarginTop = UnitConverter.InchesToMm(1); // 1 inchPublic Module UnitConverter
Public Function InchesToMm(inches As Double) As Double
Return inches * 25.4
End Function
Public Function PointsToMm(points As Double) As Double
Return points * 0.352778
End Function
Public Function PicasToMm(picas As Double) As Double
Return picas * 4.233
End Function
Public Function CmToMm(cm As Double) As Double
Return cm * 10
End Function
End Module
' Usage
renderer.RenderingOptions.MarginTop = UnitConverter.InchesToMm(1) ' 1 inchProblema: O tamanho da página PDF parece diferente após a migração para .NET .
Solução: Mapeie corretamente as dimensões da página XSL-FO:
// XSL-FO: page-height='11in' page-width='8.5in' (Letter)
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
// XSL-FO: page-height='297mm' page-width='210mm' (A4)
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
// Custom size (in mm)
renderer.RenderingOptions.SetCustomPaperSize(210, 297);' XSL-FO: page-height='11in' page-width='8.5in' (Letter)
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
' XSL-FO: page-height='297mm' page-width='210mm' (A4)
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
' Custom size (in mm)
renderer.RenderingOptions.SetCustomPaperSize(210, 297)Problema: Não tem certeza do que <fo:block> deve se tornar.
Solução: Utilize HTML semântico apropriado:
<h1> até <h6><p><div><span>Problema: As fontes parecem diferentes da saída do .NET .
Solução: Utilize fontes da web ou especifique fontes do sistema em CSS:
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
body { font-family: 'Roboto', Arial, sans-serif; }
</style>Problema: <fo:page-number/> não funciona.
Solução: Utilize marcadores de posição do IronPDF em cabeçalhos/rodapés:
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align:center;'>Page {page} of {total-pages}</div>",
MaxHeight = 15 // mm
};Imports System
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align:center;'>Page {page} of {total-pages}</div>",
.MaxHeight = 15 ' mm
}.fo, .xslfo)fo:static-content)Fonet ou FO.NET: dotnet remove package FonetIronPdf: dotnet add package IronPdfFonet para IronPdfFonetDriver.Make() por new ChromePdfRenderer()driver.Render() por renderer.RenderHtmlAsPdf()pdf.SaveAs()fo:static-content para HtmlHeaderFooter<fo:page-number/> por espaço reservado {page}.fo e .xslfoPara uma cobertura mais completa da superfície de IronPDF usada acima, consulte a referência de API do IronPDF.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
