Solid Principles C# (Jak to działa dla programistów)

1. Pięć zasad SOLID w języku C

2. Zastosowania zasad projektowania SOLID

using System;

// Abstract base class representing a shape
public abstract class Shape
{
    // Abstract method to be implemented by derived classes
    public abstract double Area();
}

// Derived class representing a circle
class Circle : Shape
{
    public double Radius { get; set; }

    // Override Area() method to calculate the area of a circle
    public override double Area() => Math.PI * Math.Pow(Radius, 2);
}

// Derived class representing a rectangle
class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    // Override Area() method to calculate the area of a rectangle
    public override double Area() => Width * Height;
}

// Class responsible for calculating the area of a shape
class AreaCalculator
{
    // Method to calculate the area of a given shape
    public double CalculateArea(Shape shape) => shape.Area();
}

// Interface for logging messages
interface ILogger 
{
    void Log(string message); // Interface segregation principle
}

// Implementation of ILogger that logs messages to the console
class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"Log: {message}");
}

// Implementation of ILogger that simulates logging messages to a file
class FileLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"File Log: {message}");
}

// Service to manage user-related tasks
class UserService
{
    private readonly ILogger logger;

    // Constructor injection for dependency inversion principle
    public UserService(ILogger logger) => this.logger = logger;

    public void CreateUser()
    {
        logger.Log("User created successfully");
    }
}

// Service to manage email-related tasks
class EmailService
{
    private readonly ILogger logger;

    // Constructor injection for dependency inversion principle
    public EmailService(ILogger logger) => this.logger = logger;

    public void SendEmail()
    {
        logger.Log("Email sent successfully");
    }
}

using System;

// Abstract base class representing a shape
public abstract class Shape
{
    // Abstract method to be implemented by derived classes
    public abstract double Area();
}

// Derived class representing a circle
class Circle : Shape
{
    public double Radius { get; set; }

    // Override Area() method to calculate the area of a circle
    public override double Area() => Math.PI * Math.Pow(Radius, 2);
}

// Derived class representing a rectangle
class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    // Override Area() method to calculate the area of a rectangle
    public override double Area() => Width * Height;
}

// Class responsible for calculating the area of a shape
class AreaCalculator
{
    // Method to calculate the area of a given shape
    public double CalculateArea(Shape shape) => shape.Area();
}

// Interface for logging messages
interface ILogger 
{
    void Log(string message); // Interface segregation principle
}

// Implementation of ILogger that logs messages to the console
class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"Log: {message}");
}

// Implementation of ILogger that simulates logging messages to a file
class FileLogger : ILogger
{
    public void Log(string message) => Console.WriteLine($"File Log: {message}");
}

// Service to manage user-related tasks
class UserService
{
    private readonly ILogger logger;

    // Constructor injection for dependency inversion principle
    public UserService(ILogger logger) => this.logger = logger;

    public void CreateUser()
    {
        logger.Log("User created successfully");
    }
}

// Service to manage email-related tasks
class EmailService
{
    private readonly ILogger logger;

    // Constructor injection for dependency inversion principle
    public EmailService(ILogger logger) => this.logger = logger;

    public void SendEmail()
    {
        logger.Log("Email sent successfully");
    }
}

Imports System

' Abstract base class representing a shape
Public MustInherit Class Shape
	' Abstract method to be implemented by derived classes
	Public MustOverride Function Area() As Double
End Class

' Derived class representing a circle
Friend Class Circle
	Inherits Shape

	Public Property Radius() As Double

	' Override Area() method to calculate the area of a circle
	Public Overrides Function Area() As Double
		Return Math.PI * Math.Pow(Radius, 2)
	End Function
End Class

' Derived class representing a rectangle
Friend Class Rectangle
	Inherits Shape

	Public Property Width() As Double
	Public Property Height() As Double

	' Override Area() method to calculate the area of a rectangle
	Public Overrides Function Area() As Double
		Return Width * Height
	End Function
