Wie Excel Charts und Sheets in PNG Bilder umwandeln

Wie Excel Charts und Sheets in PNG Bilder umwandeln

Dieser Artikel zeigt, wie man Excel-Diagramme und Arbeitsblätter in PNG-Bilder mit dem Aspose.Cells LowCode ImageConverter in .NET-Anwendungen umwandeln kann.ImageConvert bietet einen gestrehten Ansatz für die Exportung von Visual-Elementen von Excel als hochwertige Bilder ohne umfassende Codierung oder tiefe Kenntnisse der internen Strukturen des Excel.

Real-Weltproblem

Report-Designer und Business-Analysten müssen oft Excel-basierte Visualisierungen in Präsentationen, Dokumente und Web-Anwendungen integrieren. manuell Screenshots oder mit komplexen Bildmanipulationsbibliotheken führen zu unvereinbarer Qualität, verlorene Formatierung und signifikanten Entwicklungsoberflächen.

Überblick der Lösung

Mit Aspose.Cells LowCode ImageConverter können wir diese Herausforderung effizient mit minimalem Code lösen. Diese Lösung ist ideal für Report-Designer und Business-Analysten, die hochwertige visuelle Vermögenswerte aus Excel-Daten programmatisch generieren müssen, während Formatierung und visueller Treue beibehalten werden.

Voraussetzung

Bevor Sie die Lösung implementieren, stellen Sie sicher, dass Sie:

  • Visual Studio 2019 oder später
  • .NET 6.0 oder höher (kompatibel mit .Net Framework 4.6.2+)
  • Aspose.Cells für das .NET-Paket über NuGet installiert
  • Grundverständnis der C#-Programmierung

PM> Install-Package Aspose.Cells

Schritt für Schritt Implementierung

Schritt 1: Installieren und Konfigurieren Aspose.Cells

Fügen Sie das Aspose.Cells-Paket zu Ihrem Projekt hinzu und enthalten die erforderlichen Namenräume:

using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;
using System.IO;

Schritt 2: Bereiten Sie Ihre Input-Daten vor

Identifizieren Sie die Excel-Datei, die die Diagramme oder Werkblätter enthält, auf die Sie in PNG-Bilder konvertieren möchten.

// Define the path to your Excel file
string excelFilePath = "reports/quarterly_sales.xlsx";

// Ensure the directory for output exists
Directory.CreateDirectory("result");

Schritt 3: Konfigurieren Sie die ImageConverter Optionen

Konfigurieren Sie die Optionen für den ImageConverter-Prozess nach Ihren Anforderungen:

// Basic usage - convert the entire workbook
ImageConverter.Process(excelFilePath, "result/BasicOutput.png");

// Advanced configuration
LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
loadOptions.InputFile = excelFilePath;

LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
imageOptions.Quality = 100; // Set the quality of the output image
imageOptions.OnePagePerSheet = true; // Each sheet on a separate image
saveOptions.ImageOptions = imageOptions;

Schritt 4: Durchführen des ImageConverter-Prozesses

Führen Sie die Operation ImageConverter mit den konfigurierten Optionen aus:

// Basic execution
ImageConverter.Process(loadOptions, saveOptions);

// Advanced execution with custom file naming
LowCodeSaveOptionsProviderOfPlaceHolders fileNameProvider = new LowCodeSaveOptionsProviderOfPlaceHolders(
    "result/Chart${SheetIndexPrefix}${SheetIndex}_${SplitPartIndex}.png");
fileNameProvider.SheetIndexOffset = 1;
fileNameProvider.SheetIndexPrefix = "S";
fileNameProvider.SplitPartIndexOffset = 1;

ImageConverter.Process(loadOptions, saveOptions, fileNameProvider);

Schritt 5: Verwenden Sie den Ausgang

Verarbeiten und nutzen Sie die generierten PNG-Bilder, wie für Ihre Anwendung erforderlich ist:

