Naucz się C#

Zrozumienie klasy abstrakcyjnej w C#

Tim Corey

19m 59s

Klasy abstrakcyjne w C# to fundamentalna koncepcja, która często budzi pytania wśród programistów. W swoim filmie, "C# Abstract Classes - What They Are, How to Use Them, and Best Practices", Tim Corey zagłębia się w to, czym są klasy abstrakcyjne, jak ich używać oraz jakie są najlepsze praktyki. Ten artykuł podsumowuje kluczowe punkty z jego filmu, wykorzystując znaczniki czasowe jako odniesienie.

Wprowadzenie

Tim (0:00) wyjaśnia, że klasy abstrakcyjne są często poddawane w wątpliwość pod względem ich celu, funkcjonalności i znaczenia. Opisuje klasę abstrakcyjną jako połączenie pełnej klasy bazowej i interfejsu, umieszczonego pomiędzy nimi pod względem funkcjonalności.

Demonstracja aplikacji - przewodnik

O godzinie (0:59) Tim przedstawia aplikację demo do pokazania klas abstrakcyjnych. Aplikacja obejmuje aplikację konsolową i bibliotekę klas z dwiema klasami dostępu do danych, które symulują operacje na bazie danych. Te klasy mają metody ładowania i zapisywania danych, których Tim używa do zilustrowania podobieństw i różnic między klasami abstrakcyjnymi, klasami bazowymi i interfejsami.

Oto początkowy kod dla klasy bazowej i klas pochodnych:

// Base Class Definition
public class DataAccess
{
    // Method to load the connection string
    public string LoadConnectionString()
    {
        Console.WriteLine("Loading the connection string...");
        return "Test Connection String";
    }

    // Method to load data
    public void LoadData()
    {
        Console.WriteLine("Loading data...");
    }

    // Method to save data
    public void SaveData()
    {
        Console.WriteLine("Saving data...");
    }
}

// Derived class that inherits from DataAccess
public class SQLDataAccess : DataAccess
{
    // Overriding LoadData method to specify SQL data loading
    public new void LoadData()
    {
        Console.WriteLine("Loading SQL data...");
    }

    // Overriding SaveData method to specify SQL data saving
    public new void SaveData()
    {
        Console.WriteLine("Saving SQL data...");
    }
}

// Derived class that inherits from DataAccess
public class SQLiteDataAccess : DataAccess
{
    // Overriding LoadData method to specify SQLite data loading
    public new void LoadData()
    {
        Console.WriteLine("Loading SQLite data...");
    }

    // Overriding SaveData method to specify SQLite data saving
    public new void SaveData()
    {
        Console.WriteLine("Saving SQLite data...");
    }
}

// Base Class Definition
public class DataAccess
{
    // Method to load the connection string
    public string LoadConnectionString()
    {
        Console.WriteLine("Loading the connection string...");
        return "Test Connection String";
    }

    // Method to load data
    public void LoadData()
    {
        Console.WriteLine("Loading data...");
    }

    // Method to save data
    public void SaveData()
    {
        Console.WriteLine("Saving data...");
    }
}

// Derived class that inherits from DataAccess
public class SQLDataAccess : DataAccess
{
    // Overriding LoadData method to specify SQL data loading
    public new void LoadData()
    {
        Console.WriteLine("Loading SQL data...");
    }

    // Overriding SaveData method to specify SQL data saving
    public new void SaveData()
    {
        Console.WriteLine("Saving SQL data...");
    }
}

// Derived class that inherits from DataAccess
public class SQLiteDataAccess : DataAccess
{
    // Overriding LoadData method to specify SQLite data loading
    public new void LoadData()
    {
        Console.WriteLine("Loading SQLite data...");
    }

    // Overriding SaveData method to specify SQLite data saving
    public new void SaveData()
    {
        Console.WriteLine("Saving SQLite data...");
    }
}

' Base Class Definition
Public Class DataAccess
    ' Method to load the connection string
    Public Function LoadConnectionString() As String
        Console.WriteLine("Loading the connection string...")
        Return "Test Connection String"
    End Function

    ' Method to load data
    Public Sub LoadData()
        Console.WriteLine("Loading data...")
    End Sub

    ' Method to save data
    Public Sub SaveData()
        Console.WriteLine("Saving data...")
    End Sub
