Productos de Iron Software y Visual Studio 2026: una guía completa de integración

Experiencia IDE mejorada con el sistema de diseño de interfaz de usuario fluido

Visual Studio 2026 presenta una experiencia de usuario completamente rediseñada con una interfaz renovada y alineada con el sistema de diseño Fluent UI de Microsoft. Las nuevas características incluyen controles de editor mejorados, claridad visual mejorada y un mayor control sobre el tema general del IDE. Los desarrolladores ahora pueden elegir entre 11 nuevos temas tintados, lo que permite una mayor personalización del entorno de codificación para que coincida con las preferencias personales y reduzca la fatiga visual durante sesiones de desarrollo prolongadas.

La experiencia de configuración moderna reemplaza el cuadro de diálogo tradicional Herramientas > Opciones con una interfaz optimizada y fácil de usar. Esta experiencia de usuario rediseñada facilita que los desarrolladores web configuren rápidamente su entorno de desarrollo, ya sea que estén trabajando en aplicaciones web, herramientas de interfaz de línea de comandos o proyectos de edición empresarial.

Como señaló Elanchezhiyan P en Medium , el IDE presenta un "rediseño de interfaz de usuario fluido con diseños e íconos más limpios", lo que hace que la experiencia de desarrollo sea más intuitiva y visualmente atractiva.

Integración de GitHub Copilot y desarrollo impulsado por IA

¡ Chat de copiloto de GitHub !

Uno de los avances más significativos de Visual Studio 2026 es la profunda integración de Copilot en el IDE. El agente de Copilot del generador de perfiles puede analizar el uso de la CPU, las asignaciones de memoria y el comportamiento en tiempo de ejecución, lo que proporciona mejores respuestas e información de Copilot para ayudar a los desarrolladores a optimizar su código. La asistencia del copiloto se extiende a varios aspectos del desarrollo, incluido el explorador de pruebas, donde los desarrolladores pueden aprovechar la IA para generar y corregir pruebas unitarias automáticamente.

El nuevo menú contextual proporciona acceso rápido a las acciones de Copilot, y la funcionalidad de pegado adaptable ajusta automáticamente el código pegado para adaptarse al contexto de su proyecto. Estas características representan un cambio fundamental hacia el desarrollo impulsado por IA, donde las sugerencias inteligentes ayudan a los desarrolladores a codificar más rápido sin sacrificar la calidad del código.

Mejoras de rendimiento y herramientas de compilación

Visual Studio 2026 ofrece un rendimiento sustancialmente mejorado en todos los ámbitos. Las soluciones con cientos de proyectos existentes ahora se cargan un 40 % más rápido que en Visual Studio 2022. El depurador muestra tiempos de inicio hasta un 30 % más rápidos al usar F5, y las reconstrucciones completas se sienten más cercanas a las compilaciones incrementales gracias a las optimizaciones tanto en el IDE como en el tiempo de ejecución de .NET 10.

Las herramientas de compilación se han desacoplado del propio IDE, lo que significa que los desarrolladores pueden actualizar Visual Studio con actualizaciones mensuales automáticas sin afectar a sus compiladores .NET o C++. Esta separación garantiza que los flujos de trabajo de integración continua permanezcan estables mientras los desarrolladores se benefician de las últimas características y correcciones de errores en el IDE.

Mejoras en la cobertura del código y las pruebas

Un avance importante en Visual Studio 2026 es la disponibilidad de la cobertura de código en las ediciones Community y Professional de Visual Studio por primera vez. Anteriormente restringida a la edición Enterprise, los desarrolladores ahora pueden analizar la ventana de resultados de la cobertura de código para comprender qué partes de su código se utilizan en las pruebas unitarias. Esta democratización de las herramientas de prueba ayuda a más desarrolladores a garantizar que sus aplicaciones estén bien probadas antes de su implementación.

La opción de analizar cobertura de código permite a los desarrolladores ejecutar la cobertura de código para pruebas seleccionadas directamente desde el menú de pruebas, y los resultados se muestran en la ventana de cobertura de código con porcentajes para cada ensamblaje, clase y método. Visual Studio resalta las líneas probadas directamente en el editor de código, lo que facilita la detección de brechas en la cobertura de la prueba.

Introducción a IronPDF

IronPDF es una completa biblioteca de PDF de C# que permite a los desarrolladores crear, editar y extraer contenido PDF en proyectos .NET . Con el soporte de Visual Studio 2026 para .NET 10 y capacidades de depuración mejoradas, trabajar con IronPDF se vuelve aún más eficiente.

Para instalar IronPDF en su proyecto de Visual Studio 2026, abra la Consola del Administrador de paquetes NuGet y ejecute:

Install-Package IronPdf

Install-Package IronPdf

O usa la CLI de .NET:

dotnet add package IronPdf

dotnet add package IronPdf

Obtenga más información sobre la instalación de IronPDF

Conversión de HTML a 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");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Trabajar con archivos PDF 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");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Formularios PDF y firmas digitales

IronPDF admite el trabajo con formularios PDF y firmas digitales , algo esencial para las aplicaciones de edición empresarial que requieren autenticación 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");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Las características de cobertura de código en Visual Studio 2026 ayudan a garantizar que la lógica de llenado y firma de formularios se pruebe correctamente en diferentes escenarios.

Configuración de IronOCR

IronOCR permite a los desarrolladores realizar operaciones de OCR en aplicaciones .NET y admite más de 125 idiomas. Instalar IronOCR en Visual Studio 2026 es sencillo:

Install-Package IronOcr

Install-Package IronOcr

Operaciones 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}%");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Compatibilidad con OCR en varios idiomas

La compatibilidad de IronOCR con varios idiomas funciona perfectamente con la compatibilidad de idiomas mejorada de 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}");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

