C# Objektorientiert (Wie es für Entwickler funktioniert)

Objektorientierte Programmierung (OOP) ist ein grundlegendes Konzept in der Softwareentwicklung, das es Programmierern ermöglicht, modularen, wiederverwendbaren und anpassbaren Code zu erstellen. C#, eine moderne objektorientierte Programmiersprache, bietet einen robusten Rahmen für die Erstellung komplexer Anwendungen. Dieses Handbuch führt in OOP-Konzepte mit C# ein und konzentriert sich auf praktische Implementierungen und Programmierbeispiele, um Anfängern zu helfen, diese Prinzipien zu verstehen und effektiv anzuwenden. Wir werden auch erörtern, wie man diese Grundsätze anwenden kann mit IronPDF-Bibliothek.

Verstehen objektorientierter Programmierkonzepte

Im Mittelpunkt der OOP stehen mehrere Schlüsselkonzepte: Klassen, Objekte, Vererbung, Polymorphismus, Abstraktion und Kapselung. Diese Konzepte ermöglichen es Entwicklern, reale Entitäten zu modellieren, die Komplexität zu bewältigen und die Wartbarkeit ihres Codes zu verbessern.

Klassen und Objekte: Die Bausteine

Eine Klasse erzeugt individuelle Objekte. Die Klasse ist eine Blaupause, die die Daten und das Verhalten definiert, die alle Objekte der Klasse gemeinsam haben. Ein Objekt ist eine Manifestation der Klasse. Sie verkörpert reale Werte und keine abstrakten Platzhalter, die im Klassenentwurf definiert sind.

public class Car // A class declared as 'Car' defines its structure and behavior.
{
    public string Name;
    public string Color;
    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Color: {Color}");
    }
}
class Program // This is the program class, serving as the entry point of C# program
{
    static void Main(string [] args)
    {
        Car myCar = new Car();
        myCar.Name = "Toyota";
        myCar.Color = "Red";
        myCar.DisplayInfo();
    }
}

public class Car // A class declared as 'Car' defines its structure and behavior.
{
    public string Name;
    public string Color;
    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Color: {Color}");
    }
}
class Program // This is the program class, serving as the entry point of C# program
{
    static void Main(string [] args)
    {
        Car myCar = new Car();
        myCar.Name = "Toyota";
        myCar.Color = "Red";
        myCar.DisplayInfo();
    }
}

Public Class Car ' A class declared as 'Car' defines its structure and behavior.
	Public Name As String
	Public Color As String
	Public Sub DisplayInfo()
		Console.WriteLine($"Name: {Name}, Color: {Color}")
	End Sub
End Class
Friend Class Program ' This is the program class, serving as the entry point of C# program
	Shared Sub Main(ByVal args() As String)
		Dim myCar As New Car()
		myCar.Name = "Toyota"
		myCar.Color = "Red"
		myCar.DisplayInfo()
	End Sub
End Class

In diesem Beispiel hat die Klasse Car zwei Datenelemente (Name und Farbe) und eine Methode (DisplayInfo). Die Methode Main, die als Einstiegspunkt der Anwendung dient, erstellt eine Instanz der Klasse Car und weist ihren Feldern Werte zu, bevor sie ihre Methode zur Anzeige dieser Werte aufruft.

Vererbung: Vorhandene Klassen erweitern

Die Vererbung ermöglicht es einer Klasse, die Eigenschaften und Methoden einer bestehenden Klasse zu erben. Die Klasse, deren Eigenschaften geerbt werden, wird als Basisklasse bezeichnet, und die Klasse, die diese Eigenschaften erbt, wird als abgeleitete Klasse bezeichnet.

public class Vehicle
{
    public string LicensePlate;
    public void Honk()
    {
        Console.WriteLine("Honking");
    }
}
public class Truck : Vehicle // Truck is a child class derived from the Vehicle base class
{
    public int CargoCapacity;
}
class Program
{
    static void Main(string [] args)
    {
        Truck myTruck = new Truck();
        myTruck.LicensePlate = "ABC123";
        myTruck.CargoCapacity = 5000;
        myTruck.Honk();
    }
}

