Wie man PowerPoint-Dateien in C# anzeigt

Einführung

Im Bereich der Software-Entwicklung erfordert die Bereitstellung reichhaltiger und fesselnder Benutzererfahrungen die Fähigkeit, viele Medienarten in Programme einzubinden. Da Microsoft Office PowerPoint-Präsentationen häufig zur Vermittlung von Informationen verwendet werden, ist es von Vorteil, ein PowerPoint-Viewer-Steuerelement in ein C#-WinForms-Programm zu integrieren. In diesem Artikel wird erklärt, wie diese Art von Steuerung integriert werden kann, so dass Entwickler ihre Anwendungen um PowerPoint-Anzeigefunktionen erweitern und verbessern können. In diesem Artikel werden wir C# PowerPoint Viewer ohne Installation von MS PowerPoint Viewer erstellen.

Wie man Powerpoint-Dateien in C# anzeigt;

1. Erstellen Sie eine PowerPoint-Anwendungsinstanz.

2. Fügen Sie die Interop-Referenz zum Projekt hinzu

3. Öffnen Sie die Präsentation über die Instanz.

4. Prüfen und erstellen Sie einen Ausgabeordner für die Exportdateien.

5. Laden Sie die zu erstellenden Folienbilder in das Feld Bild. Verwenden Sie die Taste, um zwischen den Folien zu wechseln.

6. Schließen Sie die Präsentation und beenden Sie die Anwendung.

Das PowerPoint Viewer-Steuerelement verstehen

PowerPoint-Präsentationen werden in einer Vielzahl von Bereichen eingesetzt, unter anderem im Bildungswesen und in der Wirtschaft. Die Einbindung eines PowerPoint-Viewer-Steuerelements in eine WinForms-Anwendung hat mehrere Vorteile.

• Nahtlose Integration: Indem Benutzer PowerPoint-Präsentationen direkt innerhalb der Anwendung sehen und interaktiv nutzen können, wird die Zeit, die sie mit dem Wechseln zwischen verschiedenen Programmen verbringen, reduziert und ihr Arbeitsablauf rationalisiert.
• Verbesserte Benutzererfahrung: Das Programm verbessert die Benutzererfahrung und Effizienz, indem es eine vertraute Oberfläche für die Arbeit mit PowerPoint-Folien bietet.
• Erhöhte Flexibilität: Für Windows-Entwickler in .NET-Anwendungen können Entwickler durch Hinzufügen von Navigationssteuerungen oder Einführen von Anzeigemodi die Betrachtersteuerung anpassen, um einzigartige Anforderungen zu erfüllen.

Hinzufügen von Referenzen

Fügen Sie zuerst Verweise auf die notwendigen Assemblys hinzu: Um den Verweis auf Microsoft.Office.Interop.PowerPoint in Ihrem Projekt hinzuzufügen, klicken Sie mit der rechten Maustaste auf das Projekt in Visual Studio, wählen Sie "Hinzufügen" > "Verweis" und fügen Sie sie dann im COM-Tab hinzu.

Betrachter PowerPoint

Der Microsoft.Office.Interop.PowerPoint-Namensraum bietet Klassen und Methoden für die programmatische Interaktion mit PowerPoint-Präsentationen. Stellen Sie sicher, dass PowerPoint auf dem System installiert ist. Lassen Sie uns den folgenden Code aus dem vorangegangenen Beispiel analysieren und erklären:

