Klasa Sealed w języku C# (jak działa dla programistów)

Czym są klasy typu Sealed i metody typu Sealed?

Klasa zamknięta: W języku C# klasa zamknięta to klasa, której nie można dziedziczyć. Używając słowa kluczowego sealed, programiści mogą uniemożliwić innym klasom dziedziczenie lub rozszerzanie klasy zamkniętej. To celowe ograniczenie gwarantuje, że klasa typu sealed nie może być używana jako klasa bazowa dla żadnej innej klasy, co ogranicza zakres hierarchii dziedziczenia. Klasy zamknięte są często stosowane, gdy programista chce kontrolować i sfinalizować strukturę klasy, zapobiegając niezamierzonym modyfikacjom poprzez dziedziczenie.

Rozważmy następujący przykład:

public sealed class Animal
{
    public string Species { get; set; }

    public void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

// The following code will cause a compilation error because 'Animal' is sealed and cannot be inherited:
// public class Dog : Animal // Error: Cannot inherit from sealed class 'Animal'
// {
// }

public sealed class Animal
{
    public string Species { get; set; }

    public void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

// The following code will cause a compilation error because 'Animal' is sealed and cannot be inherited:
// public class Dog : Animal // Error: Cannot inherit from sealed class 'Animal'
// {
// }

Public NotInheritable Class Animal
	Public Property Species() As String

	Public Sub MakeSound()
		Console.WriteLine("Generic animal sound")
	End Sub
End Class

' The following code will cause a compilation error because 'Animal' is sealed and cannot be inherited:
' public class Dog : Animal // Error: Cannot inherit from sealed class 'Animal'
' {
' }

W przeciwieństwie do struktur, które są domyślnie zapieczętowane, klasa zapieczętowana musi zostać zadeklarowana przy użyciu słowa kluczowego sealed, jak pokazano powyżej. W tym przykładzie klasa Animal jest zadeklarowana jako sealed, co uniemożliwia dziedziczenie z niej przez jakąkolwiek inną klasę.

Metoda zapieczętowana: Oprócz zapieczętowywania całych klas, C# pozwala programistom na zapieczętowanie poszczególnych metod w ramach klasy. Metoda zamknięta to metoda, której żadna klasa pochodna nie może nadpisać. Gwarantuje to, że zachowanie metody pozostaje spójne we wszystkich podklasach, zapewniając pewien poziom przewidywalności w logice aplikacji.

Aby zablokować metodę, użyj modyfikatora sealed:

public class Animal
{
    public string Species { get; set; }

    // A virtual method allows derived classes to override it.
    public virtual void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

public class Dog : Animal
{
    // The sealed override prevents further overriding of this method.
    public sealed override void MakeSound()
    {
        Console.WriteLine("Bark!");
    }
}

public class Animal
{
    public string Species { get; set; }

    // A virtual method allows derived classes to override it.
    public virtual void MakeSound()
    {
        Console.WriteLine("Generic animal sound");
    }
}

public class Dog : Animal
{
    // The sealed override prevents further overriding of this method.
    public sealed override void MakeSound()
    {
        Console.WriteLine("Bark!");
    }
}

Public Class Animal
	Public Property Species() As String

	' A virtual method allows derived classes to override it.
	Public Overridable Sub MakeSound()
		Console.WriteLine("Generic animal sound")
	End Sub
End Class

Public Class Dog
	Inherits Animal

	' The sealed override prevents further overriding of this method.
	Public NotOverridable Overrides Sub MakeSound()
		Console.WriteLine("Bark!")
	End Sub
End Class

Słowo kluczowe virtual pozwala na nadpisanie metody w klasach pochodnych, natomiast słowo kluczowe sealed uniemożliwia dalsze nadpisywanie wirtualnej metody klasy bazowej w kolejnych podklasach.

Klasy typu Sealed i elementy składowe klas: Klasy typu Sealed mogą również zawierać elementy składowe typu Sealed, takie jak właściwości, metody i zdarzenia. To połączenie klasy typu sealed i elementów typu sealed zapewnia wysoki stopień kontroli nad zachowaniem i strukturą klasy.

Rozważmy następujący przykład:

public sealed class ControlledClass
{
    // A sealed property that prevents overriding.
    public sealed string ControlledProperty { get; set; }

    // A method that cannot be redefined by derived classes.
    public virtual sealed void ControlledMethod()
    {
        // Method implementation
        Console.WriteLine("Executing controlled method.");
    }

    // A sealed event that cannot be subscribed to or raised by derived classes.
    public sealed event EventHandler ControlledEvent;

