Produtos de Iron Software e Visual Studio 2026: Um guia completo de integração

Experiência IDE Melhorada com o Sistema de Design Fluent UI

O Visual Studio 2026 introduz uma experiência completamente redesenhada para o usuário com a interface renovada alinhada ao sistema de design Fluent UI da Microsoft. Os novos recursos incluem controles do editor aprimorados, maior clareza visual e mais controle sobre o tema geral do IDE. Os desenvolvedores agora podem escolher entre 11 novos temas com tonalidades, permitindo uma maior personalização do ambiente de codificação para corresponder às preferências pessoais e reduzir a tensão ocular durante longas sessões de desenvolvimento.

A experiência de configurações modernas substitui o diálogo tradicional Ferramentas > Opções por uma interface simplificada e amigável para o usuário. Esta experiência de usuário redesenhada torna mais fácil para os desenvolvedores da .NET configurar rapidamente seu ambiente de desenvolvimento, seja trabalhando em aplicativos web, ferramentas de interface de linha de comando ou projetos da edição enterprise.

Conforme observado por Elanchezhiyan P no Medium, o IDE possui um "redesenho Fluent UI com layouts e ícones mais limpos," tornando a experiência de desenvolvimento mais intuitiva e visualmente atraente.

Integração com o GitHub Copilot e Desenvolvimento Orientado por IA

Um dos avanços mais significativos no Visual Studio 2026 é a integração profunda do copilot em todo o IDE. O agente profiler copilot pode analisar o uso da CPU, alocações de memória e comportamento de runtime, fornecendo melhores respostas e insights do copilot para ajudar os desenvolvedores a otimizarem seu código. A assistência do copilot se estende a várias etapas do desenvolvimento, incluindo o explorador de testes, onde os desenvolvedores podem aproveitar a IA para gerar e corrigir testes unitários automaticamente.

O novo menu de contexto oferece acesso rápido às ações do Copilot, e a funcionalidade de colar adaptativa ajusta automaticamente o código colado para se adequar ao contexto do seu projeto. Esses recursos representam uma mudança fundamental em direção ao desenvolvimento orientado por IA, onde sugestões inteligentes ajudam os desenvolvedores a codificarem mais rápido sem sacrificar a qualidade do código.

Melhorias de Desempenho e Ferramentas de Compilação

O Visual Studio 2026 oferece melhorias substanciais de desempenho em todos os aspectos. Soluções com centenas de projetos existentes agora carregam 40% mais rápido do que no Visual Studio 2022. O depurador mostra tempos de inicialização até 30% mais rápidos ao usar F5, e as recompilações completas se aproximam mais das compilações incrementais graças às otimizações tanto no IDE quanto no runtime do .NET 10.

As ferramentas de compilação foram desacopladas do próprio IDE, o que significa que os desenvolvedores podem atualizar o Visual Studio com atualizações mensais automáticas sem afetar seus compiladores .NET ou C++. Esta separação garante que os fluxos de trabalho de integração contínua permaneçam estáveis enquanto os desenvolvedores se beneficiam dos recursos mais recentes e correções de bugs no IDE.

Melhorias na Cobertura de Código e Testes

Um grande avanço no Visual Studio 2026 é a disponibilidade da cobertura de código nas edições comunitária e profissional do Visual Studio pela primeira vez. Antes restrita à edição enterprise, os desenvolvedores agora podem analisar a janela de resultados de cobertura de código para entender quais partes do seu código são exercidas por testes unitários. Esta democratização das ferramentas de teste ajuda mais desenvolvedores a garantir que suas aplicações sejam bem testadas antes da implantação.

A opção de selecionar e analisar a cobertura de código permite que os desenvolvedores executem a cobertura de código para testes selecionados diretamente do menu de testes, com os resultados exibidos na janela de cobertura de código mostrando porcentagens para cada assembly, classe e método. O Visual Studio destaca linhas testadas diretamente no editor de código, facilitando a identificação de lacunas na cobertura de testes.

Primeiros passos com o IronPDF

IronPDF é uma biblioteca C# abrangente que permite aos desenvolvedores criar, editar e extrair conteúdo PDF em projetos .NET. Com o suporte do Visual Studio 2026 for .NET 10 e capacidades de depuração aprimoradas, trabalhar com o IronPDF torna-se ainda mais eficiente.

