Aprenda C#

Entendendo a Classe Abstrata em C#

Tim Corey

19m 59s

Classes abstratas em C# são um conceito fundamental que frequentemente gera dúvidas entre os desenvolvedores. Em seu vídeo " Classes abstratas em C# - O que são, como usá-las e melhores práticas ", Tim Corey explora o que são classes abstratas, como usá-las e as melhores práticas. Este artigo resume os pontos principais do vídeo, utilizando marcações de tempo como referência.

Introdução

Tim (0:00) explica que as classes abstratas são frequentemente questionadas em termos de seu propósito, funcionalidade e importância. Ele descreve uma classe abstrata como uma mistura entre uma classe base completa e uma interface, situada entre as duas em termos de funcionalidade.

Demonstração do Aplicativo - Passo a Passo

Em (0:59), Tim apresenta um aplicativo de demonstração para ilustrar classes abstratas. A aplicação consiste em uma aplicação de console e uma biblioteca de classes com duas classes de acesso a dados que simulam operações de banco de dados. Essas classes possuem métodos para carregar e salvar dados, que Tim usa para ilustrar as semelhanças e diferenças entre classes abstratas, classes base e interfaces.

Aqui está o código inicial para a classe base e as classes derivadas:

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

Criando uma classe base

Tim explica em (3:21) como criar uma classe base. Ele refatora o código para mover métodos comuns, como LoadConnectionString, para uma classe base chamada DataAccess. Ao herdar desta classe base, outras classes como SQLDataAccess e SQLiteDataAccess ganham acesso a esses métodos compartilhados, reduzindo a duplicação de código.

Tornando a classe base abstrata

Tim em (5:56) transita da classe base para uma classe abstrata para demonstrar as diferenças. Ele muda DataAccess para uma classe abstrata, impedindo que seja instanciada diretamente. Em vez disso, apenas classes que herdam desta classe abstrata, como SQLiteDataAccess e SQLDataAccess, podem implementar seus métodos e usar sua funcionalidade compartilhada.

Veja como o código muda quando DataAccess se torna uma classe abstrata:

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

Parte da interface na classe abstrata

Tim em (8:34) explica como as classes abstratas combinam as características das interfaces e das classes base. Ele declara métodos abstratos dentro da classe abstrata, como public abstract void LoadData(); e public abstract void SaveData();, sem implementá-los. Isso garante que qualquer classe derivada implemente esses métodos, de forma semelhante ao funcionamento das interfaces.

Sobrescrita de métodos em classes abstratas

Tim em (12:56) discute como sobrescrever métodos em uma classe abstrata. Ele mostra que você pode declarar um método na classe base como virtual, permitindo que classes derivadas o substituam. Essa abordagem proporciona flexibilidade na forma como os métodos são implementados e estendidos em classes derivadas.

Aqui está o código da classe derivada mostrando as sobrescritas de métodos:

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

Quando usar classes abstratas

Tim, às 16:01, aconselha que as classes abstratas não devem ser usadas todos os dias, mas são valiosas em cenários específicos. Ele alerta contra o uso de classes abstratas apenas porque duas classes compartilham código semelhante. Em vez disso, ele enfatiza a manutenção da relação "é um" e sugere considerar métodos ou classes auxiliares para código compartilhado quando apropriado.

Segue o código principal do programa demonstrando sua utilização:

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

Conclusão

O estudo aprofundado de Tim Corey sobre classes abstratas em C# oferece uma compreensão clara e prática de seu propósito, funcionalidade e aplicações no mundo real. Por meio de seu aplicativo de demonstração, ele mostra como as classes abstratas preenchem a lacuna entre classes base e interfaces, permitindo que os desenvolvedores criem estruturas de código flexíveis e de fácil manutenção.

Ao enfatizar as melhores práticas, como o uso de classes abstratas nos cenários adequados e evitar o uso excessivo, Tim fornece aos desenvolvedores as ferramentas necessárias para tomarem decisões de design informadas. Com um sólido domínio desses conceitos, os desenvolvedores podem aprimorar suas habilidades de programação orientada a objetos e criar aplicativos C# robustos.