// Verify the output files exist
if (File.Exists("result/ChartS1_1.png"))
{
    Console.WriteLine("Chart image successfully created!");
    
    // Implement your logic to use the image files
    // For example: Copy to a web server directory
    // File.Copy("result/ChartS1_1.png", "wwwroot/images/chart1.png");
}

Schritt 6: Implementierung Fehlerbehandlung

Fügen Sie die richtige Fehlerbehandlung hinzu, um eine robuste Funktion zu gewährleisten:

try
{
    // Configure load options
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
    loadOptions.InputFile = excelFilePath;
    
    // Configure save options
    LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
    ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
    imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
    saveOptions.ImageOptions = imageOptions;
    
    // Execute conversion
    ImageConverter.Process(loadOptions, saveOptions);
    
    Console.WriteLine("Conversion completed successfully.");
}
catch (Exception ex)
{
    // Error handling and logging
    Console.WriteLine($"Error during conversion: {ex.Message}");
    // Log the error to your logging system
    // Consider implementing retry logic for transient issues
}

Schritt 7: Optimierung der Leistung

Betrachten Sie diese Optimierungstechniken für Produktionsumgebungen:

  • Verwenden Sie Speicherströme für hohe Volumenverarbeitung, um Dateien I/O zu vermeiden
  • Implementierung der parallelen Verarbeitung für mehrere Diagramme oder Arbeitsblätter
  • Anpassung der Bildqualitätsinstellungen für den entsprechenden Gleichgewicht zwischen Qualität und Dateigröße
// Using memory streams for programmatic use without file I/O
using (MemoryStream outputStream = new MemoryStream())
{
    LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
    loadOptions.InputFile = excelFilePath;
    
    LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
    ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
    imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
    
    // For web use, might want lower quality/size
    imageOptions.Quality = 85;
    saveOptions.ImageOptions = imageOptions;
    saveOptions.OutputStream = outputStream;
    
    ImageConverter.Process(loadOptions, saveOptions);
    
    // Use the stream directly (e.g., with web responses)
    byte[] imageBytes = outputStream.ToArray();
    
    // Example: save to file from memory stream
    File.WriteAllBytes("result/OptimizedChart.png", imageBytes);
}

Schritt 8: Vollständige Umsetzung

Hier ist ein vollständiges Arbeitsbeispiel, das den gesamten Prozess demonstriert:

using System;
using System.IO;
using Aspose.Cells;
using Aspose.Cells.LowCode;
using Aspose.Cells.Rendering;

namespace ExcelChartToPngConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                // Set up directories
                Directory.CreateDirectory("result");
                
                // Define source Excel file
                string excelFilePath = "quarterly_sales.xlsx";
                
                Console.WriteLine("Starting Excel chart conversion...");
                
                // Basic conversion - entire workbook
                ImageConverter.Process(excelFilePath, "result/FullWorkbook.png");
                
                // Advanced conversion with options
                LowCodeLoadOptions loadOptions = new LowCodeLoadOptions();
                loadOptions.InputFile = excelFilePath;
                
                LowCodeImageSaveOptions saveOptions = new LowCodeImageSaveOptions();
                ImageOrPrintOptions imageOptions = new ImageOrPrintOptions();
                imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
                imageOptions.Quality = 100;
                imageOptions.OnePagePerSheet = true;
                saveOptions.ImageOptions = imageOptions;
                
                // Custom file naming pattern for multi-sheet output
                LowCodeSaveOptionsProviderOfPlaceHolders fileNameProvider = 
                    new LowCodeSaveOptionsProviderOfPlaceHolders(
                        "result/Report${SheetIndexPrefix}${SheetIndex}_${SplitPartIndex}.png");
                fileNameProvider.SheetIndexOffset = 1;
                fileNameProvider.SheetIndexPrefix = "S";
                fileNameProvider.SplitPartIndexOffset = 1;
                
                // Execute conversion with custom naming
                ImageConverter.Process(loadOptions, saveOptions, fileNameProvider);
                
                // For specific sheet only conversion
                saveOptions = new LowCodeImageSaveOptions();
                imageOptions = new ImageOrPrintOptions();
                imageOptions.ImageType = Aspose.Cells.Drawing.ImageType.Png;
                imageOptions.PageIndex = 0; // First sheet only
                saveOptions.ImageOptions = imageOptions;
                saveOptions.OutputFile = "result/FirstSheetOnly.png";
                
                ImageConverter.Process(loadOptions, saveOptions);
                
                Console.WriteLine("Conversion completed successfully!");
                Console.WriteLine("Output files located in 'result' directory.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error occurred: {ex.Message}");
                Console.WriteLine(ex.StackTrace);
            }
        }
    }
}