Para instalar o IronPDF no seu projeto Visual Studio 2026, abra o Console do Gerenciador de Pacotes NuGet e execute:

Install-Package IronPdf

Install-Package IronPdf

Ou utilize a CLI do .NET :

dotnet add package IronPdf

dotnet add package IronPdf

Saiba mais sobre a instalação do IronPDF

Conversão de HTML para PDF

using IronPdf;

// Create a new PDF from HTML string
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from Visual Studio 2026!</h1><p>Generated with IronPDF</p>");

// Save the PDF
pdf.SaveAs("output.pdf");

using IronPdf;

// Create a new PDF from HTML string
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from Visual Studio 2026!</h1><p>Generated with IronPDF</p>");

// Save the PDF
pdf.SaveAs("output.pdf");

Trabalhando com PDFs existentes

using IronPdf;

// Open an existing PDF
var pdf = PdfDocument.FromFile("existing.pdf");

// Add watermark
pdf.ApplyWatermark("<h2 style='color:red'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center);

// Extract text
string text = pdf.ExtractAllText();
Console.WriteLine(text);

// Save modified PDF
pdf.SaveAs("modified.pdf");

using IronPdf;

// Open an existing PDF
var pdf = PdfDocument.FromFile("existing.pdf");

// Add watermark
pdf.ApplyWatermark("<h2 style='color:red'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center);

// Extract text
string text = pdf.ExtractAllText();
Console.WriteLine(text);

// Save modified PDF
pdf.SaveAs("modified.pdf");

Formulários PDF e Assinaturas Digitais

O IronPDF suporta o trabalho com formulários PDF e assinaturas digitais, essenciais para aplicações em edições enterprise que exigem autenticação de documentos:

using IronPdf;
using IronPdf.Signing;

// Open a PDF with form fields
var pdf = PdfDocument.FromFile("form.pdf");

// Fill form fields
pdf.Form.Fields["Name"].Value = "John Developer";
pdf.Form.Fields["Email"].Value = "john@example.com";

// Sign the PDF (using CSP-based certificates)
var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

// Save the signed PDF
pdf.SaveAs("signed.pdf");

using IronPdf;
using IronPdf.Signing;

// Open a PDF with form fields
var pdf = PdfDocument.FromFile("form.pdf");

// Fill form fields
pdf.Form.Fields["Name"].Value = "John Developer";
pdf.Form.Fields["Email"].Value = "john@example.com";

// Sign the PDF (using CSP-based certificates)
var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

// Save the signed PDF
pdf.SaveAs("signed.pdf");

Os recursos de cobertura de código no Visual Studio 2026 ajudam a garantir que a lógica de preenchimento de formulários e de assinatura seja testada adequadamente em diferentes cenários.

Configuração do IronOCR

IronOCR permite aos desenvolvedores realizar operações de OCR em aplicativos .NET, suportando mais de 125 idiomas. Instalar o IronOCR no Visual Studio 2026 é simples:

Install-Package IronOcr

Install-Package IronOcr

Operações Básicas de OCR

using IronOcr;

// Initialize OCR engine
var ocr = new IronTesseract();

// Perform OCR on an image
using (var input = new OcrInput())
{
    input.AddImage("document.png");

    // Process the image
    var result = ocr.Read(input);

    // Extract text
    string text = result.Text;
    Console.WriteLine(text);

    // Get confidence level
    double confidence = result.Confidence;
    Console.WriteLine($"Confidence: {confidence}%");
}

using IronOcr;

// Initialize OCR engine
var ocr = new IronTesseract();

// Perform OCR on an image
using (var input = new OcrInput())
{
    input.AddImage("document.png");

    // Process the image
    var result = ocr.Read(input);

    // Extract text
    string text = result.Text;
    Console.WriteLine(text);

    // Get confidence level
    double confidence = result.Confidence;
    Console.WriteLine($"Confidence: {confidence}%");
}

Suporte a OCR Multilíngue

O suporte do IronOCR para múltiplos idiomas funciona perfeitamente com o suporte aprimorado a idiomas do Visual Studio 2026:

using IronOcr;

// Initialize with specific language
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.Spanish;

// Add additional languages
ocr.AddSecondaryLanguage(OcrLanguage.French);

using (var input = new OcrInput())
{
    input.AddImage("multilingual-document.png");
    var result = ocr.Read(input);

    // Process multilingual text
    foreach (var page in result.Pages)
    {
        Console.WriteLine($"Page {page.PageNumber}: {page.Text}");
    }
}

using IronOcr;

// Initialize with specific language
var ocr = new IronTesseract();
ocr.Language = OcrLanguage.Spanish;

// Add additional languages
ocr.AddSecondaryLanguage(OcrLanguage.French);

using (var input = new OcrInput())
{
    input.AddImage("multilingual-document.png");
    var result = ocr.Read(input);

    // Process multilingual text
    foreach (var page in result.Pages)
    {
        Console.WriteLine($"Page {page.PageNumber}: {page.Text}");
    }
}

OCR com Aprimoramento de Imagem

O IronOCR inclui capacidades de aprimoramento de imagem para melhorar a precisão do OCR em digitalizações de baixa qualidade:

using IronOcr;

var ocr = new IronTesseract();

using (var input = new OcrInput())
{
    // Add image with enhancement
    input.AddImage("poor-quality-scan.jpg");

    // Apply filters
    input.Deskew();
    input.DeNoise();
    input.Dilate();

    // Perform OCR
    var result = ocr.Read(input);
    Console.WriteLine(result.Text);
}

using IronOcr;

var ocr = new IronTesseract();

using (var input = new OcrInput())
{
    // Add image with enhancement
    input.AddImage("poor-quality-scan.jpg");

    // Apply filters
    input.Deskew();
    input.DeNoise();
    input.Dilate();

    // Perform OCR
    var result = ocr.Read(input);
    Console.WriteLine(result.Text);
}

A depuração inline de instruções if do Visual Studio 2026 ajuda os desenvolvedores a entender exatamente quais filtros de aprimoramento são aplicados e seu impacto nos resultados do OCR.

Instalando IronBarcode

IronBarcode fornece capacidades abrangentes de leitura e escrita de código de barras para aplicativos .NET:

Install-Package IronBarcode

Install-Package IronBarcode

Comece com o IronBarcode

Lendo Códigos de Barras de Imagens

using IronBarCode;

// Read barcode from image file
var results = BarcodeReader.Read("barcode-image.png");

foreach (var result in results)
{
    Console.WriteLine($"Barcode Type: {result.BarcodeType}");
    Console.WriteLine($"Value: {result.Value}");
}

using IronBarCode;

// Read barcode from image file
var results = BarcodeReader.Read("barcode-image.png");

foreach (var result in results)
{
    Console.WriteLine($"Barcode Type: {result.BarcodeType}");
    Console.WriteLine($"Value: {result.Value}");
}

Gerando Códigos de Barra

using IronBarCode;
using IronSoftware.Drawing;

// Generate a QR code
var qrCode = BarcodeWriter.CreateBarcode("https://ironsoftware.com", BarcodeEncoding.QRCode);

// Customize appearance
qrCode.SetMargins(10);
qrCode.AddBarcodeValueTextBelowBarcode();
qrCode.ChangeBarCodeColor(Color.Blue);

// Save as image
qrCode.SaveAsImage("qr-code.png");

// Or save as PDF
qrCode.SaveAsPdf("qr-code.pdf");

using IronBarCode;
using IronSoftware.Drawing;

// Generate a QR code
var qrCode = BarcodeWriter.CreateBarcode("https://ironsoftware.com", BarcodeEncoding.QRCode);

// Customize appearance
qrCode.SetMargins(10);
qrCode.AddBarcodeValueTextBelowBarcode();
qrCode.ChangeBarCodeColor(Color.Blue);

// Save as image
qrCode.SaveAsImage("qr-code.png");

// Or save as PDF
qrCode.SaveAsPdf("qr-code.pdf");

Leitura Avançada de Código de Barras com Detecção ML

O IronBarcode suporta detecção baseada em aprendizado de máquina para maior precisão:

using IronBarCode;

// Configure barcode reader with ML detection
var options = new BarcodeReaderOptions
{
    ExpectMultipleBarcodes = true,
    ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,
    CropArea = new System.Drawing.Rectangle(0, 0, 500, 500),
    UseCode39ExtendedMode = true
};

// Read barcodes with options
var results = BarcodeReader.Read("multi-barcode-image.png", options);

foreach (var barcode in results)
{
    Console.WriteLine($"Found: {barcode.BarcodeType} = {barcode.Value}");
}

using IronBarCode;

// Configure barcode reader with ML detection
var options = new BarcodeReaderOptions
{
    ExpectMultipleBarcodes = true,
    ExpectBarcodeTypes = BarcodeEncoding.AllOneDimensional,
    CropArea = new System.Drawing.Rectangle(0, 0, 500, 500),
    UseCode39ExtendedMode = true
};

// Read barcodes with options
var results = BarcodeReader.Read("multi-barcode-image.png", options);

foreach (var barcode in results)
{
    Console.WriteLine($"Found: {barcode.BarcodeType} = {barcode.Value}");
}

A ferramenta de alocação de rede no Visual Studio 2026 ajuda os desenvolvedores a otimizar o uso da memória ao processar grandes lotes de imagens de código de barras.

Primeiros passos com o IronXL

IronXL permite que os desenvolvedores leiam, gerem e editem arquivos Excel sem a necessidade do Microsoft Office ou do Excel Interop:

Comece com o IronXL

Criando Livros de Trabalho Excel

using IronXL;

// Create a new Excel workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.DefaultWorkSheet;

// Add data
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Price";

// Add rows of data
sheet["A2"].Value = "IronPDF License";
sheet["B2"].Value = 1;
sheet["C2"].Value = 599;

sheet["A3"].Value = "IronOCR License";
sheet["B3"].Value = 1;
sheet["C3"].Value = 499;

// Add formula
sheet["C4"].Formula = "=SUM(C2:C3)";

// Save the workbook
workbook.SaveAs("products.xlsx");

using IronXL;

// Create a new Excel workbook
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.DefaultWorkSheet;

// Add data
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Price";

// Add rows of data
sheet["A2"].Value = "IronPDF License";
sheet["B2"].Value = 1;
sheet["C2"].Value = 599;

sheet["A3"].Value = "IronOCR License";
sheet["B3"].Value = 1;
sheet["C3"].Value = 499;

// Add formula
sheet["C4"].Formula = "=SUM(C2:C3)";

// Save the workbook
workbook.SaveAs("products.xlsx");

Lendo Arquivos Excel Existentes

using IronXL;

// Load existing Excel file
WorkBook workbook = WorkBook.Load("sales-data.xlsx");
WorkSheet sheet = workbook.GetWorkSheet("Sales");

// Read cells
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.Write($"{cell.Value}\t");
    }
    Console.WriteLine();
}

