Forneça exemplos de uso do padrão de fábrica…

O padrão de fábrica abstrata é útil quando é necessário criar uma família de objetos relacionados ou dependentes sem especificar suas classes concretas. Exemplos da prática real:

Criação de elementos de interface de utilizador (GUI) para diferentes sistemas operativos:

A fábrica abstrata (IGUIFactory) pode ter métodos para criar botões (CreateButton), caixas de texto (CreateTextBox) e outros elementos.
As fábricas concretas (WindowsFactory, MacOSFactory) implementam IGUIFactory, criando elementos específicos para a plataforma correspondente.
O código cliente interage apenas com as interfaces (IButton, ITextBox), sem conhecer a implementação concreta.

// Produtos abstratos
public interface IButton
{
    void Render();
}

public interface ITextBox
{
    void ShowText();
}

// Produtos concretos para Windows
public class WindowsButton : IButton
{
    public void Render() { /* Lógica para renderizar botão Windows */ }
}

public class WindowsTextBox : ITextBox
{
    public void ShowText() { /* Lógica para mostrar texto na caixa de texto Windows */ }
}

// Produtos concretos para MacOS
public class MacOSButton : IButton
{
    public void Render() { /* Lógica para renderizar botão MacOS */ }
}

public class MacOSTextBox : ITextBox
{
    public void ShowText() { /* Lógica para mostrar texto na caixa de texto MacOS */ }
}

// Fábrica abstrata
public interface IGUIFactory
{
    IButton CreateButton();
    ITextBox CreateTextBox();
}

// Fábrica concreta para Windows
public class WindowsFactory : IGUIFactory
{
    public IButton CreateButton() { return new WindowsButton(); }
    public ITextBox CreateTextBox() { return new WindowsTextBox(); }
}

// Fábrica concreta para MacOS
public class MacOSFactory : IGUIFactory
{
    public IButton CreateButton() { return new MacOSButton(); }
    public ITextBox CreateTextBox() { return new MacOSTextBox(); }
}

// Código cliente
public class Application
{
    private readonly IGUIFactory _factory;
    private IButton _button;
    private ITextBox _textBox;

    public Application(IGUIFactory factory)
    {
        _factory = factory;
        _button = _factory.CreateButton();
        _textBox = _factory.CreateTextBox();
    }

    public void Paint()
    {
        _button.Render();
        _textBox.ShowText();
    }
}

// Utilização
// var factory = new WindowsFactory(); // Ou new MacOSFactory();
// var app = new Application(factory);
// app.Paint();

Criação de objetos de acesso a dados (DAO) para diferentes tipos de bases de dados:

A fábrica abstrata (IDatabaseFactory) pode ter métodos para criar DAO para utilizadores (CreateUserDAO), produtos (CreateProductDAO), etc.
As fábricas concretas (SqlDatabaseFactory, OracleDatabaseFactory) implementam IDatabaseFactory, criando DAO específicos para a base de dados correspondente.
Isto permite mudar facilmente o tipo de base de dados sem modificar a lógica de negócio.

// DAO abstratos
public interface IUserDAO
{
    void InsertUser(string username);
}

public interface IProductDAO
{
    void AddProduct(string productName);
}

// DAO concretos para SQL
public class SqlUserDAO : IUserDAO
{
    public void InsertUser(string username) { /* lógica de inserção SQL */ }
}

public class SqlProductDAO : IProductDAO
{
    public void AddProduct(string productName) { /* lógica de inserção SQL */ }
}

// DAO concretos para Oracle
public class OracleUserDAO : IUserDAO
{
    public void InsertUser(string username) { /* lógica de inserção Oracle */ }
}

public class OracleProductDAO : IProductDAO
{
    public void AddProduct(string productName) { /* lógica de inserção Oracle */ }
}

// Fábrica abstrata
public interface IDatabaseFactory
{
    IUserDAO CreateUserDAO();
    IProductDAO CreateProductDAO();
}

// Fábrica concreta para SQL
public class SqlDatabaseFactory : IDatabaseFactory
{
    public IUserDAO CreateUserDAO() { return new SqlUserDAO(); }
    public IProductDAO CreateProductDAO() { return new SqlProductDAO(); }
}

// Fábrica concreta para Oracle
public class OracleDatabaseFactory : IDatabaseFactory
{
    public IUserDAO CreateUserDAO() { return new OracleUserDAO(); }
    public IProductDAO CreateProductDAO() { return new OracleProductDAO(); }
}

// Exemplo de uso na lógica de negócio
public class BusinessLogic
{
    private readonly IDatabaseFactory _factory;

    public BusinessLogic(IDatabaseFactory factory)
    {
        _factory = factory;
    }

    public void RegisterUser(string username)
    {
        var userDAO = _factory.CreateUserDAO();
        userDAO.InsertUser(username);
    }
}

Criação de objetos para trabalhar com diferentes formatos de ficheiros (p. ex., XML, JSON):
- A fábrica abstrata pode criar analisadores (CreateParser) e serializadores (CreateSerializer) para diferentes formatos.
- As fábricas concretas (XmlFactory, JsonFactory) fornecerão implementações específicas para XML e JSON.

Estes exemplos demonstram como a fábrica abstrata permite criar famílias de objetos relacionados, abstraindo o código cliente das suas implementações concretas e facilitando a adição de novas variantes de famílias.

Forneça exemplos de uso do padrão de fábrica abstrata.