Padrão Composite em C#

O que é o Padrão Composite? O Padrão Composite é uma técnica de design estrutural que permite tratar objetos individuais e grupos de objetos da mesma maneira. Isso facilita a criação de hierarquias de objetos, onde cada elemento pode ser um item único ou um conjunto de itens. Essa abordagem promove a flexibilidade e a escalabilidade em sistemas complexos, tornando-o uma ferramenta essencial para desenvolvedores.

Um Exemplo prático: Gerenciamento de Arquivos. Imagine um sistema de gerenciamento de arquivos onde você tem arquivos individuais, como documentos e imagens, e pastas que podem conter esses arquivos e outras pastas. O Padrão Composite é perfeito para isso, pois permite que o sistema trate arquivos e pastas de forma uniforme. Por exemplo: você pode criar um método para imprimir a estrutura do sistema de arquivos sem precisar saber se o objeto é um arquivo ou uma pasta.

Estrutura do Padrão Composite

Componente: A interface que define como os objetos serão tratados. No nosso exemplo, seria a interface FileSystemItem.

Objeto Folha: Itens individuais, como arquivos.

Objeto Composto: Itens que podem conter outros, como pastas.

Cliente: O código que interage com os objetos, sem precisar saber se são individuais ou compostos.

Vantagens do Padrão Composite

Flexibilidade: Permite tratar objetos de diferentes tipos de forma uniforme.
Escalabilidade: Facilita a adição de novos tipos de objetos sem alterar o código existente.
Simplificação do Código: Reduz a complexidade do código, pois não é necessário tratar cada tipo de objeto de forma diferente.

Vamos criar um sistema de gerenciamento de arquivos simplificado utilizando C#.

using System;
using System.Collections.Generic;

// Componente
interface IFileSystemItem
{
    void Print(string indent);
}

// Objeto Folha
class File : IFileSystemItem
{
    private string name;

    public File(string name)
    {
        this.name = name;
    }

    public void Print(string indent)
    {
        Console.WriteLine(indent + name);
    }
}

// Objeto Composto
class Folder : IFileSystemItem
{
    private string name;
    private List<IFileSystemItem> children = new List<IFileSystemItem>();

    public Folder(string name)
    {
        this.name = name;
    }

    public void Add(IFileSystemItem item)
    {
        children.Add(item);
    }

    public void Remove(IFileSystemItem item)
    {
        children.Remove(item);
    }

    public void Print(string indent)
    {
        Console.WriteLine(indent + "+ " + name);
        foreach (var child in children)
        {
            child.Print(indent + "  ");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Criando objetos folha
        var file1 = new File("Document.txt");
        var file2 = new File("Image.png");

        // Criando objeto composto
        var folder1 = new Folder("Folder 1");
        folder1.Add(file1);
        folder1.Add(file2);

        // Criando objeto composto dentro de outro objeto composto
        var folder2 = new Folder("Folder 2");
        folder2.Add(folder1);

        // Imprimindo a estrutura
        folder2.Print("");
    }
}

Neste exemplo, File e Folder implementam a interface IFileSystemItem permitindo que o sistema trate ambos de forma uniforme. O método Print é chamado em todos os objetos, seja um arquivo ou uma pasta, para imprimir a estrutura do sistema de arquivos.

Conclusão

Em resumo, o Padrão Composite é uma técnica de design estrutural que permite tratar objetos individuais e compostos de forma uniforme, promovendo flexibilidade e escalabilidade em sistemas complexos. Ao implementar esse padrão, você pode criar hierarquias de objetos robustas e fáceis de manter, permitindo que sua aplicação cresça e evolua com facilidade.