End Class

' Class responsible for calculating the area of a shape
Friend Class AreaCalculator
	' Method to calculate the area of a given shape
	Public Function CalculateArea(ByVal shape As Shape) As Double
		Return shape.Area()
	End Function
End Class

' Interface for logging messages
Friend Interface ILogger
	Sub Log(ByVal message As String) ' Interface segregation principle
End Interface

' Implementation of ILogger that logs messages to the console
Friend Class ConsoleLogger
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		Console.WriteLine($"Log: {message}")
	End Sub
End Class

' Implementation of ILogger that simulates logging messages to a file
Friend Class FileLogger
	Implements ILogger

	Public Sub Log(ByVal message As String) Implements ILogger.Log
		Console.WriteLine($"File Log: {message}")
	End Sub
End Class

' Service to manage user-related tasks
Friend Class UserService
	Private ReadOnly logger As ILogger

	' Constructor injection for dependency inversion principle
	Public Sub New(ByVal logger As ILogger)
		Me.logger = logger
	End Sub

	Public Sub CreateUser()
		logger.Log("User created successfully")
	End Sub
End Class

' Service to manage email-related tasks
Friend Class EmailService
	Private ReadOnly logger As ILogger

	' Constructor injection for dependency inversion principle
	Public Sub New(ByVal logger As ILogger)
		Me.logger = logger
	End Sub

	Public Sub SendEmail()
		logger.Log("Email sent successfully")
	End Sub
End Class

3. Stosowanie zasad SOLID w IronPDF

Skoro omówiliśmy już zasady SOLID w teorii, przejdźmy do ich praktycznego zastosowania w języku C# przy użyciu IronPDF, popularnej biblioteki do pracy z plikami PDF. IronPDF pozwala programistom na płynne tworzenie, edycję i przetwarzanie dokumentów PDF w języku C#. Dzięki zastosowaniu zasad SOLID możemy zapewnić, że nasz kod pozostanie modułowy, rozszerzalny i łatwy w utrzymaniu.

IronPDF wyróżnia się w konwersji HTML do PDF, zapewniając precyzyjne zachowanie oryginalnych układów i stylów. Idealnie nadaje się do tworzenia plików PDF z treści internetowych, takich jak raporty, faktury i dokumentacja. Dzięki obsłudze plików HTML, adresów URL i surowych ciągów znaków HTML, IronPDF z łatwością tworzy wysokiej jakości dokumenty PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Należy uwzględnić zasadę pojedynczej odpowiedzialności. Podczas pracy z IronPDF warto korzystać z klas obsługujących konkretne aspekty generowania lub manipulacji plikami PDF. Na przykład jedna klasa może tworzyć dokumenty PDF, podczas gdy inna skupia się na dodawaniu i formatowaniu treści.

Zasada otwartości/zamknięcia zachęca nas do projektowania klas związanych z PDF z myślą o rozszerzeniach. Zamiast modyfikować istniejące klasy w celu dostosowania ich do nowych funkcji, możemy tworzyć klasy, które rozszerzają lub implementują istniejące interfejsy. W ten sposób przestrzegamy tej zasady bez uszczerbku dla istniejącej funkcjonalności.

Zasada substytucji Liskov ma zastosowanie w przypadku różnych typów elementów PDF. Niezależnie od tego, czy chodzi o tekst, obrazy czy adnotacje, projektowanie klas zgodnych ze wspólnym interfejsem pozwala na płynną zamianę i zwiększa elastyczność naszego kodu generującego pliki PDF. Zasada segregacji interfejsów ma zasadnicze znaczenie przy definiowaniu kontraktów dla klas, które współdziałają z IronPDF. Tworząc małe, konkretne interfejsy dostosowane do potrzeb różnych komponentów, unikamy niepotrzebnych zależności i zapewniamy, że klasy implementują tylko te metody, których potrzebują.