    // Sealed indexers, if applicable
    public sealed string this[int index]
    {
        get { return "Value"; }
        set 
        { 
            // Setter implementation 
        }
    }
}

public sealed class ControlledClass
{
    // A sealed property that prevents overriding.
    public sealed string ControlledProperty { get; set; }

    // A method that cannot be redefined by derived classes.
    public virtual sealed void ControlledMethod()
    {
        // Method implementation
        Console.WriteLine("Executing controlled method.");
    }

    // A sealed event that cannot be subscribed to or raised by derived classes.
    public sealed event EventHandler ControlledEvent;

    // Sealed indexers, if applicable
    public sealed string this[int index]
    {
        get { return "Value"; }
        set 
        { 
            // Setter implementation 
        }
    }
}

Public NotInheritable Class ControlledClass
	' A sealed property that prevents overriding.
	Public NotOverridable Property ControlledProperty() As String

	' A method that cannot be redefined by derived classes.
	Public Overridable NotOverridable Sub ControlledMethod()
		' Method implementation
		Console.WriteLine("Executing controlled method.")
	End Sub

	' A sealed event that cannot be subscribed to or raised by derived classes.
	Public Event ControlledEvent As EventHandler

	' Sealed indexers, if applicable
	Default Public NotOverridable Property Item(ByVal index As Integer) As String
		Get
			Return "Value"
		End Get
		Set(ByVal value As String)
			' Setter implementation 
		End Set
	End Property
End Class

W tym przykładzie każdy aspekt ControlledClass jest zapieczętowany – właściwość, metoda, zdarzenie, a nawet indeksator, jeśli ma to zastosowanie. Ten poziom uszczelnienia zapewnia solidną i niezmienną strukturę, idealną w sytuacjach, w których projekt klasy powinien pozostać niezmienny.

Uzasadnienie klasy Sealed

Bezpieczeństwo kodu: Klasy zamknięte przyczyniają się do bezpieczeństwa kodu, zapobiegając nieautoryzowanemu dostępowi i modyfikacjom. Gdy klasa jest typu sealed, pełni rolę zamkniętej jednostki o ściśle zdefiniowanym interfejsie i zachowaniu. Ta enkapsulacja minimalizuje ryzyko niezamierzonych skutków ubocznych lub zmian, które mogłyby potencjalnie zagrozić stabilności i bezpieczeństwu kodu źródłowego.

Spójność projektu: W większych bazach kodu lub frameworkach zachowanie spójności projektu ma ogromne znaczenie. Klasa zamknięta pełni rolę podstawowego elementu konstrukcyjnego o stałej strukturze, co zmniejsza ryzyko niezamierzonych modyfikacji. Jest to szczególnie przydatne w sytuacjach, gdy klasa stanowi podstawowy komponent systemu, a jej zachowanie powinno być spójne w różnych modułach.

Najlepsze praktyki dotyczące korzystania z klasy Sealed

1. Oszczędnie korzystaj z klas typu sealed: Chociaż klasy typu sealed oferują korzyści, należy je stosować rozważnie. Nadmierne używanie klas zamkniętych może prowadzić do powstania sztywnego i trudniejszego w utrzymaniu kodu.
2. Cel dokumentacji: Podczas uszczelniania klasy lub metody kluczowe znaczenie ma udokumentówanie intencji stojącej za tą decyzją. Wyjaśnij, dlaczego dana klasa jest typu sealed i jakie względy projektowe doprowadziły do tego wyboru.
3. Weź pod uwagę przyszłą rozszerzalność: Przed zamknięciem klasy zastanów się, czy przyszłe wymagania mogą wymagać rozszerzalności. Jeśli istnieje prawdopodobieństwo, że klasa będzie musiała zostać rozszerzona, jej uszczelnienie może utrudnić przyszły rozwój.
4. Użyj metod zamkniętych dla stabilności: Zamknięcie metod może być korzystne, gdy podstawowe zachowanie metody powinno pozostać stabilne w różnych podklasach. Może to zwiększyć przewidywalność kodu.
5. Nie może być również abstrakcyjna: klasa typu sealed/metody typu sealed nie mogą być jednocześnie klasą abstrakcyjną/metodami abstrakcyjnymi, ponieważ klasy abstrakcyjne są zaprojektowane tak, aby mogły być dziedziczone przez inne klasy, podczas gdy klasy typu sealed ograniczają dziedziczenie.

Przedstawiamy IronPDF

IronPDF to biblioteka PDF w języku C# firmy Iron Software, będąca nowoczesnym generatorem i czytnikiem plików PDF.

Instalacja

IronPDF można zainstalować za pomocą konsoli NuGet Package Manager lub menedżera pakietów Visual Studio. Poniżej znajduje się polecenie dla konsoli:

Install-Package IronPdf

Aby zainstalować IronPDF za pomocą menedżera pakietów NuGet, wpisz "IronPdf" w pasku wyszukiwania menedżera pakietów NuGet.

namespace OrderBy
{
    public class Program
    {
        static void Main()
        {
            Console.WriteLine("Demo Sealed Class and IronPdf");
            var dog = new Dog();
            dog.MakeSound();
            dog.Print();
        }
    }

