Iron Software Products et Visual Studio 2026 : un guide d'intégration complet

Expérience IDE améliorée grâce au système de conception d'interface utilisateur Fluent

Visual Studio 2026 introduit une expérience utilisateur entièrement repensée avec une interface modernisée, alignée sur le système de conception d'interface utilisateur Fluent de Microsoft. Les nouvelles fonctionnalités comprennent des commandes d'édition améliorées, une meilleure clarté visuelle et un contrôle accru sur le thème général de l'IDE. Les développeurs peuvent désormais choisir parmi 11 nouveaux thèmes teintés, ce qui permet une plus grande personnalisation de l'environnement de codage afin de correspondre aux préférences personnelles et de réduire la fatigue oculaire lors des sessions de développement prolongées.

L'interface moderne des paramètres remplace la boîte de dialogue traditionnelle Outils > Options par une interface simplifiée et conviviale. Cette interface utilisateur repensée permet aux développeurs .NET de configurer plus facilement et rapidement leur environnement de développement, qu'ils travaillent sur des applications web, des outils d'interface en ligne de commande ou des projets d'entreprise.

Comme l'a noté Elanchezhiyan P sur Medium , l'IDE propose une " refonte de l'interface utilisateur Fluent avec des mises en page et des icônes plus épurées ", rendant l'expérience de développement plus intuitive et visuellement attrayante.

Intégration de GitHub Copilot et développement piloté par l'IA

! Chat GitHub Copilot

L'une des avancées majeures de Visual Studio 2026 réside dans l'intégration poussée de Copilot au sein de l'IDE. L'agent Copilot du profileur analyse l'utilisation du processeur, les allocations de mémoire et le comportement d'exécution, fournissant ainsi des réponses et des informations plus pertinentes pour aider les développeurs à optimiser leur code. L'assistance du copilote s'étend à divers aspects du développement, notamment à l'explorateur de tests, où les développeurs peuvent tirer parti de l'IA pour générer et corriger automatiquement les tests unitaires.

Le nouveau menu contextuel offre un accès rapide aux actions de Copilot, et la fonctionnalité de collage adaptatif ajuste automatiquement le code collé au contexte de votre projet. Ces fonctionnalités représentent un changement fondamental vers un développement piloté par l'IA, où des suggestions intelligentes aident les développeurs à coder plus rapidement sans sacrifier la qualité du code.

Améliorations des performances et outils de construction

Visual Studio 2026 offre des performances nettement améliorées sur tous les plans. Les solutions comportant des centaines de projets existants se chargent désormais 40 % plus rapidement qu'avec Visual Studio 2022. Le débogueur affiche des temps de démarrage jusqu'à 30 % plus rapides avec la touche F5, et les reconstructions complètes sont plus proches des compilations incrémentales grâce aux optimisations apportées à l'IDE et à l'environnement d'exécution .NET 10.

Les outils de génération ont été dissociés de l'IDE lui-même, ce qui signifie que les développeurs peuvent mettre à jour Visual Studio grâce à des mises à jour mensuelles automatiques sans affecter leurs compilateurs .NET ou C++. Cette séparation garantit la stabilité des flux de travail d'intégration continue, tandis que les développeurs bénéficient des dernières fonctionnalités et corrections de bogues dans l'IDE.

Améliorations de la couverture de code et des tests

Une avancée majeure de Visual Studio 2026 est la disponibilité, pour la première fois, de la couverture de code dans les éditions Community et Professional. Auparavant réservée à l'édition Enterprise, cette fonctionnalité est désormais accessible aux développeurs qui peuvent analyser les résultats de la couverture de code afin de déterminer quelles parties de leur code sont testées par les tests unitaires. Cette démocratisation des outils de test aide davantage de développeurs à s'assurer que leurs applications sont bien testées avant leur déploiement.

L'option " Analyser la couverture de code " permet aux développeurs d'exécuter l'analyse de la couverture de code pour les tests sélectionnés directement depuis le menu de test, les résultats étant affichés dans la fenêtre de couverture de code avec des pourcentages pour chaque assembly, classe et méthode. Visual Studio met en évidence les lignes testées directement dans l'éditeur de code, ce qui facilite le repérage des lacunes dans la couverture des tests.

Commencer avec IronPDF

IronPDF est une bibliothèque PDF C# complète qui permet aux développeurs de créer, modifier et extraire du contenu PDF dans des projets .NET . Grâce à la prise en charge de .NET 10 et aux capacités de débogage améliorées de Visual Studio 2026, travailler avec IronPDF devient encore plus efficace.

Pour installer IronPDF dans votre projet Visual Studio 2026, ouvrez la console du gestionnaire de packages NuGet et exécutez :

Install-Package IronPdf

Install-Package IronPdf

Ou utilisez le .NET CLI :

dotnet add package IronPdf

dotnet add package IronPdf

Apprenez-en davantage sur l'installation d'IronPDF

Conversion HTML en 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

Utilisation des fichiers PDF existants

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

Formulaires PDF et signatures numériques

IronPDF prend en charge la gestion des formulaires PDF et des signatures numériques , éléments essentiels pour les applications d'entreprise nécessitant l'authentification des documents :

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

Les fonctionnalités de couverture de code de Visual Studio 2026 permettent de garantir que la logique de remplissage et de signature des formulaires est correctement testée dans différents scénarios.

Configuration d'IronOCR

IronOCR permet aux développeurs d'effectuer des opérations OCR dans les applications .NET, prenant en charge plus de 125 langues. L'installation d'IronOCR dans Visual Studio 2026 est simple :

Install-Package IronOcr

Install-Package IronOcr

Opérations OCR de base

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

Assistance OCR multilingue