OCR con mejora de imagen

IronOCR incluye capacidades de mejora de imágenes para mejorar la precisión del OCR en escaneos de baja calidad:

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);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La depuración de instrucciones if en línea de Visual Studio 2026 ayuda a los desarrolladores a comprender exactamente qué filtros de mejora se aplican y su impacto en los resultados de OCR.

Instalación de IronBarcode

IronBarcode ofrece capacidades integrales de lectura y escritura de códigos de barras para aplicaciones .NET:

Install-Package IronBarcode

Install-Package IronBarcode

Comience a usar IronBarcode

Lectura de códigos de barras a partir de imágenes

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}");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Generación de códigos de barras

using IronBarCode;
using Iron Software.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 Iron Software.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");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Lectura avanzada de códigos de barras con detección ML

IronBarcode admite la detección basada en aprendizaje automático para una mayor precisión:

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}");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La herramienta de asignación de red en Visual Studio 2026 ayuda a los desarrolladores a optimizar el uso de memoria al procesar grandes lotes de imágenes de códigos de barras.

Introducción a IronXL

IronXL permite a los desarrolladores leer, generar y editar archivos de Excel sin necesidad de Microsoft Office o Excel Interop:

Install-Package IronXL.Excel

Install-Package IronXL.Excel

Comience a utilizar IronXL

Creación de libros de trabajo de 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");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Lectura de archivos de 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}");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Trabajar con rangos y formato de 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");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cómo aprovechar GitHub Copilot con las bibliotecas de Iron Software

¡ Generando código funcional con Copilot !

La profunda integración de GitHub Copilot en Visual Studio 2026 proporciona sugerencias de código inteligentes cuando se trabaja con productos de Iron Software. Copilot puede:

• Generar código de representación IronPDF completo a partir de descripciones en lenguaje natural

• Sugerir configuraciones de OCR óptimas según la calidad de la imagen

• Recomendar tipos de códigos de barras y parámetros de codificación

• Crear fórmulas de Excel y lógica de manipulación de datos.

Simplemente describa lo que desea lograr y Copilot generará el código pertinente utilizando las bibliotecas de Iron Software. La compatibilidad con el editor de rebajas también facilita la documentación de su código con ejemplos.

Depuración de aplicaciones de Iron Software

Las funciones de depuración mejoradas de Visual Studio 2026 mejoran significativamente la experiencia de desarrollo al trabajar con el procesamiento 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);
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Las funciones de depuración en línea, combinadas con el análisis de Copilot, facilitan la comprensión de los flujos de trabajo de procesamiento de documentos y la identificación rápida de problemas.

Performance Profiling con Iron Software

El agente copiloto del perfilador en Visual Studio 2026 puede analizar el rendimiento cuando se trabaja con bibliotecas de 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>();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Utilice la plantilla de proyecto benchmarkdotnet en Visual Studio 2026 para crear pruebas de rendimiento y aproveche el generador de perfiles para identificar oportunidades de optimización.

Integración de servicios en la nube

Los productos de Iron Software funcionan a la perfección con los servicios en la nube implementados desde 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 });
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La compatibilidad ampliada con los servicios en la nube de Visual Studio 2026 facilita la implementación de aplicaciones de Iron Software en Azure.

Pruebas unitarias con cobertura de código

Las funciones de cobertura de código de Visual Studio 2026 en las ediciones Community y Professional permiten realizar pruebas exhaustivas de las integraciones de 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);
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ejecute estas pruebas utilizando el explorador de pruebas y analice los resultados con la ventana de resultados de cobertura de código para garantizar una cobertura de prueba integral de su lógica de procesamiento de documentos.

Pruebas de integración

Para pruebas de integración en las que participen varios productos de 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"));
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La función de argumentos personalizados en Visual Studio 2026 le permite pasar diferentes configuraciones de prueba al ejecutar pruebas de integración.

Plantillas y estructura del proyecto

Al iniciar un nuevo proyecto en Visual Studio 2026 que utilice productos de Iron Software:

1. Cree un proyecto utilizando la plantilla de proyecto .NET 10 adecuada

   ¡ Crea un proyecto en Visual Studio !

2. Instalación de los paquetes NuGet de Iron Software necesarios

   Instalación de paquetes NuGet de Iron Software

3. Configure las claves de licencia en la configuración de la aplicación

4. Configuración de la inyección de dependencias para los servicios de Iron Software

5. Implementar un manejo y registro de errores adecuados

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();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Excluir archivos de la búsqueda

! Excluyendo archivos

Utilice la función de exclusión de archivos de Visual Studio 2026 para evitar la búsqueda en archivos PDF generados o archivos de documentos grandes:

1. Vaya a Herramientas → Opciones → Entorno → Buscar

2. Agregue patrones como .pdf, .xlsx o output/\ * /\ para excluir estos archivos de los resultados de búsqueda.

3. Esto mejora el rendimiento de la búsqueda y reduce el ruido al buscar código.

Flujos de trabajo de integración continua

Aproveche los flujos de trabajo de integración continua mejorados de Visual Studio 2026 al implementar aplicaciones de 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"

La compatibilidad nativa con las acciones de GitHub en Visual Studio 2026 facilita la creación de canalizaciones CI/CD para proyectos de Iron Software.

Gestión de la memoria

Al trabajar con documentos grandes, tenga en cuenta estas estrategias de optimización:

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
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La herramienta de asignación de red en Visual Studio 2026 puede identificar ineficiencias de memoria en el código de procesamiento de documentos.

Procesamiento por lotes

Para procesar múltiples documentos, implemente el procesamiento por lotes con una gestión adecuada de los 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);
        });
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com