// Access specific cell
var totalSales = sheet["D10"].DoubleValue;
Console.WriteLine($"Total Sales: ${totalSales:F2}");

using IronXL;

// Load existing Excel file
WorkBook workbook = WorkBook.Load("sales-data.xlsx");
WorkSheet sheet = workbook.GetWorkSheet("Sales");

// Read cells
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.Write($"{cell.Value}\t");
    }
    Console.WriteLine();
}

// Access specific cell
var totalSales = sheet["D10"].DoubleValue;
Console.WriteLine($"Total Sales: ${totalSales:F2}");

Trabalhando com Intervalos e Formatação no Excel

using IronXL;

WorkBook workbook = WorkBook.Load(@"C:\Users\kyess\Desktop\Desktop\Code-Projects\Assets\financial_report.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Select a range
var range = sheet["A1:D1"];

range.Style.Font.Bold = true;
range.Style.Font.Height = 12; 
range.Style.SetBackgroundColor("#0066CC");
range.Style.Font.SetColor("#FFFFFF");

for (int i = 0; i <= 3; i++)
{
    sheet.AutoSizeColumn(i);
}

// Save changes
workbook.SaveAs("formatted-report.xlsx");

using IronXL;

WorkBook workbook = WorkBook.Load(@"C:\Users\kyess\Desktop\Desktop\Code-Projects\Assets\financial_report.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Select a range
var range = sheet["A1:D1"];

range.Style.Font.Bold = true;
range.Style.Font.Height = 12; 
range.Style.SetBackgroundColor("#0066CC");
range.Style.Font.SetColor("#FFFFFF");

for (int i = 0; i <= 3; i++)
{
    sheet.AutoSizeColumn(i);
}

// Save changes
workbook.SaveAs("formatted-report.xlsx");

Aproveitando o GitHub Copilot com Bibliotecas da Iron Software

A integração profunda do GitHub Copilot no Visual Studio 2026 fornece sugestões inteligentes de código ao trabalhar com produtos da Iron Software. O Copilot pode:

• Gerar código completo de renderização no IronPDF a partir de descrições em linguagem natural

• Sugerir configurações ótimas de OCR com base na qualidade da imagem

• Recomendar tipos de código de barras e parâmetros de codificação

• Criar fórmulas Excel e lógica de manipulação de dados

Basta descrever o que você deseja realizar, e o Copilot gerará o código relevante usando as bibliotecas da Iron Software. O suporte ao editor de markdown também facilita a documentação do seu código com exemplos.

Depurando Aplicações da Iron Software

Os recursos de depuração aprimorados do Visual Studio 2026 melhoram significativamente a experiência de desenvolvimento ao trabalhar com processamento de documentos:

using IronPdf;
using System.Diagnostics;

public class PdfProcessor
{
    public void ProcessDocument(string htmlContent, string outputPath)
    {
        // Visual Studio 2026 shows inline values here
        var renderer = new ChromePdfRenderer();

        // Inline if-statement debugging shows evaluation results
        if (string.IsNullOrEmpty(htmlContent))
        {
            throw new ArgumentException("HTML content cannot be empty");
        }

        // Inline post-return values show the PDF object immediately
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Copilot can analyze unexpected results
        var pageCount = pdf.PageCount;
        Debug.WriteLine($"Generated PDF with {pageCount} pages");

        pdf.SaveAs(outputPath);
    }
}

using IronPdf;
using System.Diagnostics;

public class PdfProcessor
{
    public void ProcessDocument(string htmlContent, string outputPath)
    {
        // Visual Studio 2026 shows inline values here
        var renderer = new ChromePdfRenderer();

        // Inline if-statement debugging shows evaluation results
        if (string.IsNullOrEmpty(htmlContent))
        {
            throw new ArgumentException("HTML content cannot be empty");
        }

        // Inline post-return values show the PDF object immediately
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Copilot can analyze unexpected results
        var pageCount = pdf.PageCount;
        Debug.WriteLine($"Generated PDF with {pageCount} pages");

        pdf.SaveAs(outputPath);
    }
}

Os recursos de depuração inline, combinados com a análise do Copilot, facilitam o entendimento dos fluxos de trabalho de processamento de documentos e a rápida identificação de problemas.

Perfil de Desempenho com a Iron Software

O agente do copilot de perfil no Visual Studio 2026 pode analisar o desempenho ao trabalhar com bibliotecas da Iron Software:

using IronPdf;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class PdfBenchmarks
{
    private const string SampleHtml = "<html><body><h1>Test Document</h1></body></html>";

    [Benchmark]
    public void RenderSimplePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(SampleHtml);
    }

    [Benchmark]
    public void RenderComplexPdf()
    {
        var renderer = new ChromePdfRenderer();
        var complexHtml = GenerateComplexHtml();
        var pdf = renderer.RenderHtmlAsPdf(complexHtml);
    }

    private string GenerateComplexHtml()
    {
        // Generate HTML with tables, images, etc.
        return "<html><body><table>...</table></body></html>";
    }
}

partial class Program
{
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<PdfBenchmarks>();
    }
}