Verwendung von Fällen und Anwendungen

Enterprise Reporting-Systeme

Finanzanalytiker können automatisch visuelle Vermögenswerte aus Excel-Berichten generieren, um sie in exekutive Präsentationen oder Dashboards aufzunehmen.Dies beseitigt manuelle Screenshots und sorgt für konsistente, qualitativ hochwertige Visualisationen, die die Quelldaten genau darstellen.

Datenintegration Workflows

Integrierte Workflows können Excel-basierte Diagramme automatisch in Bildformate umwandeln, um in PDF-Berichte, Webportale oder E-Mail-Nachrichten zu integrieren.Dieser Automatisierung reduziert die manuelle Anstrengung, die erforderlich ist, Datenvisualisierungen in verbrauchbare Formate zu transformieren.

automatische Dokumentverarbeitung

Dokumentenerzeugungssysteme können Charts und Visualisierungen aus Excel-Workshopen programmatisch extrahieren, um professionelle Berichte zu erstellen, die Daten, Text und visuelle Elemente kombinieren.

Gemeinsame Herausforderungen und Lösungen

Herausforderung 1: Aufrechterhaltung der Bildqualität

Lösung: Konfigurieren Sie die ImageOrPrintOptions mit geeigneten Qualitätsinstellungen und Auflösungsparameter, um eine optimale Leistung zu gewährleisten. Für Präsentationen und gedruckte Materialien verwenden Sie Qualitätseinrichtungen von 90 oder höher und berücksichtigen Sie, die DPI-Settings auf der Grundlage der gewünschten Verwendung anzupassen.

Herausforderung 2: Große Werkstücke handhaben

Lösung: Verwenden Sie die ImageOrPrintOptions.PageIndex und PageCount Eigenschaften, um spezifische Teile großer Arbeitsblätter zu verarbeiten. Für sehr große Arbeitsplätze berücksichtigen Sie den Einsatz von Schaltmethoden durch die Konfiguration anpassender Seiteninstellungen in der Excel-Datei.

Herausforderung 3: Unverträglich Rendering durch Umgebungen

Lösung: Stellen Sie sicher, dass die in der Excel-Datei verwendeten Schriften auf dem Server verfügbar sind, oder verwenden Sie die Schriftwechselinstellungen in Aspose.Cells. Prüfen Sie grundsätzlich über verschiedene Umgebungen und berücksichtigen Sie, die notwendigen Schritte in Ihre Anwendung zu integrieren.

Performance Beachtung

  • Verwenden Sie Speicherströme anstelle von I/O-Dateien, wenn Sie mehrere Bilder in einem Set-Prozess konvertieren
  • Für mehrstrichtige Umgebungen implementieren Sie geeignete Schließmechanismen beim Zugriff auf gemeinsame Ressourcen
  • Betrachten Sie die Blattgröße und die Komplexität bei der Einstellung von Qualitätsoptionen – höherer Komplexität erfordert mehr Verarbeitungsressourcen