Wreszcie, zastosowanie zasady odwrócenia zależności może poprawić testowalność i łatwość utrzymania naszego kodu. Wprowadzając zależności zamiast ich sztywnego kodowania, tworzymy system o luźniejszym powiązaniu, który jest łatwiejszy do aktualizacji i rozbudowy.

Zilustrujmy te koncepcje prostym przykładem kodu wykorzystującym IronPDF:

using IronPdf;
using System;

// Interface for PDF creation
public interface IPdfCreator
{
    void CreatePdf(string filePath, string content);
}

// Concrete implementation using IronPDF
public class IronPdfCreator : IPdfCreator
{    
    public void CreatePdf(string filePath, string content)
    {
        // IronPDF-specific code for creating a PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs(filePath);
    }
}

// Service adhering to Single Responsibility Principle
public class PdfGenerationService
{
    private readonly IPdfCreator pdfCreator;

    public PdfGenerationService(IPdfCreator pdfCreator)
    {
        this.pdfCreator = pdfCreator;
    }

    public void GeneratePdfDocument(string filePath)
    {
        // Business logic for generating content
        string content = "<p>This PDF is generated using IronPDF and follows SOLID principles.</p>";
        // Delegate the PDF creation to the injected dependency
        pdfCreator.CreatePdf(filePath, content);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}

class Program
{
    static void Main()
    {
        // Dependency injection using the Dependency Inversion Principle
        IPdfCreator ironPdfCreator = new IronPdfCreator();
        PdfGenerationService pdfService = new PdfGenerationService(ironPdfCreator);
        // Generate PDF using the service
        string pdfFilePath = "output.pdf";
        pdfService.GeneratePdfDocument(pdfFilePath);
        Console.ReadLine(); // To prevent the console window from closing immediately
    }
}

using IronPdf;
using System;

// Interface for PDF creation
public interface IPdfCreator
{
    void CreatePdf(string filePath, string content);
}

// Concrete implementation using IronPDF
public class IronPdfCreator : IPdfCreator
{    
    public void CreatePdf(string filePath, string content)
    {
        // IronPDF-specific code for creating a PDF
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs(filePath);
    }
}

// Service adhering to Single Responsibility Principle
public class PdfGenerationService
{
    private readonly IPdfCreator pdfCreator;

    public PdfGenerationService(IPdfCreator pdfCreator)
    {
        this.pdfCreator = pdfCreator;
    }

    public void GeneratePdfDocument(string filePath)
    {
        // Business logic for generating content
        string content = "<p>This PDF is generated using IronPDF and follows SOLID principles.</p>";
        // Delegate the PDF creation to the injected dependency
        pdfCreator.CreatePdf(filePath, content);
        Console.WriteLine($"PDF generated successfully at {filePath}");
    }
}

class Program
{
    static void Main()
    {
        // Dependency injection using the Dependency Inversion Principle
        IPdfCreator ironPdfCreator = new IronPdfCreator();
        PdfGenerationService pdfService = new PdfGenerationService(ironPdfCreator);
        // Generate PDF using the service
        string pdfFilePath = "output.pdf";
        pdfService.GeneratePdfDocument(pdfFilePath);
        Console.ReadLine(); // To prevent the console window from closing immediately
    }
}

Imports IronPdf
Imports System

' Interface for PDF creation
Public Interface IPdfCreator
	Sub CreatePdf(ByVal filePath As String, ByVal content As String)
End Interface

' Concrete implementation using IronPDF
Public Class IronPdfCreator
	Implements IPdfCreator

	Public Sub CreatePdf(ByVal filePath As String, ByVal content As String) Implements IPdfCreator.CreatePdf
		' IronPDF-specific code for creating a PDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(content)
		pdf.SaveAs(filePath)
	End Sub
End Class

' Service adhering to Single Responsibility Principle
Public Class PdfGenerationService
	Private ReadOnly pdfCreator As IPdfCreator