using IronPdf;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class PdfBenchmarks
{
    private const string SampleHtml = "<html><body><h1>Test Document</h1></body></html>";

    [Benchmark]
    public void RenderSimplePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(SampleHtml);
    }

    [Benchmark]
    public void RenderComplexPdf()
    {
        var renderer = new ChromePdfRenderer();
        var complexHtml = GenerateComplexHtml();
        var pdf = renderer.RenderHtmlAsPdf(complexHtml);
    }

    private string GenerateComplexHtml()
    {
        // Generate HTML with tables, images, etc.
        return "<html><body><table>...</table></body></html>";
    }
}

partial class Program
{
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<PdfBenchmarks>();
    }
}

Use o modelo de projeto benchmarkdotnet no Visual Studio 2026 para criar testes de desempenho, e utilize o profiler para identificar oportunidades de otimização.

Integração com Serviços na Nuvem

Os produtos da Iron Software funcionam perfeitamente com serviços na nuvem implantados a partir do Visual Studio 2026:

using Microsoft.Azure.Functions;
using IronPdf;
using IronOcr;

public class DocumentProcessor
{
    [FunctionName("ConvertHtmlToPdf")]
    public async Task<IActionResult> ConvertToPdf(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        string html = await new StreamReader(req.Body).ReadToEndAsync();

        // Configure IronPDF for Azure
        License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);