using Microsoft.Office.Core;
using Microsoft.Office.Interop.PowerPoint;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace DataTableWindowsForm
{
    public partial class PowerPointViewer : Form
    {
        private Microsoft.Office.Interop.PowerPoint.Application pptApplication = new Microsoft.Office.Interop.PowerPoint.Application();
        private Presentation pptPresentation;
        private string outputFolder = @"output_images";
        private int slideIndex = 1;
        public PowerPointViewer()
        {
            InitializeComponent();
        }
        private void DisplaySlide()
        {
            if (!Directory.Exists(outputFolder))
                Directory.CreateDirectory(outputFolder);
            // Export the slide as an png file
            string tempHtmlFile = Path.Combine(outputFolder, "temp.png");
            pptPresentation.Slides [slideIndex].Export(tempHtmlFile, "png", 1024, 768);
            // Load the HTML file into the picture box control
            pictureBox1.ImageLocation = tempHtmlFile;
        }
        private void Next_Click(object sender, EventArgs e)
        {
            int currentSlideIndex = slideIndex;
            if (currentSlideIndex < pptPresentation.Slides.Count)
            {
                slideIndex = slideIndex + 1;
                DisplaySlide();
            }
        }
        private void PowerPointViewercs_Load(object sender, EventArgs e)
        {
            // Load PowerPoint Presentation
            string pptFilePath = "demo.pptx"; // Path to your PowerPoint file
            pptPresentation = pptApplication.Presentations.Open(pptFilePath, MsoTriState.msoFalse, MsoTriState.msoFalse, MsoTriState.msoFalse);
        // Load PowerPoint files here
            DisplaySlide();
        }
        private void Previous_Click(object sender, EventArgs e)
        {
            int currentSlideIndex = slideIndex;
            if (currentSlideIndex > 1)
            {
                slideIndex = slideIndex - 1;
                DisplaySlide();
            }
        }
        private void PowerPointViewercs_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Close the PowerPoint presentation and quit the application when the form is closing
            pptPresentation.Close();
            pptApplication.Quit();
        }
    }
}

using Microsoft.Office.Core;
using Microsoft.Office.Interop.PowerPoint;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace DataTableWindowsForm
{
    public partial class PowerPointViewer : Form
    {
        private Microsoft.Office.Interop.PowerPoint.Application pptApplication = new Microsoft.Office.Interop.PowerPoint.Application();
        private Presentation pptPresentation;
        private string outputFolder = @"output_images";
        private int slideIndex = 1;
        public PowerPointViewer()
        {
            InitializeComponent();
        }
        private void DisplaySlide()
        {
            if (!Directory.Exists(outputFolder))
                Directory.CreateDirectory(outputFolder);
            // Export the slide as an png file
            string tempHtmlFile = Path.Combine(outputFolder, "temp.png");
            pptPresentation.Slides [slideIndex].Export(tempHtmlFile, "png", 1024, 768);
            // Load the HTML file into the picture box control
            pictureBox1.ImageLocation = tempHtmlFile;
        }
        private void Next_Click(object sender, EventArgs e)
        {
            int currentSlideIndex = slideIndex;
            if (currentSlideIndex < pptPresentation.Slides.Count)
            {
                slideIndex = slideIndex + 1;
                DisplaySlide();
            }
        }
        private void PowerPointViewercs_Load(object sender, EventArgs e)
        {
            // Load PowerPoint Presentation
            string pptFilePath = "demo.pptx"; // Path to your PowerPoint file
            pptPresentation = pptApplication.Presentations.Open(pptFilePath, MsoTriState.msoFalse, MsoTriState.msoFalse, MsoTriState.msoFalse);
        // Load PowerPoint files here
            DisplaySlide();
        }
        private void Previous_Click(object sender, EventArgs e)
        {
            int currentSlideIndex = slideIndex;
            if (currentSlideIndex > 1)
            {
                slideIndex = slideIndex - 1;
                DisplaySlide();
            }
        }
        private void PowerPointViewercs_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Close the PowerPoint presentation and quit the application when the form is closing
            pptPresentation.Close();
            pptApplication.Quit();
        }
    }
}

