Ludo Programming

Într-o aplicație complexă, nu e suficient să creezi un singur obiect. De multe ori, ai nevoie de familii de obiecte care lucrează împreună — fără ca logica principală să știe exact ce clase sunt folosite.

Aici intervine Abstract Factory, unul dintre cele mai elegante pattern-uri de creare.

🔍 Ce este Abstract Factory?

Abstract Factory este un pattern de design creational care oferă o interfață pentru crearea de familii de obiecte interconectate, fără a specifica clasele lor concrete.

Scopul său este să izoleze codul client de implementările concrete, permițând schimbarea întregii „familii” de obiecte fără modificări în logica aplicației.

🧠 Analogie simplă

Imaginează-ți că dezvolți o aplicație multiplatformă (.NET MAUI, de exemplu).

Ai nevoie de butoane și ferestre diferite pentru Windows, macOS și Linux, dar interfața aplicației trebuie să rămână aceeași.

În loc să scrii:

if (platform == "Windows")
    button = new WindowsButton();
else if (platform == "Mac")
    button = new MacButton();

poți apela elegant:

var guiFactory = new MacFactory();
var button = guiFactory.CreateButton();
var window = guiFactory.CreateWindow();

Astfel, schimbi întreaga familie de obiecte (buton + fereastră) printr-un singur factory.

⚙️ Implementare în C#

// Abstract Factory
public interface IGUIFactory
{
    IButton CreateButton();
    IWindow CreateWindow();
}

// Produse abstracte
public interface IButton { void Render(); }
public interface IWindow { void Open(); }

// Implementări concrete
public class MacFactory : IGUIFactory
{
    public IButton CreateButton() => new MacButton();
    public IWindow CreateWindow() => new MacWindow();
}

public class WindowsFactory : IGUIFactory
{
    public IButton CreateButton() => new WindowsButton();
    public IWindow CreateWindow() => new WindowsWindow();
}

// Produse concrete
public class MacButton : IButton { public void Render() => Console.WriteLine("Mac Button"); }
public class MacWindow : IWindow { public void Open() => Console.WriteLine("Mac Window"); }

public class WindowsButton : IButton { public void Render() => Console.WriteLine("Windows Button"); }
public class WindowsWindow : IWindow { public void Open() => Console.WriteLine("Windows Window"); }

// Client
class Application
{
    private readonly IGUIFactory _factory;

    public Application(IGUIFactory factory)
    {
        _factory = factory;
    }

    public void Run()
    {
        var button = _factory.CreateButton();
        var window = _factory.CreateWindow();

        button.Render();
        window.Open();
    }
}

🏗️ Avantaje

✅ Separă clar codul client de implementările concrete

✅ Permite schimbarea rapidă a familiei de produse

✅ Promovează consistența între obiectele create

✅ Simplifică testarea și extinderea aplicației

⚠️ Dezavantaje

❌ Codul devine mai complex, cu multe interfețe

❌ Dificil de extins dacă adaugi un produs nou în toate fabricile

💡 Când să folosești Abstract Factory

• Când aplicația trebuie să funcționeze pe mai multe platforme sau stiluri de UI

• Când vrei să eviți dependențele directe față de clase concrete

• Când ai nevoie ca toate obiectele create să fie coerente între ele

🧩 Concluzie

Abstract Factory aduce ordine și consistență în arhitecturile complexe.

Prin el, poți crea ecosisteme coerente de obiecte, fără ca logica aplicației să depindă de detaliile implementării — un pas esențial către cod curat, scalabil și testabil în C#.