    // Base class
    public class Animal
    {
        public string Species { get; set; }

        public virtual void MakeSound()
        {
            Console.WriteLine("Generic animal sound");
        }

        public virtual void Print()
        {
            Console.WriteLine("Generic animal Print");
        }
    }

    public class Dog : Animal
    {
        // Sealed override ensures method cannot be overridden in further derived classes.
        public sealed override void MakeSound()
        {
            Console.WriteLine("Bark!");
        }

        public sealed override void Print()
        {
            var pdfRenderer = new ChromePdfRenderer();
            string content = @"
            <!DOCTYPE html>
            <html>
            <body>
                <h1>Hello, Dog!</h1>
                <p>This is Print from Derived class.</p>
                <p>Print Animal Dog</p>
                <p>Print Animal Sound: Bark</p>
            </body>
            </html>";

            pdfRenderer.RenderHtmlAsPdf(content).SaveAs("dog.pdf");
        }
    }
}

namespace OrderBy
{
    public class Program
    {
        static void Main()
        {
            Console.WriteLine("Demo Sealed Class and IronPdf");
            var dog = new Dog();
            dog.MakeSound();
            dog.Print();
        }
    }

    // Base class
    public class Animal
    {
        public string Species { get; set; }

        public virtual void MakeSound()
        {
            Console.WriteLine("Generic animal sound");
        }

        public virtual void Print()
        {
            Console.WriteLine("Generic animal Print");
        }
    }

    public class Dog : Animal
    {
        // Sealed override ensures method cannot be overridden in further derived classes.
        public sealed override void MakeSound()
        {
            Console.WriteLine("Bark!");
        }

        public sealed override void Print()
        {
            var pdfRenderer = new ChromePdfRenderer();
            string content = @"
            <!DOCTYPE html>
            <html>
            <body>
                <h1>Hello, Dog!</h1>
                <p>This is Print from Derived class.</p>
                <p>Print Animal Dog</p>
                <p>Print Animal Sound: Bark</p>
            </body>
            </html>";

            pdfRenderer.RenderHtmlAsPdf(content).SaveAs("dog.pdf");
        }
    }
}

Namespace OrderBy
	Public Class Program
		Shared Sub Main()
			Console.WriteLine("Demo Sealed Class and IronPdf")
			Dim dog As New Dog()
			dog.MakeSound()
			dog.Print()
		End Sub
	End Class

	' Base class
	Public Class Animal
		Public Property Species() As String

		Public Overridable Sub MakeSound()
			Console.WriteLine("Generic animal sound")
		End Sub

		Public Overridable Sub Print()
			Console.WriteLine("Generic animal Print")
		End Sub
	End Class

	Public Class Dog
		Inherits Animal

		' Sealed override ensures method cannot be overridden in further derived classes.
		Public NotOverridable Overrides Sub MakeSound()
			Console.WriteLine("Bark!")
		End Sub

		Public NotOverridable Overrides Sub Print()
			Dim pdfRenderer = New ChromePdfRenderer()
			Dim content As String = "
            <!DOCTYPE html>
            <html>
            <body>
                <h1>Hello, Dog!</h1>
                <p>This is Print from Derived class.</p>
                <p>Print Animal Dog</p>
                <p>Print Animal Sound: Bark</p>
            </body>
            </html>"

			pdfRenderer.RenderHtmlAsPdf(content).SaveAs("dog.pdf")
		End Sub
	End Class
End Namespace

{
    "IronPdf.LicenseKey": "your license key"
}

Wnioski

Klasy typu sealed w języku C# oferują programistom potężny mechanizm kontroli hierarchii dziedziczenia i zapewniają, że określone klasy i ich elementy składowe nie mogą być rozszerzane ani nadpisywane. Chociaż należy ostrożnie rozważać stosowanie klas zamkniętych, stanowią one skuteczny sposób na hermetyzację funkcjonalności i zapobieganie niezamierzonym modyfikacjom. Dzięki zrozumieniu koncepcji klas i metod zamkniętych programiści mogą podejmować świadome decyzje dotyczące tego, kiedy i gdzie zastosować to ograniczenie, przyczyniając się do tworzenia łatwych w utrzymaniu, bezpiecznych i przewidywalnych systemów oprogramowania. Wraz z IronPDF możemy również drukować dokumenty PDF.