End Class

' Derived class that inherits from DataAccess
Public Class SQLDataAccess
    Inherits DataAccess

    ' Overriding LoadData method to specify SQL data loading
    Public Shadows Sub LoadData()
        Console.WriteLine("Loading SQL data...")
    End Sub

    ' Overriding SaveData method to specify SQL data saving
    Public Shadows Sub SaveData()
        Console.WriteLine("Saving SQL data...")
    End Sub
End Class

' Derived class that inherits from DataAccess
Public Class SQLiteDataAccess
    Inherits DataAccess

    ' Overriding LoadData method to specify SQLite data loading
    Public Shadows Sub LoadData()
        Console.WriteLine("Loading SQLite data...")
    End Sub

    ' Overriding SaveData method to specify SQLite data saving
    Public Shadows Sub SaveData()
        Console.WriteLine("Saving SQLite data...")
    End Sub
End Class

' Base Class Definition
Public Class DataAccess
    ' Method to load the connection string
    Public Function LoadConnectionString() As String
        Console.WriteLine("Loading the connection string...")
        Return "Test Connection String"
    End Function

    ' Method to load data
    Public Sub LoadData()
        Console.WriteLine("Loading data...")
    End Sub

    ' Method to save data
    Public Sub SaveData()
        Console.WriteLine("Saving data...")
    End Sub
End Class

' Derived class that inherits from DataAccess
Public Class SQLDataAccess
    Inherits DataAccess

    ' Overriding LoadData method to specify SQL data loading
    Public Shadows Sub LoadData()
        Console.WriteLine("Loading SQL data...")
    End Sub

    ' Overriding SaveData method to specify SQL data saving
    Public Shadows Sub SaveData()
        Console.WriteLine("Saving SQL data...")
    End Sub
End Class

' Derived class that inherits from DataAccess
Public Class SQLiteDataAccess
    Inherits DataAccess

    ' Overriding LoadData method to specify SQLite data loading
    Public Shadows Sub LoadData()
        Console.WriteLine("Loading SQLite data...")
    End Sub

    ' Overriding SaveData method to specify SQLite data saving
    Public Shadows Sub SaveData()
        Console.WriteLine("Saving SQLite data...")
    End Sub
End Class

Tworzenie klasy bazowej

Tim wyjaśnia o 3:21 jak stworzyć klasę bazową. Refaktoryzuje kod, aby przeniesc wspolne metody, takie jak LoadConnectionString, do klasy bazowej o nazwie DataAccess. Dziedzicząc z tej klasy bazowej, inne klasy, takie jak SQLDataAccess i SQLiteDataAccess, uzyskują dostęp do tych wspólnych metod, zmniejszając powielanie kodu.

Uczynienie klasy bazowej abstrakcyjną

Tim o 5:56 przechodzi od klasy bazowej do klasy abstrakcyjnej, aby pokazać różnice. Zmienia DataAccess na klase abstrakcyjna, aby nie mozna bylo jej bezposrednio instancjonowac. Zamiast tego, tylko klasy dziedziczace z tej klasy abstrakcyjnej, takie jak SQLiteDataAccess i SQLDataAccess, moga implementowac jej metody i korzystac z jej wspolnej funkcjonalnosci.

Oto jak zmienia sie kod, gdy DataAccess staje sie klasa abstrakcyjna:

// Abstract Base Class Definition
public abstract class AbstractDataAccess
{
    // Shared method to load connection string
    public string LoadConnectionString()
    {
        Console.WriteLine("Loading the connection string...");
        return "Test Connection String";
    }

    // Abstract methods that must be implemented by derived classes
    public abstract void LoadData();
    public abstract void SaveData();
}

// Abstract Base Class Definition
public abstract class AbstractDataAccess
{
    // Shared method to load connection string
    public string LoadConnectionString()
    {
        Console.WriteLine("Loading the connection string...");
        return "Test Connection String";
    }