public class Vehicle
{
    public string LicensePlate;
    public void Honk()
    {
        Console.WriteLine("Honking");
    }
}
public class Truck : Vehicle // Truck is a child class derived from the Vehicle base class
{
    public int CargoCapacity;
}
class Program
{
    static void Main(string [] args)
    {
        Truck myTruck = new Truck();
        myTruck.LicensePlate = "ABC123";
        myTruck.CargoCapacity = 5000;
        myTruck.Honk();
    }
}

Public Class Vehicle
	Public LicensePlate As String
	Public Sub Honk()
		Console.WriteLine("Honking")
	End Sub
End Class
Public Class Truck ' Truck is a child class derived from the Vehicle base class
	Inherits Vehicle

	Public CargoCapacity As Integer
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim myTruck As New Truck()
		myTruck.LicensePlate = "ABC123"
		myTruck.CargoCapacity = 5000
		myTruck.Honk()
	End Sub
End Class

In diesem Beispiel ist Truck eine abgeleitete Klasse, die die Basisklasse Vehicle erweitert und deren LicensePlate-Feld und Honk-Methode erbt, während sie ein neues Feld, CargoCapacity, hinzufügt.

Polymorphismus und Abstraktion: Interfaces und abstrakte Klassen

Polymorphismus ermöglicht es, dass Objekte als Instanzen ihrer Basisklasse und nicht als Instanzen ihrer spezifischen Klasse behandelt werden. Die Abstraktion ermöglicht es Ihnen, abstrakte Klassen und Schnittstellen zu definieren, die nicht instanziiert werden können, aber als Basisklassen verwendet werden können.

Abstrakte Klassen und Methoden

Abstrakte Klassen können nicht instanziiert werden und werden in der Regel verwendet, um eine gemeinsame Definition einer Basisklasse bereitzustellen, die mehrere abgeleitete Klassen gemeinsam nutzen können.

public abstract class Shape
{
    public abstract void Draw();
}
public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

public abstract class Shape
{
    public abstract void Draw();
}
public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}

Public MustInherit Class Shape
	Public MustOverride Sub Draw()
End Class
Public Class Circle
	Inherits Shape

	Public Overrides Sub Draw()
		Console.WriteLine("Drawing a circle")
	End Sub
End Class

Mehrere Schnittstellen implementieren

Eine Schnittstelle legt eine Vereinbarung oder einen Vertrag fest, den Klassen durch die Implementierung ihrer definierten Methoden erfüllen können. Klassen können mehrere Schnittstellen implementieren, was eine Form von Polymorphismus ermöglicht.

public interface IDrawable
{
    void Draw();
}
public interface IColorable
{
    void Color();
}
public class CustomShape : IDrawable, IColorable // Defining a new class CustomShape that implements IDrawable and IColorable
{
    public void Draw()
    {
        Console.WriteLine("Custom shape drawn");
    }
    public void Color()
    {
        Console.WriteLine("Custom shape colored");
    }
}

public interface IDrawable
{
    void Draw();
}
public interface IColorable
{
    void Color();
}
public class CustomShape : IDrawable, IColorable // Defining a new class CustomShape that implements IDrawable and IColorable
{
    public void Draw()
    {
        Console.WriteLine("Custom shape drawn");
    }
    public void Color()
    {
        Console.WriteLine("Custom shape colored");
    }
}

Public Interface IDrawable
	Sub Draw()
End Interface
Public Interface IColorable
	Sub Color()
End Interface
Public Class CustomShape ' Defining a new class CustomShape that implements IDrawable and IColorable
	Implements IDrawable, IColorable

	Public Sub Draw() Implements IDrawable.Draw
		Console.WriteLine("Custom shape drawn")
	End Sub
	Public Sub Color() Implements IColorable.Color
		Console.WriteLine("Custom shape colored")
	End Sub