        return new FileContentResult(pdf.BinaryData, "application/pdf")
        {
            FileDownloadName = "document.pdf"
        };
    }

    [FunctionName("ExtractTextFromImage")]
    public async Task<IActionResult> ExtractText(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        var imageBytes = await ReadImageBytes(req);

        License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

        var ocr = new IronTesseract();
        using (var input = new OcrInput())
        {
            input.AddImage(imageBytes);
            var result = ocr.Read(input);

            return new OkObjectResult(new { text = result.Text });
        }
    }
}

using Microsoft.Azure.Functions;
using IronPdf;
using IronOcr;

public class DocumentProcessor
{
    [FunctionName("ConvertHtmlToPdf")]
    public async Task<IActionResult> ConvertToPdf(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        string html = await new StreamReader(req.Body).ReadToEndAsync();

        // Configure IronPDF for Azure
        License.LicenseKey = Environment.GetEnvironmentVariable("IRONPDF_LICENSE");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);

        return new FileContentResult(pdf.BinaryData, "application/pdf")
        {
            FileDownloadName = "document.pdf"
        };
    }

    [FunctionName("ExtractTextFromImage")]
    public async Task<IActionResult> ExtractText(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
    {
        var imageBytes = await ReadImageBytes(req);

        License.LicenseKey = Environment.GetEnvironmentVariable("IRONOCR_LICENSE");

        var ocr = new IronTesseract();
        using (var input = new OcrInput())
        {
            input.AddImage(imageBytes);
            var result = ocr.Read(input);

            return new OkObjectResult(new { text = result.Text });
        }
    }
}