Beste Praktiken

  • Implementieren von Caching-Mekanismen für häufige Charts, um wiederholte Konvertierungen zu vermeiden
  • Setzen Sie eine systematische Naming-Konvention für Output-Dateien, um die Quelle jedes Bildes zu verfolgen
  • Inkludieren Sie Metadaten in das Bild-Ausgabe-Direktorien, um die Traceability zurück zu den Quell-Excel-Dateien zu erhalten
  • Validieren Sie Eingabe Excel-Dateien vor der Verarbeitung, um sicherzustellen, dass sie die erwarteten Charts und Daten enthalten
  • Implementierungslogging, um erfolgreiche Konvertierungen und Probleme zu verfolgen, die während der Verarbeitung auftreten

Fortgeschrittene Szenarien

Für komplexere Anforderungen berücksichtigen Sie diese fortgeschrittenen Implementierungen:

Szenario 1: Nur spezifische Charts aus einem Arbeitsblatt zu extrahieren

using Aspose.Cells;
using Aspose.Cells.Charts;
using Aspose.Cells.Drawing;
using System.IO;

// Load the workbook
Workbook workbook = new Workbook("reports/charts.xlsx");

// Get the first worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Process each chart in the worksheet
for (int i = 0; i < worksheet.Charts.Count; i++)
{
    Chart chart = worksheet.Charts[i];
    
    // Save only specific charts based on title or other properties
    if (chart.Title.Text.Contains("Revenue"))
    {
        // Create image for this specific chart
        chart.ToImage("result/revenue_chart_" + i + ".png", new ImageOrPrintOptions
        {
            ImageType = ImageType.Png,
            HorizontalResolution = 300,
            VerticalResolution = 300
        });
    }
}

Szenario 2: Erstellen eines Multi-Chart-Dashboard-Images

using Aspose.Cells;
using Aspose.Cells.Drawing;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

// Load the workbook containing charts
Workbook workbook = new Workbook("reports/dashboard_data.xlsx");

// Create a bitmap to serve as the dashboard canvas
using (Bitmap dashboardImage = new Bitmap(1200, 800))
{
    using (Graphics g = Graphics.FromImage(dashboardImage))
    {
        // Set white background
        g.Clear(Color.White);
        
        // Draw title
        using (Font titleFont = new Font("Arial", 18, FontStyle.Bold))
        {
            g.DrawString("Q2 2025 Performance Dashboard", titleFont, 
                Brushes.DarkBlue, new PointF(400, 30));
        }
        
        // Extract and place charts
        int yPosition = 100;
        for (int sheetIndex = 0; sheetIndex < 3; sheetIndex++)
        {
            // Get specific worksheet with chart
            Worksheet sheet = workbook.Worksheets[sheetIndex];
            
            if (sheet.Charts.Count > 0)
            {
                // Convert chart to image
                MemoryStream chartStream = new MemoryStream();
                sheet.Charts[0].ToImage(chartStream, new ImageOrPrintOptions
                {
                    ImageType = ImageType.Png,
                    HorizontalResolution = 150,
                    VerticalResolution = 150
                });
                
                // Load chart image
                using (Bitmap chartImage = new Bitmap(chartStream))
                {
                    // Position chart on dashboard
                    g.DrawImage(chartImage, new Rectangle(50, yPosition, 500, 300));
                    yPosition += 320;
                }
            }
        }
        
        // Save the composite dashboard image
        dashboardImage.Save("result/complete_dashboard.png", ImageFormat.Png);
    }
}

Schlussfolgerungen

Durch die Implementierung von Aspose.Cells LowCode ImageConverter können Sie Excel-Diagramme und Werkblätter effizient in hochwertige PNG-Bilder konvertieren und die Erstellung von visuellen Vermögenswerten für Berichte und Präsentationen gestärkt. Dieser Ansatz reduziert die Entwicklungszeit und manuelle Anstrengungen erheblich, während die visuelle Treue und Formatierung Konsistenz beibehalten.

Weitere Informationen und weitere Beispiele finden Sie unter Aspose.Cells.LowCode API Referenz .

 Deutsch