End Class

Verkapselung: Schutz der Daten

Kapselung ist ein Mechanismus, der den Zugang zu bestimmten Komponenten eines Objekts einschränkt und verhindert, dass externe Parteien die interne Darstellung sehen können. Dies wird durch die Verwendung von Zugriffsmodifikatoren erreicht.

public class Person
{
    private string name; // Private variable, inaccessible outside the class
    public string Name   // Public property to access the private variable
    {
        get { return name; }
        set { name = value; }
    }
}
// Example showing a simple customer class with encapsulated data
public class Customer
{
    public string Name { get; set; }
    public string Address { get; set; } 
}

public class Person
{
    private string name; // Private variable, inaccessible outside the class
    public string Name   // Public property to access the private variable
    {
        get { return name; }
        set { name = value; }
    }
}
// Example showing a simple customer class with encapsulated data
public class Customer
{
    public string Name { get; set; }
    public string Address { get; set; } 
}

Public Class Person
'INSTANT VB NOTE: The field name was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private name_Conflict As String ' Private variable, inaccessible outside the class
	Public Property Name() As String ' Public property to access the private variable
		Get
			Return name_Conflict
		End Get
		Set(ByVal value As String)
			name_Conflict = value
		End Set
	End Property
End Class
' Example showing a simple customer class with encapsulated data
Public Class Customer
	Public Property Name() As String
	Public Property Address() As String
End Class

In diesem Beispiel ist das Feld Name privat, so dass es außerhalb der Klasse Person unzugänglich ist. Der Zugriff auf dieses Feld erfolgt über die öffentliche Eigenschaft Name, die die Methoden get und set umfasst.

Praktische Anwendungsfälle und Kodierungsbeispiele

Wir werden nun ein Beispiel mit mehreren Klassen untersuchen, um diese Prinzipien in der Praxis zu demonstrieren.

using System;
namespace OOPExample
{
    public class Program
    {
        static void Main(string [] args)
        {
            ElectricCar myElectricCar = new ElectricCar();
            myElectricCar.Make = "Tesla";
            myElectricCar.Model = "Model 3";
            myElectricCar.BatteryLevel = 100;
            myElectricCar.Drive();
            myElectricCar.Charge();
        }
    }
    public abstract class Vehicle
    {
        public string Make { get; set; }
        public string Model { get; set; }
        public abstract void Drive();
    }
    public class Car : Vehicle
    {
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving.");
        }
    }
    public class ElectricCar : Car
    {
        public int BatteryLevel { get; set; }
        public void Charge()
        {
            Console.WriteLine("Charging the car.");
        }
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving silently.");
        }
    }
}

using System;
namespace OOPExample
{
    public class Program
    {
        static void Main(string [] args)
        {
            ElectricCar myElectricCar = new ElectricCar();
            myElectricCar.Make = "Tesla";
            myElectricCar.Model = "Model 3";
            myElectricCar.BatteryLevel = 100;
            myElectricCar.Drive();
            myElectricCar.Charge();
        }
    }
    public abstract class Vehicle
    {
        public string Make { get; set; }
        public string Model { get; set; }
        public abstract void Drive();
    }
    public class Car : Vehicle
    {
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving.");
        }
    }
    public class ElectricCar : Car
    {
        public int BatteryLevel { get; set; }
        public void Charge()
        {
            Console.WriteLine("Charging the car.");
        }
        public override void Drive()
        {
            Console.WriteLine($"The {Make} {Model} is driving silently.");
        }
    }
}