	Public Sub New(ByVal pdfCreator As IPdfCreator)
		Me.pdfCreator = pdfCreator
	End Sub

	Public Sub GeneratePdfDocument(ByVal filePath As String)
		' Business logic for generating content
		Dim content As String = "<p>This PDF is generated using IronPDF and follows SOLID principles.</p>"
		' Delegate the PDF creation to the injected dependency
		pdfCreator.CreatePdf(filePath, content)
		Console.WriteLine($"PDF generated successfully at {filePath}")
	End Sub
End Class

Friend Class Program
	Shared Sub Main()
		' Dependency injection using the Dependency Inversion Principle
		Dim ironPdfCreator As IPdfCreator = New IronPdfCreator()
		Dim pdfService As New PdfGenerationService(ironPdfCreator)
		' Generate PDF using the service
		Dim pdfFilePath As String = "output.pdf"
		pdfService.GeneratePdfDocument(pdfFilePath)
		Console.ReadLine() ' To prevent the console window from closing immediately
	End Sub
End Class

1. Interfejs IPdfCreator: Definiuje umowę dotyczącą tworzenia plików PDF, przestrzegając zasady pojedynczej odpowiedzialności poprzez skupienie się na jednym zadaniu.
2. Klasa IronPdfCreator: Implementuje interfejs IPdfCreator przy użyciu biblioteki IronPDF w celu tworzenia plików PDF. Ta klasa zawiera logikę specyficzną dla tworzenia plików PDF.
3. Klasa PdfGenerationService: Reprezentuje usługę odpowiedzialną za generowanie plików PDF. Jest zgodny z zasadą pojedynczej odpowiedzialności, obsługując logikę biznesową generowania treści i delegując tworzenie plików PDF do wstrzykniętego IPdfCreator.
4. Klasa programu (Main): Pokazuje wykorzystanie usługi i wstrzykniętej zależności, zgodnie z zasadą odwrócenia zależności poprzez poleganie na abstrakcjach (interfejsach) zamiast na konkretnych implementacjach.

Aby uruchomić ten kod, upewnij się, że w swoim projekcie zainstalowałeś bibliotekę IronPDF. Można to zrobić za pomocą menedżera pakietów NuGet:

Install-Package IronPdf

Zastąp treść i logikę w klasie PdfGenerationService zgodnie z własnymi wymaganiami.

4. Podsumowanie

Podsumowując, zasady SOLID stanowią solidną podstawę do projektowania łatwego w utrzymaniu i skalowalnego oprogramowania w języku C#. Dzięki zrozumieniu i zastosowaniu tych zasad programiści mogą tworzyć kod bardziej modułowy, łatwiej dostosowujący się do zmian i łatwiejszy do testowania.

Podczas pracy z bibliotekami takimi jak IronPDF integracja zasad SOLID staje się jeszcze ważniejsza. Projektowanie klas zgodnych z tymi zasadami gwarantuje, że kod pozostanie elastyczny i będzie mógł ewoluować wraz ze zmieniającymi się wymaganiami zadań związanych z plikami PDF.

Kontynuując tworzenie aplikacji w języku C#, pamiętaj o zasadach SOLID jako wytycznych dotyczących pisania kodu, który przetrwa próbę czasu. Niezależnie od tego, czy pracujesz nad generowaniem plików PDF, interakcjami z bazami danych, czy jakimkolwiek innym aspektem tworzenia oprogramowania, zasady SOLID stanowią plan działania pozwalający na tworzenie funkcjonalnego i łatwego w utrzymaniu kodu w dłuższej perspektywie.

Aby dowiedzieć się więcej o bibliotece IronPDF, odwiedź dokumentację IronPDF. Aby dowiedzieć się więcej o licencji i uzyskać bezpłatną wersję próbną, odwiedź stronę licencyjną IronPDF.