    // Abstract methods that must be implemented by derived classes
    public abstract void LoadData();
    public abstract void SaveData();
}

' Abstract Base Class Definition
Public MustInherit Class AbstractDataAccess
    ' Shared method to load connection string
    Public Function LoadConnectionString() As String
        Console.WriteLine("Loading the connection string...")
        Return "Test Connection String"
    End Function

    ' Abstract methods that must be implemented by derived classes
    Public MustOverride Sub LoadData()
    Public MustOverride Sub SaveData()
End Class

' Abstract Base Class Definition
Public MustInherit Class AbstractDataAccess
    ' Shared method to load connection string
    Public Function LoadConnectionString() As String
        Console.WriteLine("Loading the connection string...")
        Return "Test Connection String"
    End Function

    ' Abstract methods that must be implemented by derived classes
    Public MustOverride Sub LoadData()
    Public MustOverride Sub SaveData()
End Class

Część interfejsu w klasie abstrakcyjnej

Tim o 8:34 wyjaśnia, jak klasy abstrakcyjne łączą funkcje interfejsów i klas bazowych. Deklaruje metody abstrakcyjne w ramach klasy abstrakcyjnej, takie jak public abstract void LoadData(); i public abstract void SaveData();, nie implementujac ich. Zapewnia to, że dowolna klasa pochodna musi implementować te metody, podobnie jak działają interfejsy.

Nadpisywanie metod w klasach abstrakcyjnych

Tim o 12:56 omawia, jak nadpisywać metody w klasie abstrakcyjnej. Pokazuje, że można zadeklarować metodę w klasie bazowej jako virtual, pozwalając klasom pochodnym na jej przesłonięcie. To podejście zapewnia elastyczność w sposobie implementacji i rozszerzania metod w klasach pochodnych.

Oto kod klasy pochodnej pokazujący nadpisywanie metod:

// Derived class from abstract base class
public class SQLDataAccessWithAbstract : AbstractDataAccess
{
    // Implementing the abstract LoadData method
    public override void LoadData()
    {
        Console.WriteLine("Loading SQL data...");
    }

    // Implementing the abstract SaveData method
    public override void SaveData()
    {
        Console.WriteLine("Saving SQL data...");
    }
}

// Derived class from abstract base class
public class SQLDataAccessWithAbstract : AbstractDataAccess
{
    // Implementing the abstract LoadData method
    public override void LoadData()
    {
        Console.WriteLine("Loading SQL data...");
    }

    // Implementing the abstract SaveData method
    public override void SaveData()
    {
        Console.WriteLine("Saving SQL data...");
    }
}

' Derived class from abstract base class
Public Class SQLDataAccessWithAbstract
    Inherits AbstractDataAccess

    ' Implementing the abstract LoadData method
    Public Overrides Sub LoadData()
        Console.WriteLine("Loading SQL data...")
    End Sub

    ' Implementing the abstract SaveData method
    Public Overrides Sub SaveData()
        Console.WriteLine("Saving SQL data...")
    End Sub
End Class

' Derived class from abstract base class
Public Class SQLDataAccessWithAbstract
    Inherits AbstractDataAccess

    ' Implementing the abstract LoadData method
    Public Overrides Sub LoadData()
        Console.WriteLine("Loading SQL data...")
    End Sub

    ' Implementing the abstract SaveData method
    Public Overrides Sub SaveData()
        Console.WriteLine("Saving SQL data...")
    End Sub
End Class

Kiedy używać klas abstrakcyjnych

Tim o 16:01 radzi, że klas abstrakcyjnych nie należy używać codziennie, ale są wartościowe w określonych scenariuszach. Zwraca uwagę, aby nie używać klas abstrakcyjnych tylko dlatego, że dwie klasy dzielą podobny kod. Zamiast tego podkreśla utrzymanie relacji "jest" i sugeruje rozważenie metod pomocniczych lub klas dla wspólnego kodu, gdy jest to właściwe.

Oto główny kod programu demonstrujący użycie:

