Zrozumienie klasy abstrakcyjnej w C#

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...");
    }
}

Tworzenie klasy bazowej

Tim wyjaśnia o 3:21 jak stworzyć klasę bazową. Refaktoryzuje kod, aby przenieść wspólne 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 powtarzalność kodu.

Uczynienie klasy bazowej abstrakcyjną

Tim o 5:56 przechodzi od klasy bazowej do klasy abstrakcyjnej, aby pokazać różnice. Zmienia DataAccess na klasę abstrakcyjną, uniemożliwiając jej bezpośrednią instancjację. Zamiast tego, tylko klasy dziedziczące z tej klasy abstrakcyjnej, takie jak SQLiteDataAccess i SQLDataAccess, mogą implementować jej metody i używać jej wspólnych funkcji.

Oto jak kod się zmienia, gdy DataAccess staje się klasą abstrakcyjną:

// 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();
}

Część interfejsu w klasie abstrakcyjnej

Tim o 8:34 wyjaśnia, jak klasy abstrakcyjne łączą funkcje interfejsów i klas bazowych. Deklaruje w klasie abstrakcyjnej metody abstrakcyjne, takie jak public abstract void LoadData(); i public abstract void SaveData();, bez ich implementacji. 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 nadpisanie. 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...");
    }
}

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
    }
}

Wnioski

Głębokie zanurzenie się Tima Coreya w klasy abstrakcyjne C# oferuje jasne i praktyczne zrozumieniuiuiuiuie 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 zrozumieniuiuiuiuiu tych koncepcji, programiści mogą ulepszać swoje umiejętności programowania obiektowego i budować solidne aplikacje w C#.