/* Loosely inspired by code written by David Elmaliach https://code.sololearn.com/chaz79RWeX1b/?ref=app */ using static System.Console; using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Reflection; using Core; /* Simulating a sample app which is completely decoupled from any specific IDocument types. */ class DocApp { public IDocument Document { get; } public DocApp(IDocument document) { Document = document; document.Print(); } } class Program { static void Main(string[] args) { /* The DocApps List uses 5 different Documents to demo how Factory Method Pattern extends the core logic with new decoupled code. */ var factoryProvider = new FactoryProvider(); (new List(){ "Resume", "Menu", "Recipe", "Report", "Invoice" }).ForEach(s => Run(s, factoryProvider)); } static public void Run( string docType, FactoryProvider factoryProvider ) { var app = new DocApp( factoryProvider .CreateFactoryFor(docType) .Create() ); } } /* The Core code is decoupled from any specific IDocument types. */ namespace Core { interface ISection {} interface IDocument { List Sections { get; } void Print(); } interface IDocumentProvider { IDocument Create(); } interface IFactory {} abstract class Document : IDocument { public List Sections { get; } public Document(List s) { Sections = s; } /* This base method will print object details reflecting the object created by the derived factory method. (ie Resume.Provider.CreateDocument() returns a new Resume (C.V.) Document.) */ public void Print() { WriteLine(@$" ---------- [ DocApp ] ---- {this.GetType().Name} ----"); this.Sections .Select(s => $" * {s}") .ToList() .ForEach(WriteLine); } } //Creator base abstract class. abstract class DocumentProvider : IDocumentProvider { /* This base class (DocumentProvider) defers object creation of IDocument to the derived Provider class (i.e. class Resume.Provider) This is a key characteristic of the Factory Method Pattern which allows an API to extend the code via derived types which are also accessible in the base class. Key Factory Design Pattern Parts: - class DocumentProvider is the creator. - CreateDocument() is the Factory method implemented in derived classes. */ public IDocument Create() => CreateDocument(); protected abstract IDocument CreateDocument(); } class FactoryProvider { private IEnumerable _factories; public FactoryProvider(){ _factories = Assembly .GetAssembly(typeof(FactoryProvider)) .GetTypes() .Where( type => typeof(IFactory) .IsAssignableFrom(type)); } public IDocumentProvider CreateFactoryFor(string name) { name = name.Contains(".Provider") ? name : $"{name}.Provider"; var factory = _factories.Single( f => f.FullName.ToLower() .Contains(name.ToLower()) ); return (IDocumentProvider) Activator.CreateInstance(factory); } } } /* Extending the Core code with specific derived document types and corresponding document providers with factory methods. See the various Documents and DocumentProviders below: - Resume (Job C.V.) - Menu (Restaurant list of foods.) - Recipe (Instructions for food dishes.) - Report (with header, body, and footer.) - Invoice (with order details.) */ //Resume (C.V.) Doc with Custom Sections namespace Resume { class Resume : Document { public Resume(List s):base(s){} } class Skills : ISection {} class Experience : ISection {} //Creator sub class. class Provider : DocumentProvider, IFactory { /* This derived type (Resume.Provider) is responsible for object creation which could change the behavior of the base type (class Core.DocumentProvider). */ protected override IDocument CreateDocument() => new Resume( new List(){ new Skills(), new Experience() }); } } //Food Menu Doc with Custom Sections namespace Menu { class Menu : Document { public Menu(List s) : base(s) {} } class Appetizers : ISection {} class Drinks : ISection {} class Sides : ISection {} class MainCourses : ISection {} class Desserts : ISection {} //Creator sub class. class Provider : DocumentProvider, IFactory { protected override IDocument CreateDocument() => new Menu( new List(){ new Appetizers(), new Drinks(), new Sides(), new MainCourses(), new Desserts() }); } } //Food Recipe Doc with relevant Sections namespace Recipe { class Recipe : Document { public Recipe(List s) : base(s) {} } class Ingredients : ISection {} class Instructions : ISection {} class Notes : ISection {} class Provider : DocumentProvider, IFactory { protected override IDocument CreateDocument() => new Recipe( new List(){ new Ingredients(), new Instructions(), new Notes() }); } } //School Report doc with relevant sections namespace Report { class Report : Document { public Report(List s) : base(s) {} } class Heading : ISection {} class Main : ISection {} class Footer : ISection {} class Provider : DocumentProvider, IFactory { protected override IDocument CreateDocument() => new Report( new List(){ new Heading(), new Main(), new Footer() }); } } //Invoice doc with relevant order sections namespace Invoice { class Invoice : Document { public Invoice(List s) : base(s) {} } class Shipping : ISection {} class OrderItems : ISection {} class Billing : ISection {} class Provider : DocumentProvider, IFactory { protected override IDocument CreateDocument() => new Invoice( new List(){ new Shipping(), new OrderItems(), new Billing() }); } }

Factory Method Pattern Demo