O suporte estendido para serviços na nuvem no Visual Studio 2026 facilita a implantação de aplicações potenciadas por Iron Software no Azure.

Teste de Unidade com Cobertura de Código

Os recursos de cobertura de código do Visual Studio 2026 nas edições community e professional permitem uma testagem completa das integrações da Iron Software:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using IronPdf;
using System.IO;

[TestClass]
public class PdfGenerationTests
{
    [TestMethod]
    public void TestSimpleHtmlToPdf()
    {
        // Arrange
        var renderer = new ChromePdfRenderer();
        var html = "<h1>Test</h1>";

        // Act
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Assert
        Assert.IsNotNull(pdf);
        Assert.IsTrue(pdf.PageCount > 0);
        Assert.IsTrue(pdf.BinaryData.Length > 0);
    }

    [TestMethod]
    public void TestPdfExtraction()
    {
        // Arrange
        var html = "<html><body><p>Sample text for extraction</p></body></html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Act
        var extractedText = pdf.ExtractAllText();

        // Assert
        Assert.IsTrue(extractedText.Contains("Sample text"));
    }

    [TestMethod]
    [DataRow("document1.html")]
    [DataRow("document2.html")]
    [DataRow("document3.html")]
    public void TestBatchPdfGeneration(string filename)
    {
        // Arrange
        var html = File.ReadAllText(filename);
        var renderer = new ChromePdfRenderer();

        // Act
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Assert
        Assert.IsNotNull(pdf);
        Assert.IsTrue(pdf.PageCount > 0);
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using IronPdf;
using System.IO;

[TestClass]
public class PdfGenerationTests
{
    [TestMethod]
    public void TestSimpleHtmlToPdf()
    {
        // Arrange
        var renderer = new ChromePdfRenderer();
        var html = "<h1>Test</h1>";

        // Act
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Assert
        Assert.IsNotNull(pdf);
        Assert.IsTrue(pdf.PageCount > 0);
        Assert.IsTrue(pdf.BinaryData.Length > 0);
    }

    [TestMethod]
    public void TestPdfExtraction()
    {
        // Arrange
        var html = "<html><body><p>Sample text for extraction</p></body></html>";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Act
        var extractedText = pdf.ExtractAllText();

        // Assert
        Assert.IsTrue(extractedText.Contains("Sample text"));
    }

    [TestMethod]
    [DataRow("document1.html")]
    [DataRow("document2.html")]
    [DataRow("document3.html")]
    public void TestBatchPdfGeneration(string filename)
    {
        // Arrange
        var html = File.ReadAllText(filename);
        var renderer = new ChromePdfRenderer();

        // Act
        var pdf = renderer.RenderHtmlAsPdf(html);

        // Assert
        Assert.IsNotNull(pdf);
        Assert.IsTrue(pdf.PageCount > 0);
    }
}

Execute estes testes usando o explorador de testes e analise os resultados com a janela de resultados de cobertura de código para garantir uma cobertura de teste abrangente da sua lógica de processamento de documentos.

Teste de Integração

Para testes de integração envolvendo vários produtos da Iron Software:

using Microsoft.VisualStudio.TestTools.UnitTesting;
using IronPdf;
using IronOcr;
using IronBarCode;

[TestClass]
public class DocumentWorkflowTests
{
    [TestMethod]
    public void TestCompleteDocumentWorkflow()
    {
        // Step 1: Generate PDF with barcode
        var renderer = new ChromePdfRenderer();
        var barcode = BarcodeWriter.CreateBarcode("DOC-12345", BarcodeEncoding.QRCode);

        var html = $@"
            <html>
            <body>
                <h1>Document #DOC-12345</h1>
                <img src='{barcode.ToDataUrl()}' />
                <p>This is a test document with a QR code.</p>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("test-document.pdf");

        // Step 2: Convert PDF to image
        pdf.RasterizeToImageFiles("test-page-*.png");

        // Step 3: Read barcode from image
        var barcodeResults = BarcodeReader.Read("test-page-1.png");

        // Step 4: Verify barcode content
        Assert.IsTrue(barcodeResults.Any());
        Assert.AreEqual("DOC-12345", barcodeResults.First().Value);

        // Step 5: OCR the document
        var ocr = new IronTesseract();
        using (var input = new OcrInput())
        {
            input.AddImage("test-page-1.png");
            var ocrResult = ocr.Read(input);

            Assert.IsTrue(ocrResult.Text.Contains("Document"));
        }
    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;
using IronPdf;
using IronOcr;
using IronBarCode;

[TestClass]
public class DocumentWorkflowTests
{
    [TestMethod]
    public void TestCompleteDocumentWorkflow()
    {
        // Step 1: Generate PDF with barcode
        var renderer = new ChromePdfRenderer();
        var barcode = BarcodeWriter.CreateBarcode("DOC-12345", BarcodeEncoding.QRCode);

        var html = $@"
            <html>
            <body>
                <h1>Document #DOC-12345</h1>
                <img src='{barcode.ToDataUrl()}' />
                <p>This is a test document with a QR code.</p>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("test-document.pdf");

        // Step 2: Convert PDF to image
        pdf.RasterizeToImageFiles("test-page-*.png");

        // Step 3: Read barcode from image
        var barcodeResults = BarcodeReader.Read("test-page-1.png");

        // Step 4: Verify barcode content
        Assert.IsTrue(barcodeResults.Any());
        Assert.AreEqual("DOC-12345", barcodeResults.First().Value);

        // Step 5: OCR the document
        var ocr = new IronTesseract();
        using (var input = new OcrInput())
        {
            input.AddImage("test-page-1.png");
            var ocrResult = ocr.Read(input);

            Assert.IsTrue(ocrResult.Text.Contains("Document"));
        }
    }
}

O recurso de argumentos personalizados no Visual Studio 2026 permite que você passe diferentes configurações de teste ao executar testes de integração.

Modelos de Projeto e Estrutura

Ao iniciar um novo projeto no Visual Studio 2026 que utiliza produtos da Iron Software:

1. Crie um projeto usando o modelo de projeto .NET 10 apropriado

   

2. Instale os pacotes NuGet necessários da Iron Software

   

3. Configure as chaves de licença nas configurações do aplicativo

4. Configure a injeção de dependência para os serviços da Iron Software

5. Implemente o tratamento adequado de erros e registros

using Microsoft.Extensions.DependencyInjection;
using IronPdf;
using IronOcr;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Configure IronPDF
        services.AddSingleton<ChromePdfRenderer>();

        // Configure IronOCR
        services.AddSingleton<IronTesseract>();

        // Add other services
        services.AddLogging();
    }
}

using Microsoft.Extensions.DependencyInjection;
using IronPdf;
using IronOcr;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Configure IronPDF
        services.AddSingleton<ChromePdfRenderer>();

        // Configure IronOCR
        services.AddSingleton<IronTesseract>();

        // Add other services
        services.AddLogging();
    }
}