Imports Microsoft.Office.Core
Imports Microsoft.Office.Interop.PowerPoint
Imports System
Imports System.Collections.Generic
Imports System.ComponentModel
Imports System.Data
Imports System.Drawing
Imports System.IO
Imports System.Linq
Imports System.Text
Imports System.Threading.Tasks
Imports System.Windows.Forms
Namespace DataTableWindowsForm
	Partial Public Class PowerPointViewer
		Inherits Form

		Private pptApplication As New Microsoft.Office.Interop.PowerPoint.Application()
		Private pptPresentation As Presentation
		Private outputFolder As String = "output_images"
		Private slideIndex As Integer = 1
		Public Sub New()
			InitializeComponent()
		End Sub
		Private Sub DisplaySlide()
			If Not Directory.Exists(outputFolder) Then
				Directory.CreateDirectory(outputFolder)
			End If
			' Export the slide as an png file
			Dim tempHtmlFile As String = Path.Combine(outputFolder, "temp.png")
			pptPresentation.Slides (slideIndex).Export(tempHtmlFile, "png", 1024, 768)
			' Load the HTML file into the picture box control
			pictureBox1.ImageLocation = tempHtmlFile
		End Sub
		Private Sub Next_Click(ByVal sender As Object, ByVal e As EventArgs)
			Dim currentSlideIndex As Integer = slideIndex
			If currentSlideIndex < pptPresentation.Slides.Count Then
				slideIndex = slideIndex + 1
				DisplaySlide()
			End If
		End Sub
		Private Sub PowerPointViewercs_Load(ByVal sender As Object, ByVal e As EventArgs)
			' Load PowerPoint Presentation
			Dim pptFilePath As String = "demo.pptx" ' Path to your PowerPoint file
			pptPresentation = pptApplication.Presentations.Open(pptFilePath, MsoTriState.msoFalse, MsoTriState.msoFalse, MsoTriState.msoFalse)
		' Load PowerPoint files here
			DisplaySlide()
		End Sub
		Private Sub Previous_Click(ByVal sender As Object, ByVal e As EventArgs)
			Dim currentSlideIndex As Integer = slideIndex
			If currentSlideIndex > 1 Then
				slideIndex = slideIndex - 1
				DisplaySlide()
			End If
		End Sub
		Private Sub PowerPointViewercs_FormClosing(ByVal sender As Object, ByVal e As FormClosingEventArgs)
			' Close the PowerPoint presentation and quit the application when the form is closing
			pptPresentation.Close()
			pptApplication.Quit()
		End Sub
	End Class
End Namespace

Zunächst importieren wir die erforderlichen Namespaces. Dateioperationen werden von System.IO gehandhabt, System.Windows.Forms bietet WinForms-Funktionen, während Microsoft.Office-Klassen für die Interaktion mit PowerPoint in PowerPoint enthalten sind. Innerhalb des PowerPointViewerApp-Namensraums definieren wir eine WinForms-Formularklasse namens PowerPointViewer. Die primäre Benutzeroberfläche für die PPT-Anwendung wird dieses Formular sein.

Es wird angekündigt, dass Verweise auf die PowerPoint-Anwendung und -Präsentation in zwei privaten Feldern, pptApplication und pptPresentation, gespeichert würden. Durch die Verwendung von InitializeComponent() richtet der Konstruktor die vom Designer definierten visuellen Komponenten des Formulars ein und initialisiert das Formular. Wenn das Formular geladen wird, wird die InitializeComponent()-Funktion aufgerufen. Die PowerPoint-Anwendung (pptApplication) wird initialisiert und an diesem Punkt zugänglich gemacht.

Als Nächstes starten wir die PowerPoint-Datei, die pptFilePath angibt. Mit pptApplication.Presentations öffnen wir die PowerPoint-Datei, indem wir ihren Pfad (pptFilePath) an die Open()-Funktion übergeben. Die Prozedur gibt ein Presentation-Objekt zurück, das die geöffnete Präsentation darstellt.

Um die erste Folie der PowerPoint-Präsentation anzuzeigen, verwenden wir die Funktion DisplaySlide(). Der Index der ersten Folie ist 1. Das Ergebnis dieser Funktion ist die Folie, die in der Bildrahmensteuerung angezeigt wird. Wir verwenden die Export()-Funktion, um die ausgewählte Folie als PNG-Datei zu exportieren. Der temporäre Ordner des Systems ist der Ort, an dem die exportierte PNG-Datei vorübergehend gespeichert wird. Mithilfe der ImageLocation()-Methode laden wir die exportierte PNG-Datei in die PictureBox-Steuerung. Mit diesen Techniken können Sie zwischen den Folien wechseln.