// Main Program
class Program
{
    static void Main(string[] args)
    {
        // Using Base Class
        SQLDataAccess sqlData = new SQLDataAccess();
        Console.WriteLine(sqlData.LoadConnectionString());
        sqlData.LoadData();
        sqlData.SaveData();

        Console.WriteLine("--------------------------");

        // Using Derived Class from Abstract Base Class
        SQLDataAccessWithAbstract sqlDataAbstract = new SQLDataAccessWithAbstract();
        Console.WriteLine(sqlDataAbstract.LoadConnectionString());
        sqlDataAbstract.LoadData();
        sqlDataAbstract.SaveData();

        Console.WriteLine("--------------------------");

        // You can't instantiate Abstract Base Class directly
        // AbstractDataAccess abstractData = new AbstractDataAccess(); 
        // Error: Cannot create an instance of the abstract class
    }
}

// Main Program
class Program
{
    static void Main(string[] args)
    {
        // Using Base Class
        SQLDataAccess sqlData = new SQLDataAccess();
        Console.WriteLine(sqlData.LoadConnectionString());
        sqlData.LoadData();
        sqlData.SaveData();

        Console.WriteLine("--------------------------");

        // Using Derived Class from Abstract Base Class
        SQLDataAccessWithAbstract sqlDataAbstract = new SQLDataAccessWithAbstract();
        Console.WriteLine(sqlDataAbstract.LoadConnectionString());
        sqlDataAbstract.LoadData();
        sqlDataAbstract.SaveData();

        Console.WriteLine("--------------------------");

        // You can't instantiate Abstract Base Class directly
        // AbstractDataAccess abstractData = new AbstractDataAccess(); 
        // Error: Cannot create an instance of the abstract class
    }
}

' Main Program
Class Program
    Shared Sub Main(ByVal args As String())
        ' Using Base Class
        Dim sqlData As New SQLDataAccess()
        Console.WriteLine(sqlData.LoadConnectionString())
        sqlData.LoadData()
        sqlData.SaveData()

        Console.WriteLine("--------------------------")

        ' Using Derived Class from Abstract Base Class
        Dim sqlDataAbstract As New SQLDataAccessWithAbstract()
        Console.WriteLine(sqlDataAbstract.LoadConnectionString())
        sqlDataAbstract.LoadData()
        sqlDataAbstract.SaveData()

        Console.WriteLine("--------------------------")

        ' You can't instantiate Abstract Base Class directly
        ' Dim abstractData As New AbstractDataAccess()
        ' Error: Cannot create an instance of the abstract class
    End Sub
End Class

' Main Program
Class Program
    Shared Sub Main(ByVal args As String())
        ' Using Base Class
        Dim sqlData As New SQLDataAccess()
        Console.WriteLine(sqlData.LoadConnectionString())
        sqlData.LoadData()
        sqlData.SaveData()

        Console.WriteLine("--------------------------")

        ' Using Derived Class from Abstract Base Class
        Dim sqlDataAbstract As New SQLDataAccessWithAbstract()
        Console.WriteLine(sqlDataAbstract.LoadConnectionString())
        sqlDataAbstract.LoadData()
        sqlDataAbstract.SaveData()

        Console.WriteLine("--------------------------")

        ' You can't instantiate Abstract Base Class directly
        ' Dim abstractData As New AbstractDataAccess()
        ' Error: Cannot create an instance of the abstract class
    End Sub
End Class

Wnioski

Głębokie zanurzenie się Tima Coreya w klasy abstrakcyjne C# oferuje jasne i praktyczne zrozumienie ich celu, funkcjonalności i zastosowań w rzeczywistym świecie. Poprzez swoją aplikację demo, pokazuje, jak klasy abstrakcyjne wypełniają lukę między klasami bazowymi a interfejsami, umożliwiając programistom tworzenie elastycznych i łatwych do utrzymania struktur kodu.

Podkreślając najlepsze praktyki, takie jak używanie klas abstrakcyjnych we właściwych scenariuszach i unikanie nadużycia, Tim wyposaża programistów w narzędzia do podejmowania świadomych decyzji projektowych. Dzięki solidnemu zrozumieniu tych koncepcji, programiści mogą ulepszać swoje umiejętności programowania obiektowego i budować solidne aplikacje w C#.