La prise en charge multilingue d'IronOCR fonctionne parfaitement avec la prise en charge linguistique améliorée 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 avec amélioration d'image

IronOCR intègre des fonctionnalités d'amélioration d'image pour optimiser la précision de la reconnaissance optique de caractères (OCR) sur les numérisations de faible qualité :

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

Le débogage des instructions if en ligne de Visual Studio 2026 aide les développeurs à comprendre exactement quels filtres d'amélioration sont appliqués et leur impact sur les résultats de l'OCR.

Installation d'IronBarcode

IronBarcode offre des fonctionnalités complètes de lecture et d'écriture de codes-barres pour les applications .NET :

Install-Package IronBarcode

Install-Package IronBarcode

Commencez avec IronBarcode

Lecture des codes-barres à partir d'images

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

Générer des codes-barres

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

Lecture avancée de codes-barres avec détection par apprentissage automatique

IronBarcode prend en charge la détection basée sur l'apprentissage automatique pour une précision accrue :

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

L'outil d'allocation réseau de Visual Studio 2026 aide les développeurs à optimiser l'utilisation de la mémoire lors du traitement de grands lots d'images de codes-barres.

Premiers pas avec IronXL

IronXL permet aux développeurs de lire, de générer et de modifier des fichiers Excel sans nécessiter Microsoft Office ni Excel Interop :

Install-Package IronXL.Excel

Install-Package IronXL.Excel

Commencez avec IronXL

Création de classeurs 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

Lecture de fichiers Excel existants

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

Utilisation des plages et de la mise en forme dans 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

Leveraging GitHub Copilot with Iron Software Libraries (en anglais)

Générer du code fonctionnel avec Copilot

L'intégration approfondie de GitHub Copilot dans Visual Studio 2026 fournit des suggestions de code intelligentes lorsque vous travaillez avec des produits Iron Software. Le copilote peut :

• Générer le code de rendu IronPDF complet à partir de descriptions en langage naturel

• Suggérer les paramètres OCR optimaux en fonction de la qualité de l'image

• Recommander les types de codes-barres et les paramètres d'encodage

• Créer des formules Excel et une logique de manipulation des données

Décrivez simplement ce que vous souhaitez accomplir, et Copilot générera un code pertinent à l'aide des bibliothèques d'Iron Software. La prise en charge de l'éditeur Markdown facilite également la documentation de votre code avec des exemples.

Débogage des applications logicielles Iron Software

Les fonctionnalités de débogage améliorées de Visual Studio 2026 améliorent considérablement l'expérience de développement lors du traitement de documents :

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

Les fonctionnalités de débogage en ligne, associées à l'analyse Copilot, facilitent la compréhension des flux de traitement des documents et permettent d'identifier rapidement les problèmes.

Profilage des performances avec Iron Software

L'agent copilote profiler de Visual Studio 2026 permet d'analyser les performances lorsqu'on travaille avec les bibliothèques d'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

Utilisez le modèle de projet benchmarkdotnet dans Visual Studio 2026 pour créer des tests de performance et exploitez le profileur pour identifier les opportunités d'optimisation.

Intégration des services cloud

Les produits Iron Software fonctionnent de manière transparente avec les services cloud déployés à partir de 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 prise en charge étendue des services cloud dans Visual Studio 2026 facilite le déploiement d'applications alimentées par Iron Software sur Azure.

Tests unitaires avec couverture de code

Les fonctionnalités de couverture de code de Visual Studio 2026 dans les éditions communautaire et professionnelle permettent de tester en profondeur les intégrations d'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

Exécutez ces tests à l'aide de l'explorateur de tests et analysez les résultats avec la fenêtre des résultats de couverture de code afin de garantir une couverture de test complète de votre logique de traitement de documents.

Tests d'intégration

Pour les tests d'intégration impliquant plusieurs produits 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 fonctionnalité des arguments personnalisés dans Visual Studio 2026 vous permet de transmettre différentes configurations de test lors de l'exécution de tests d'intégration.

Modèles et structure de projet

Lors du démarrage d'un nouveau projet dans Visual Studio 2026 qui utilise les produits Iron Software :

1. Créez un projet en utilisant le modèle de projet .NET 10 approprié.

   Créez un projet dans Visual Studio .

2. Installer les paquets NuGet d'Iron Software requis

   

3. Configurez les clés de licence dans les paramètres de l'application

4. Configurer l'injection de dépendances pour les services Iron Software

5. Mettre en œuvre une gestion et une journalisation appropriées des erreurs

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

Exclure les fichiers de la recherche

! Exclure les fichiers

Utilisez la fonctionnalité d'exclusion de fichiers de Visual Studio 2026 pour empêcher la recherche dans les fichiers PDF générés ou les fichiers de documents volumineux :

1. Allez dans Outils → Options → Environnement → Recherche

2. Ajoutez des modèles comme .pdf, .xlsx ou output/\ * /\ pour exclure ces fichiers des résultats de recherche

3. Cela améliore les performances de recherche et réduit le bruit lors de la recherche de code.

Flux de travail d'intégration continue

Tirez parti des flux d'intégration continue améliorés de Visual Studio 2026 lors du déploiement des applications 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 prise en charge native des actions GitHub dans Visual Studio 2026 simplifie la mise en place de pipelines CI/CD pour les projets Iron Software.

Gestion de la mémoire

Lorsque vous travaillez avec des documents volumineux, tenez compte des stratégies d'optimisation suivantes :

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

L'outil d'allocation réseau de Visual Studio 2026 peut identifier les inefficacités de mémoire dans votre code de traitement de documents.

Traitement par lots

Pour le traitement de plusieurs documents, mettez en œuvre un traitement par lots avec une gestion appropriée des ressources :

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