Die Navigationsschaltflächen btnPrevious_Click und btnNext_Click bringen Sie zu den vorherigen beziehungsweise nächsten Folien. Durch die Verwendung von pptPresentation können wir den Index der Folie in der Variable slideIndex erhalten. Wir rufen DisplaySlide() mit dem Index der vorherigen oder nächsten Folie auf, wenn sich der aktuelle Folienindex im gültigen Bereich von 1 bis zur Gesamtanzahl der Folien befindet.

Wenn das Formular geschlossen wird, wird die Close()-Funktion aufgerufen. Hier stellen wir sicher, dass das Ressourcenmanagement korrekt durchgeführt wird, indem wir Systemressourcen freigeben, indem wir das PowerPoint-Programm verlassen und die PowerPoint-Anwendung mit der Quit()-Methode beenden.

PowerPoint-Datei

Ausgabe: PowerPoint-Betrachter

IronXL

Die Bearbeitung von Excel-Dateien in C# wird mit der beliebten .NET Excel Library IronXL erleichtert. Es ist ein vielseitiges Tool, das dank seiner umfangreichen Funktionen zum Lesen, Erstellen und Ändern von Excel-Dateien für eine Vielzahl von Anwendungen geeignet ist.

Im Folgenden werde ich auf einige der wichtigsten Eigenschaften von IronXL eingehen:

Einfacher Zugang und hohe Geschwindigkeit

• Mit IronXL können Entwickler Daten aus aktuellen Excel-Dateien lesen und Daten schnell in neue oder bestehende Excel-Dateien schreiben. Hier geht es um den Zugriff auf die Arbeitsmappe und die Arbeitsblatteigenschaften wie Zellwerte, Formeln und Formatierungen.

Umfassende Excel-Unterstützung

• Entwickler können mit IronXL Daten aus Datenbanken, CSV-Dateien und anderen Quellen in Excel-Tabellen importieren. Ebenso können Daten aus Excel-Dateien in eine Vielzahl von Formaten exportiert werden, darunter CSV, HTML, XML und PDF.

Flexibilität

• Mit IronXL können Entwickler dynamisch Arbeitsblätter aus Excel-Dateien hinzufügen, ändern und löschen. Dies ermöglicht eine flexible Gestaltung des Datenformats und der Organisation entsprechend den Anforderungen der Anwendung.

Genaue Modifikationen

• In Excel-Tabellen können dank IronXL einzelne Zellen präzise verändert werden. Entwickler können Zellwerte, Formeln, Stile, Formatierungen und andere Funktionen programmatisch festlegen.

  Um mehr über die Dokumentation zu erfahren, klicken Sie hier.

IronXL installieren

Bevor wir fortfahren, lassen Sie uns zunächst IronXL mit dem NuGet-Paketmanager-Konsole installieren:

Install-Package IronXL.Excel

Install-Package IronXL.Excel

IronXL kann nach der Installation in unserem C#-Projekt verwendet werden.

Verwendung von IronXL für Excel-Operationen

Schauen wir uns ein hypothetisches Szenario an, in dem wir mit IronXL Daten aus einer Excel-Datei lesen wollen. Hier ein kleines Beispiel, wie man das erreichen kann:

using IronXL;
using System;
class Program
{
    static void Main(string [] args)
    {
        // Path to the Excel file
        string excelFilePath = "sample.xlsx";
        // Load the Excel file
        WorkBook workbook = WorkBook.Load(excelFilePath);
        // Access the first worksheet
        WorkSheet worksheet = workbook.WorkSheets [0];
        // Iterate through rows and columns to read data
        foreach (var row in worksheet.Rows)
        {
            foreach (var cell in row)
            {
                Console.Write(cell.Value + "\t");
            }
            Console.WriteLine();
        }
    }
}