Imports System
Namespace OOPExample
	Public Class Program
		Shared Sub Main(ByVal args() As String)
			Dim myElectricCar As New ElectricCar()
			myElectricCar.Make = "Tesla"
			myElectricCar.Model = "Model 3"
			myElectricCar.BatteryLevel = 100
			myElectricCar.Drive()
			myElectricCar.Charge()
		End Sub
	End Class
	Public MustInherit Class Vehicle
		Public Property Make() As String
		Public Property Model() As String
		Public MustOverride Sub Drive()
	End Class
	Public Class Car
		Inherits Vehicle

		Public Overrides Sub Drive()
			Console.WriteLine($"The {Make} {Model} is driving.")
		End Sub
	End Class
	Public Class ElectricCar
		Inherits Car

		Public Property BatteryLevel() As Integer
		Public Sub Charge()
			Console.WriteLine("Charging the car.")
		End Sub
		Public Overrides Sub Drive()
			Console.WriteLine($"The {Make} {Model} is driving silently.")
		End Sub
	End Class
End Namespace

In diesem Beispiel ist Drive() ist eine abstrakte Methode der abstrakten Klasse Fahrzeug. Car ist eine abgeleitete Klasse, die Drive implementiert(), und ElectricCar ist eine weitere Ebene tiefer in der Hierarchie und fügt neue Funktionen wie BatteryLevel und seinen eigenen Drive()** Durchführung. Diese Struktur zeigt, wie Abstraktion, Kapselung, Vererbung und Polymorphismus in einer C#-Anwendung zusammenwirken.

IronPDF: C# PDF-Bibliothek

IronPDF ist eine vielseitige Bibliothek für C#-Entwickler, die das Erstellen, Bearbeiten und Extrahieren von PDF-Dokumenten in .NET-Anwendungen vereinfacht. IronPDF bietet die Möglichkeit, auf einfache Weise pDFs aus HTML-Strings erzeugen, URLs oder ASPX-Dateien und bietet ein hohes Maß an Kontrolle über den Prozess der PDF-Erstellung und -Bearbeitung. Darüber hinaus unterstützt IronPDF erweiterte Funktionen wie das Hinzufügen von Kopf- und Fußzeilen, Wasserzeichen und Verschlüsselung und ist damit eine umfassende Lösung für die Handhabung von PDFs in .NET-Anwendungen.

Beispiel für IronPDF mit OOP

Hier ist ein vereinfachtes Beispiel, das die Verwendung von IronPDF in einer C#-Anwendung demonstriert, wobei das Schlüsselwort virtual verwendet wird, um zu veranschaulichen, wie man die IronPDF-Funktionalität durch Vererbung, ein Kernkonzept der OOP, erweitern kann. Nehmen wir an, wir haben eine Basisklasse, die einen einfachen PDF-Bericht erzeugt, und eine abgeleitete Klasse, die diese Funktionalität um eine benutzerdefinierte Kopfzeile erweitert:

using IronPdf;
public class BasicReportGenerator
{
    public virtual PdfDocument GenerateReport(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return pdf;
    }
}
public class CustomReportGenerator : BasicReportGenerator
{
    public override PdfDocument GenerateReport(string htmlContent)
    {
        var pdf = base.GenerateReport(htmlContent);
        AddCustomHeader(pdf, "Custom Report Header");
        return pdf;
    }
    private void AddCustomHeader(PdfDocument document, string headerContent)
    {
        // Create text header
        TextHeaderFooter textHeader = new TextHeaderFooter
        {
            CenterText = headerContent,
        };
        document.AddTextHeaders(textHeader);
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // HTML content for the report
        string htmlContent = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>";
        // Using BasicReportGenerator
        BasicReportGenerator basicReportGenerator = new BasicReportGenerator();
        var basicPdf = basicReportGenerator.GenerateReport(htmlContent);
        basicPdf.SaveAs("basic_report.pdf");
        // Using CustomReportGenerator
        CustomReportGenerator customReportGenerator = new CustomReportGenerator();
        var customPdf = customReportGenerator.GenerateReport(htmlContent);
        customPdf.SaveAs("custom_report.pdf");
        Console.WriteLine("PDF reports generated successfully.");
    }
}

