# Abstract Creational Design Pattern

![abstract](../../Asset/GOF/003-03-01-GOF-Creational-Abstract.png)

```c#
/*To illustrate the Abstract Factory pattern, let's consider an example where we need to create UI elements for different operating systems (e.g., Windows and MacOS). Each operating system has a different look and feel for their buttons and windows.

First, we define interfaces for the abstract products:
*/

// Abstract product A
public interface IButton
{
    void Render();
}

// Abstract product B
public interface IWindow
{
    void Open();
}



// Then, we create concrete product classes for each operating system:

// Concrete product A1
public class WindowsButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Rendering a button in Windows style");
    }
}

// Concrete product B1
public class WindowsWindow : IWindow
{
    public void Open()
    {
        Console.WriteLine("Opening a Windows style window");
    }
}

// Concrete product A2
public class MacOSButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Rendering a button in MacOS style");
    }
}

// Concrete product B2
public class MacOSWindow : IWindow
{
    public void Open()
    {
        Console.WriteLine("Opening a MacOS style window");
    }
}



// Next, we define the abstract factory interface with methods to create the abstract products:

// The 'AbstractFactory' interface
public interface IUIFactory
{
    IButton CreateButton();
    IWindow CreateWindow();
}



// Now, we implement concrete factories for each operating system:

// Concrete factory 1
public class WindowsFactory : IUIFactory
{
    public IButton CreateButton()
    {
        return new WindowsButton();
    }

    public IWindow CreateWindow()
    {
        return new WindowsWindow();
    }
}

// Concrete factory 2
public class MacOSFactory : IUIFactory
{
    public IButton CreateButton()
    {
        return new MacOSButton();
    }

    public IWindow CreateWindow()
    {
        return new MacOSWindow();
    }
}



// Finally, the client code can use the abstract factory to create UI elements without specifying their concrete classes:

class Program
{
    static void Main(string[] args)
    {
        IUIFactory uiFactory;
        IButton button;
        IWindow window;

        // Decide which factory to use based on some condition or configuration
        if (OperatingSystemIsWindows())
        {
            uiFactory = new WindowsFactory();
        }
        else
        {
            uiFactory = new MacOSFactory();
        }

        // Create products using the factory
        button = uiFactory.CreateButton();
        window = uiFactory.CreateWindow();

        // Use the products
        button.Render();
        window.Open();
    }

    static bool OperatingSystemIsWindows()
    {
        // Determine the operating system; for demo purposes, return true
        return true;
    }
}
```