using IronXL;
using System;
class Program
{
    static void Main(string [] args)
    {
        // Path to the Excel file
        string excelFilePath = "sample.xlsx";
        // Load the Excel file
        WorkBook workbook = WorkBook.Load(excelFilePath);
        // Access the first worksheet
        WorkSheet worksheet = workbook.WorkSheets [0];
        // Iterate through rows and columns to read data
        foreach (var row in worksheet.Rows)
        {
            foreach (var cell in row)
            {
                Console.Write(cell.Value + "\t");
            }
            Console.WriteLine();
        }
    }
}

Imports Microsoft.VisualBasic
Imports IronXL
Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Path to the Excel file
		Dim excelFilePath As String = "sample.xlsx"
		' Load the Excel file
		Dim workbook As WorkBook = WorkBook.Load(excelFilePath)
		' Access the first worksheet
		Dim worksheet As WorkSheet = workbook.WorkSheets (0)
		' Iterate through rows and columns to read data
		For Each row In worksheet.Rows
			For Each cell In row
				Console.Write(cell.Value & vbTab)
			Next cell
			Console.WriteLine()
		Next row
	End Sub
End Class

Wir beginnen mit dem Hinzufügen der erforderlichen Namespaces. Der IronXL-Namensraum enthält die Klassen und Methoden, die von der IronXL-Bibliothek bereitgestellt werden. Der Pfad zu sample.xlsx, der Excel-Datei, die wir lesen wollen, ist angegeben. Unter Verwendung von WorkBook wird die Excel-Datei geladen. Das Workbook-Objekt, das von der Load()-Methode bereitgestellt wird, repräsentiert das Excel-Arbeitsbuch. Wir können auf das erste Arbeitsblatt der Arbeitsmappe zugreifen, indem wir workbook.WorkSheets [0] verwenden. Wir gehen über die Zeilen und Spalten des Arbeitsblatts mit gestapelten für jede Schleife. Wir senden den Wert jeder Zelle an die Konsole.

Um mehr über die IronXL-Codebeispiele zu erfahren, klicken Sie hier.

Schlussfolgerung

Mehrere Softwareanwendungen erfordern die Konvertierung von PowerPoint-Präsentationen in Bilder mit C#. Der Vorgang könnte relativ schnell abgeschlossen sein, unabhängig davon, ob der Microsoft.Office.Interop.PowerPoint-Namensraum verwendet wird. Mit Hilfe der Codebeispiele in diesem Artikel können Sie die Konvertierung von PowerPoint in Bilder ganz einfach in Ihre C#-Programme integrieren und so eine Welt der Möglichkeiten für die Änderung und Bereitstellung von Informationen eröffnen.

IronXL bietet eine einfache und effiziente Methode, um Excel-Operationen in C# durchzuführen, ohne dass Excel auf dem Zielsystem installiert sein muss oder auf die Interop-Bibliothek zugegriffen werden muss. Mit seinem umfassenden Funktionsumfang und seiner benutzerfreundlichen API ist IronXL ein praktisches Tool für Entwickler, die mit Excel-Daten in C#-Anwendungen arbeiten. Es vereinfacht Aufgaben wie das Lesen, Schreiben und Bearbeiten von Excel-Dateien. Für Excel-bezogene Entwicklungsprojekte bietet IronXL eine stabile Lösung, die die Produktivität und Flexibilität steigert, egal ob Sie Daten verarbeiten, Berichte erstellen oder Tabellenkalkulationsaufgaben automatisieren.

Eine kostenlose Community Edition mit Einschränkungen für die nicht-kommerzielle Nutzung wurde von IronXL zur Verfügung gestellt. Die kostenpflichtigen Versionen beginnen bei $749 und können durch Abonnement oder unbefristete Lizenzierungsmodelle erworben werden. Sie verfügen über einen größeren Funktionsumfang und bieten mehr Funktionen und Unterstützung. IronXL bietet auch eine kostenlose Testlizenz an. Für umfassende und aktuelle Informationen zur Lizenzierung besuchen Sie bitte die Lizenzseite. Besuchen Sie diese Website, um mehr über die Produkte von Iron Software zu erfahren.