Excluir Arquivos da Pesquisa

Use o recurso de exclusão de arquivos do Visual Studio 2026 para evitar a busca em PDFs gerados ou arquivos de documentos grandes:

1. Vá para Ferramentas → Opções → Ambiente → Pesquisa

2. Adicione padrões como .pdf, .xlsx, ou output/*/ para excluir esses arquivos dos resultados de pesquisa

3. Isso melhora o desempenho da pesquisa e reduz o ruído ao procurar código

Fluxos de Trabalho de Integração Contínua

Aproveite os fluxos de trabalho de integração contínua aprimorados do Visual Studio 2026 ao implantar aplicativos da Iron Software:

name: Build and Test

on: [push, pull_request]

jobs:
  build:
    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v2

    - name: Setup .NET 10
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: '10.0.x'

    - name: Restore dependencies
      run: dotnet restore

    - name: Build
      run: dotnet build --configuration Release

    - name: Run unit tests
      run: dotnet test --configuration Release --logger trunit

    - name: Run code coverage
      run: dotnet test --collect:"XPlat Code Coverage"

name: Build and Test

on: [push, pull_request]

jobs:
  build:
    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v2

    - name: Setup .NET 10
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: '10.0.x'

    - name: Restore dependencies
      run: dotnet restore

    - name: Build
      run: dotnet build --configuration Release

    - name: Run unit tests
      run: dotnet test --configuration Release --logger trunit

    - name: Run code coverage
      run: dotnet test --collect:"XPlat Code Coverage"

O suporte nativo para GitHub Actions no Visual Studio 2026 torna a configuração de pipelines CI/CD para projetos da Iron Software simples.

Gerenciamento de memória

Ao trabalhar com documentos grandes, considere estas estratégias de otimização:

using IronPdf;
using System;

public class OptimizedPdfProcessor
{
    public void ProcessLargeDocument(string htmlPath)
    {
        // Use using statements for proper disposal
        using var renderer = new ChromePdfRenderer();

        // Configure for memory efficiency
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        // Process in chunks if possible
        var html = File.ReadAllText(htmlPath);
        using var pdf = renderer.RenderHtmlAsPdf(html);

        // Save immediately to free memory
        pdf.SaveAs("output.pdf");

        // PDF is disposed automatically
    }
}

using IronPdf;
using System;

public class OptimizedPdfProcessor
{
    public void ProcessLargeDocument(string htmlPath)
    {
        // Use using statements for proper disposal
        using var renderer = new ChromePdfRenderer();

        // Configure for memory efficiency
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        // Process in chunks if possible
        var html = File.ReadAllText(htmlPath);
        using var pdf = renderer.RenderHtmlAsPdf(html);

        // Save immediately to free memory
        pdf.SaveAs("output.pdf");

        // PDF is disposed automatically
    }
}

A ferramenta de alocação líquida no Visual Studio 2026 pode identificar ineficiências de memória no seu código de processamento de documentos.

Processamento em lote

Para o processamento de vários documentos, implemente o processamento em lote com o gerenciamento adequado de recursos:

using IronPdf;
using System.Collections.Concurrent;
using System.Threading.Tasks;

public class BatchProcessor
{
    public async Task ProcessDocumentsBatch(IEnumerable<string> filePaths)
    {
        var options = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount
        };

        await Parallel.ForEachAsync(filePaths, options, async (path, ct) =>
        {
            using var renderer = new ChromePdfRenderer();
            var html = await File.ReadAllTextAsync(path, ct);
            var pdf = renderer.RenderHtmlAsPdf(html);

            var outputPath = Path.ChangeExtension(path, ".pdf");
            pdf.SaveAs(outputPath);
        });
    }
}

using IronPdf;
using System.Collections.Concurrent;
using System.Threading.Tasks;

public class BatchProcessor
{
    public async Task ProcessDocumentsBatch(IEnumerable<string> filePaths)
    {
        var options = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount
        };

        await Parallel.ForEachAsync(filePaths, options, async (path, ct) =>
        {
            using var renderer = new ChromePdfRenderer();
            var html = await File.ReadAllTextAsync(path, ct);
            var pdf = renderer.RenderHtmlAsPdf(html);

            var outputPath = Path.ChangeExtension(path, ".pdf");
            pdf.SaveAs(outputPath);
        });
    }
}