using IronPdf;
public class BasicReportGenerator
{
    public virtual PdfDocument GenerateReport(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return pdf;
    }
}
public class CustomReportGenerator : BasicReportGenerator
{
    public override PdfDocument GenerateReport(string htmlContent)
    {
        var pdf = base.GenerateReport(htmlContent);
        AddCustomHeader(pdf, "Custom Report Header");
        return pdf;
    }
    private void AddCustomHeader(PdfDocument document, string headerContent)
    {
        // Create text header
        TextHeaderFooter textHeader = new TextHeaderFooter
        {
            CenterText = headerContent,
        };
        document.AddTextHeaders(textHeader);
    }
}
class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        // HTML content for the report
        string htmlContent = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>";
        // Using BasicReportGenerator
        BasicReportGenerator basicReportGenerator = new BasicReportGenerator();
        var basicPdf = basicReportGenerator.GenerateReport(htmlContent);
        basicPdf.SaveAs("basic_report.pdf");
        // Using CustomReportGenerator
        CustomReportGenerator customReportGenerator = new CustomReportGenerator();
        var customPdf = customReportGenerator.GenerateReport(htmlContent);
        customPdf.SaveAs("custom_report.pdf");
        Console.WriteLine("PDF reports generated successfully.");
    }
}

Imports IronPdf
Public Class BasicReportGenerator
	Public Overridable Function GenerateReport(ByVal htmlContent As String) As PdfDocument
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		Return pdf
	End Function
End Class
Public Class CustomReportGenerator
	Inherits BasicReportGenerator

	Public Overrides Function GenerateReport(ByVal htmlContent As String) As PdfDocument
		Dim pdf = MyBase.GenerateReport(htmlContent)
		AddCustomHeader(pdf, "Custom Report Header")
		Return pdf
	End Function
	Private Sub AddCustomHeader(ByVal document As PdfDocument, ByVal headerContent As String)
		' Create text header
		Dim textHeader As New TextHeaderFooter With {.CenterText = headerContent}
		document.AddTextHeaders(textHeader)
	End Sub
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		' HTML content for the report
		Dim htmlContent As String = "<html><body><h1>Sample Report</h1><p>This is a sample report content.</p></body></html>"
		' Using BasicReportGenerator
		Dim basicReportGenerator As New BasicReportGenerator()
		Dim basicPdf = basicReportGenerator.GenerateReport(htmlContent)
		basicPdf.SaveAs("basic_report.pdf")
		' Using CustomReportGenerator
		Dim customReportGenerator As New CustomReportGenerator()
		Dim customPdf = customReportGenerator.GenerateReport(htmlContent)
		customPdf.SaveAs("custom_report.pdf")
		Console.WriteLine("PDF reports generated successfully.")
	End Sub
End Class

In diesem Beispiel verfügt BasicReportGenerator über eine Methode GenerateReport, die HTML-Inhalt annimmt und mit IronPDF ein PDF-Dokument erzeugt. Die Klasse CustomReportGenerator, die von BasicReportGenerator erbt, überschreibt die Methode GenerateReport, um dem PDF-Dokument eine benutzerdefinierte Kopfzeile hinzuzufügen, nachdem es von der Basismethode erzeugt wurde. Hier ist der benutzerdefinierte Bericht, der mit dem Code erstellt wurde:

Schlussfolgerung

Durch das Verstehen und Anwenden der Grundprinzipien von OOP können Anfänger wichtige Schritte zur Beherrschung von C# und zur Entwicklung robuster Softwarelösungen machen. Vererbung und Polymorphismus ermöglichen die Wiederverwendung von Code und Flexibilität, so dass neue Klassen auf bestehenden Strukturen und Funktionen aufbauen können. Abstraktion und Kapselung stellen sicher, dass die Klassen nur das Nötigste nach außen hin offenlegen und die internen Abläufe privat und sicher vor unbeabsichtigter Verwendung bleiben. Sie können das IronPDF kostenloser Test, die ab $749 verfügbar ist.