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.

• Reibungslose Integration: Durch die Möglichkeit, PowerPoint-Präsentationen direkt in der Anwendung zu sehen und mit ihnen zu interagieren, können die Benutzer die Zeit, die sie mit dem Wechsel zwischen verschiedenen Programmen verbringen, reduzieren und ihre Arbeitsabläufe rationalisieren.
• Verbesserte Benutzerfreundlichkeit: Das Programm verbessert die Benutzerfreundlichkeit und Effizienz, indem es eine wiedererkennbare Oberfläche für die Arbeit mit PowerPoint-Folien bietet.
• Erhöhte Flexibilität: Für Windows-Entwickler in .NET-Anwendungen kann das Viewer-Steuerelement durch das Hinzufügen von Navigationssteuerelementen oder die Einführung von Anzeigemodi an die jeweiligen Bedürfnisse angepasst werden.

Hinzufügen von Referenzen

Fügen Sie zunächst Verweise auf die erforderlichen Baugruppen hinzu: Um eine Microsoft.Office.Interop.PowerPoint-Referenz in Ihrem Projekt hinzuzufügen, klicken Sie mit der rechten Maustaste auf das Projekt in Visual Studio, wählen Sie "Hinzufügen" > "Referenz" und fügen Sie sie dann auf der Registerkarte COM hinzu.

Betrachter PowerPoint

DieMicrosoft.Office.Interop.PowerPoint namespace 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 behandelt, 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 werden sollen. Durch die Verwendung von InitializeComponent()Der Konstruktor richtet die visuellen Komponenten des Formulars ein, die vom Designer definiert wurden, und initialisiert das Formular. Wenn das Formular geladen wird, wird die InitializeComponent() funktion aufgerufen wird. Die PowerPoint-Anwendung(pptAnwendung) wird an dieser Stelle initialisiert und 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 angeben(pptFilePath) zum Offenen() Funktion. 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 den Befehl DisplaySlide() Funktion. Der Index der ersten Folie ist 1. Das Ergebnis dieser Funktion ist die Folie, die in der Bildrahmensteuerung angezeigt wird. Wir verwenden den Export() Mit dieser Funktion können Sie die ausgewählte Folie als PNG-Datei exportieren. Die exportierte PNG-Datei wird vorübergehend im temporären Ordner des Systems gespeichert. Verwendung der Funktion ImageLocation() Methode laden wir die exportierte PNG-Datei in das PictureBox-Steuerelement. Mit diesen Techniken können Sie zwischen den Folien wechseln.

Die Navigationsschaltflächen btnPrevious_Click und btnNext_Click führen Sie zur vorherigen bzw. nächsten Folie. Mit pptPresentation können wir den Index der Folie in der Variablen slideIndex ermitteln. Wir nennen DisplaySlide() mit dem Index der vorherigen bzw. nächsten Folie, wenn der Index der aktuellen Folie im gültigen Bereich von 1 bis zur gesamten Anzahl der Folien liegt.

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

PowerPoint-Datei

Ausgabe: PowerPoint-Betrachter

IronXL

Die Bearbeitung von Excel-Dateien in C# wird durch die beliebte .NET Excel Library erleichtertIronXL. 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.

  Weitere Informationen über die Dokumentation finden Sie unterhier.

IronXL installieren

Bevor wir fortfahren, installieren wir zunächstIronXL über die NuGet-Paketmanager-Konsole:

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. Mit Hilfe von WorkBook wird die Excel-Datei geladen. Das Workbook-Objekt, das vom Befehl Load geliefert wird() methode stellt die Excel-Arbeitsmappe dar. Wir können auf das erste Arbeitsblatt der Arbeitsmappe zugreifen, indem wir workbook.WorkSheets[0]. Wir gehen über die Zeilen und Spalten des Arbeitsblatts mit gestapelten für jede Schleife. Wir senden den Wert jeder Zelle an die Konsole.

Weitere Informationen zu den IronXL-Codebeispielen finden Sie unterhier.

Schlussfolgerung

Mehrere Softwareanwendungen erfordern die Konvertierung von PowerPoint-Präsentationen in Bilder mit C#. Der Prozess kann relativ schnell abgeschlossen werden, unabhängig davon, ob der Microsoft.Office.Interop.PowerPoint-Namensraum verwendet wird oder nicht. 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 angewiesen ist. 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. Kostenpflichtige Versionen beginnen bei $749 und können über ein Abonnement oder eine unbefristete Lizenz erworben werdengenehmigungsverfahren. Sie verfügen über einen größeren Funktionsumfang und bieten mehr Funktionen und Unterstützung. IronXL bietet auch einekostenlose Testlizenz. Umfassende und aktuelle Informationen zur Lizenzvergabe finden Sie auf der Websitelizenzseite. Besuchen Sie diesewebsite um mehr über die Produkte von Iron Software zu erfahren.