/*

 Author: FeralCoder (philip.thomas@thoughtworks.com)

 Builder

 - Builder used to create items based on abstraction and not a concrete implementation

 - does not violate the Single Responsibility, Open-Closed Principle, Liskov Substitution, Interface Segregation or Dependency Injection.

 - why how you are not breaking each of these.

*/

using System;

using System.Collections.Generic;

using Unity;

using static System.Console;

​

public class Program

{

    static IUnityContainer unityContainer = new UnityContainer();

    private static void RegisterTypes()

    {

        unityContainer.RegisterType<IWingFactory, WingFactory>();

    }

​

    public static void Main()

    {

        RegisterTypes();

        // NOTE: SOLID - Dependency Injection

        var wingFactory = unityContainer.Resolve<WingFactory>();

        var order = new Order(wingFactory);

        var chicken = order.WingFactory.Create<Chicken>();

        var cauliflower = order.WingFactory.Create<Cauliflower>();

        var tofu = order.WingFactory.Create<Tofu>();

        order.Items.Add(chicken);

        order.Items.Add(cauliflower);

        order.Items.Add(tofu);

    }

}

​

/* Model */

#region Model

public class Order

{

    public IWingFactory WingFactory

    {

        get;

    }

​

    public IList<Item> Items

    {

        get;

    }

​

    public Order(IWingFactory wingFactory)

    {

        this.WingFactory = wingFactory;

        this.Items = new List<Item>();

    }

}

​

public class Item

{

    public virtual string Name

    {

        get;

    }

​

    public override string ToString()

    {

        return $"{nameof(Name)}: {Name}";

    }

}

​

public class Chicken : Item

{

    public override string Name => "Chicken";

}

​

public class Cauliflower : Item

{

    public override string Name => "Cauliflower";

}

​

public class Tofu : Item

{

    public override string Name => "Tofu";

}

​

#endregion

/* Factories */

#region Factories

// NOTE: I should never have to change IWingFactory if I have a new WingType and not breaking Open Closed

// NOTE: Liskov Substitution is not an issue here either.

public interface IWingFactory

{

    private static readonly string WingCooker = "WingCooker";

    WingType Create<WingType>()

        where WingType : Item, new()

    {

        dynamic wingCooker = Activator.CreateInstance(Type.GetType(typeof(WingType).Name + WingCooker), new WingType());

        return wingCooker.Cook().Item;

    }

}

​

// NOTE: I should never have to change IWingCookerFactory if I have a new WingType and not breaking Open Closed

// NOTE: Liskov Substitution is not an issue here either.

// NOTE: Single Responsibility not broken.

// NOTE: Interface Segration not borken.

public class WingFactory : IWingFactory

{

}

​

#endregion

/* Builders */

#region Builders

// NOTE: Builder could easily break Open Closed because if I want to add/remove/modify behavior. Decorator could solve this.

// NOTE: All behavior can be used for all Cookers that implement this so not breaking Interface Segration, but it can easily do so if not careful.

public abstract class WingCooker<WingType>

    where WingType : Item, new()

    {

​

    public WingType Item

    {

        get;

    }

​

    public WingCooker(WingType item)

    {

        this.Item = item;

    }

​

    public WingCooker<WingType> Wash()

    {

        WriteLine($"Washing the {Item.Name} wings thoroughly.");

        return this;

    }

​

    public WingCooker<WingType> Season()

    {

        WriteLine($"Seasoning the {Item.Name} wings generously.");

        return this;

    }

​

    public WingCooker<WingType> PutInBasket()

    {

        WriteLine($"Putting the {Item.Name} wings into the frying basket carefully.");

        return this;

    }

​

    public WingCooker<WingType> PutOnBakingTray()

    {

        WriteLine($"Putting the {Item.Name} wings onto the baking tray carefully.");

        return this;

    }

​

    public WingCooker<WingType> PlaceInOven()

    {

        WriteLine($"Placing the {Item.Name} wings into the oven.");

        return this;

    }

​

    public WingCooker<WingType> DropInVAT()

    {

        WriteLine($"Dropping the frying basket full of the {Item.Name} wings in deep fry VAT.");

        return this;

    }

​

    public WingCooker<WingType> SetTimer()

    {

        WriteLine($"Setting the timer for the {Item.Name} wings.");

        return this;

    }

​

    public WingCooker<WingType> PressOutWater()

    {

        WriteLine($"Pressing out the water for the {Item.Name} wings.");

        return this;

    }

​

    public WingCooker<WingType> CutIntoRectangles()

    {

        WriteLine($"Cutting out block of {Item.Name} into evenly shaped rectangles for the {Item.Name} wings.");

        return this;

    }

​

    public WingCooker<WingType> Remove()

    {

        WriteLine($"Removing the {Item.Name} wings.");

        return this;

    }

​

    public WingCooker<WingType> Package()

    {

        WriteLine($"Packaging the {Item.Name} wings.");

        return this;

    }

​

    public abstract WingCooker<WingType> Cook();

}

​

// NOTE: Single responsibility here. Only dealing with specific steps for cooking Chicken

public class ChickenWingCooker : WingCooker<Chicken>

{

    public ChickenWingCooker(Chicken item): base(item)

    {

    }

​

    public override WingCooker<Chicken> Cook()

    {

        return this.Wash().Season().PutInBasket().DropInVAT().SetTimer().Remove().Package();

    }

}

​

// NOTE: Single responsibility here. Only dealing with specific steps for cooking Cauliflower

public class CauliflowerWingCooker : WingCooker<Cauliflower>

{

    public CauliflowerWingCooker(Cauliflower item): base(item)

    {

    }

​

    public override WingCooker<Cauliflower> Cook()

    {

        return this.Wash().Season().PutOnBakingTray().PlaceInOven().SetTimer().Remove().Package();

    }

}

​

// NOTE: Single responsibility here. Only dealing with specific steps for cooking Tofu

public class TofuWingCooker : WingCooker<Tofu>

{

    public TofuWingCooker(Tofu item): base(item)

    {

    }

​

    public override WingCooker<Tofu> Cook()

    {

        return this.Wash().PressOutWater().CutIntoRectangles().Season().SetTimer().Remove().Package();

    }

}

#endregion

​