CSharp: Factory Method Pattern in donet core 3

 

    #region Animal Hierarchy
    /*
     * Both the Dog and Tiger classes will 
     * implement the IAnimal interface method.
    */
    /// <summary>
    /// 工厂方法模式 Factory Method Pattern
    /// geovindu,Geovin Du  eidt
    /// </summary>
    public interface IAnimal
    {
        void AboutMe();
    }
    /// <summary>
    /// Dog class
    /// </summary>
    public class Dog : IAnimal
    {
        public void AboutMe()
        {
            Console.WriteLine("The dog says: Bow-Wow.I prefer barking.");
        }
    }
    /// <summary>
    /// Tiger class
    /// </summary>
    public class Tiger : IAnimal
    {
        public void AboutMe()
        {
            Console.WriteLine("The tiger says: Halum.I prefer hunting.");
        }
    }
    #endregion 

    #region Factory Hierarchy

    /// <summary>
    /// Both DogFactory and TigerFactory will use this.
    /// </summary>
    public abstract class AnimalFactory
    {
        /*
        Remember the GoF definition which says 
        "....Factory method lets a class defer instantiation
        to subclasses." Following method will create a Tiger 
        or a Dog, but at this point it does not know whether 
        it will get a dog or a tiger. It will be decided by 
        the subclasses i.e.DogFactory or TigerFactory.
        So, the following method is acting like a factory 
        (of creation).
        */
        public abstract IAnimal CreateAnimal(string animalType);
    }
    /*
     * ConcreteAnimalFactory is used to create dogs or tigers 
     * based on method parameter of CreateAnimal() method.
     */
    /// <summary>
    /// 
    /// </summary>
    public class ConcreteAnimalFactory : AnimalFactory
    {

        /// <summary>
        /// 
        /// </summary>
        /// <param name="animalType"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        public override IAnimal CreateAnimal(string animalType)
        {
            if (animalType.Contains("dog"))
            {
                //Creating a Dog
                return new Dog();
            }
            else
            if (animalType.Contains("tiger"))
            {
                //Creating a Dog
                return new Tiger();
            }
            else
            {
                throw new ArgumentException("You need to pass either a dog or a tiger as an argument.");
            }
        }
    }

    #endregion

　　

    /// <summary>
    /// 工厂方法模式 Factory Method Pattern
    /// geovindu,Geovin Du  eidt
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IAsyncInit<T>
    {
        Task<T> InitAsync();
    }
    /// <summary>
    /// 
    /// </summary>
    public class Foo : IAsyncInit<Foo>
    {
        /*public*/
        public Foo()
        {
            // await Task.Delay(1000);
        
        }

        // ↓↓
        public async Task<Foo> InitAsync()
        {
            // some work here
            Console.WriteLine("some work here");
            await Task.Delay(1000);
            return this; // fluent
        }

        public static Task<Foo> CreateAsync()
        {
            var result = new Foo();
            return result.InitAsync();
        }
    }
    /// <summary>
    /// 
    /// </summary>
    public static class AsyncFactory
    {
        public static async Task<T> Create<T>()
          where T : IAsyncInit<T>, new()
        {
            var result = await new T().InitAsync();
            return result;
        }
    }

　　

 /// <summary>
    /// 抽象工厂模式 Abstract Factory Pattern
    /// geovindu,Geovin Du  eidt
    /// </summary>
    public interface IShape
    {
        void Draw();
    }
    /// <summary>
    /// 
    /// </summary>
    public class Square : IShape
    {
        public void Draw() => Console.WriteLine("Basic square");
    }
    /// <summary>
    /// 
    /// </summary>
    public class Rectangle : IShape
    {
        public void Draw() => Console.WriteLine("Basic rectangle");
    }
    /// <summary>
    /// 
    /// </summary>
    public class RoundedSquare : IShape
    {
        public void Draw() => Console.WriteLine("Rounded square");
    }
    /// <summary>
    /// 
    /// </summary>
    public class RoundedRectangle : IShape
    {
        public void Draw() => Console.WriteLine("Rounded rectangle");
    }
    /// <summary>
    /// 
    /// </summary>
    public enum Shape
    {
        Square,
        Rectangle
    }
    /// <summary>
    /// 
    /// </summary>
    public abstract class ShapeFactory
    {
        public abstract IShape Create(Shape shape);
    }
    /// <summary>
    /// 
    /// </summary>
    public class BasicShapeFactory : ShapeFactory
    {
        public override IShape Create(Shape shape)
        {
            switch (shape)
            {
                case Shape.Square:
                    return new Square();
                case Shape.Rectangle:
                    return new Rectangle();
                default:
                    throw new ArgumentOutOfRangeException(
                      nameof(shape), shape, null);
            }
        }
    }
    /// <summary>
    /// 
    /// </summary>
    public class RoundedShapeFactory : ShapeFactory
    {
        public override IShape Create(Shape shape)
        {
            switch (shape)
            {
                case Shape.Square:
                    return new RoundedSquare();
                case Shape.Rectangle:
                    return new RoundedRectangle();
                default:
                    throw new ArgumentOutOfRangeException(nameof(shape), shape, null);
            }
        }
    }
    /// <summary>
    /// 
    /// </summary>
    public class Demo
    {
        public static ShapeFactory GetFactory(bool rounded)
        {
            if (rounded)
                return new RoundedShapeFactory();
            else
                return new BasicShapeFactory();
        }
    }

　　

    /// <summary>
    /// 工厂方法模式 Factory Method Pattern
    /// geovindu,Geovin Du  eidt
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IAsyncInit<T>
    {
        Task<T> InitAsync();
    }
    /// <summary>
    /// 
    /// </summary>
    public class Foo : IAsyncInit<Foo>
    {
        /*public*/
        public Foo()
        {
            // await Task.Delay(1000);
        
        }

        // ↓↓
        public async Task<Foo> InitAsync()
        {
            // some work here
            Console.WriteLine("some work here");
            await Task.Delay(1000);
            return this; // fluent
        }

        public static Task<Foo> CreateAsync()
        {
            var result = new Foo();
            return result.InitAsync();
        }
    }
    /// <summary>
    /// 
    /// </summary>
    public static class AsyncFactory
    {
        public static async Task<T> Create<T>()
          where T : IAsyncInit<T>, new()
        {
            var result = await new T().InitAsync();
            return result;
        }
    }

　　

 /// <summary>
    /// 工厂方法模式 Factory Method Pattern
    /// geovindu,Geovin Du  eidt
    /// </summary>
    public interface IHotDrink
    {
        void Consume();
    }
    /// <summary>
    /// 
    /// </summary>
    internal class Tea : IHotDrink
    {
        public void Consume()
        {
            Console.WriteLine("This tea is nice but I'd prefer it with milk.");
        }
    }
    /// <summary>
    /// 
    /// </summary>
    internal class Coffee : IHotDrink
    {
        public void Consume()
        {
            Console.WriteLine("This coffee is delicious!");
        }
    }
    /// <summary>
    /// 
    /// </summary>
    public interface IHotDrinkFactory
    {
        IHotDrink Prepare(int amount);
    }
    /// <summary>
    /// 
    /// </summary>
    internal class TeaFactory : IHotDrinkFactory
    {
        public IHotDrink Prepare(int amount)
        {
            Console.WriteLine($"Put in tea bag, boil water, pour {amount} ml, add lemon, enjoy!");
            return new Tea();
        }
    }
    /// <summary>
    /// 
    /// </summary>
    internal class CoffeeFactory : IHotDrinkFactory
    {
        public IHotDrink Prepare(int amount)
        {
            Console.WriteLine($"Grind some beans, boil water, pour {amount} ml, add cream and sugar, enjoy!");
            return new Coffee();
        }
    }
    /// <summary>
    /// 
    /// </summary>
    public class HotDrinkMachine
    {

        /// <summary>
        /// 
        /// </summary>
        public enum AvailableDrink // violates open-closed
        {
            Coffee, Tea
        }

        private Dictionary<AvailableDrink, IHotDrinkFactory> factories =
          new Dictionary<AvailableDrink, IHotDrinkFactory>();

        private List<Tuple<string, IHotDrinkFactory>> namedFactories =
          new List<Tuple<string, IHotDrinkFactory>>();
        /// <summary>
        /// 
        /// </summary>
        public HotDrinkMachine()
        {
            //foreach (AvailableDrink drink in Enum.GetValues(typeof(AvailableDrink)))
            //{
            //  var factory = (IHotDrinkFactory) Activator.CreateInstance(
            //    Type.GetType("DotNetDesignPatternDemos.Creational.AbstractFactory." + Enum.GetName(typeof(AvailableDrink), drink) + "Factory"));
            //  factories.Add(drink, factory);
            //}

            foreach (var t in typeof(HotDrinkMachine).Assembly.GetTypes())
            {
                if (typeof(IHotDrinkFactory).IsAssignableFrom(t) && !t.IsInterface)
                {
                    namedFactories.Add(Tuple.Create(
                      t.Name.Replace("Factory", string.Empty), (IHotDrinkFactory)Activator.CreateInstance(t)));
                }
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        public IHotDrink MakeDrink(string type)
        {
            switch (type)
            {
                case "tea":
                    return new TeaFactory().Prepare(200);
                case "coffee":
                    return new CoffeeFactory().Prepare(50);
                default:
                    throw new ArgumentException("type");
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public IHotDrink MakeDrink()
        {
            Console.WriteLine("Available drinks");
            for (var index = 0; index < namedFactories.Count; index++)
            {
                var tuple = namedFactories[index];
                Console.WriteLine($"{index}: {tuple.Item1}");

            }

            while (true)
            {
                string s;
                if ((s = Console.ReadLine()) != null
                    && int.TryParse(s, out int i) // c# 7
                    && i >= 0
                    && i < namedFactories.Count)
                {
                    Console.Write("Specify amount: ");
                    s = Console.ReadLine();
                    if (s != null
                        && int.TryParse(s, out int amount)
                        && amount > 0)
                    {
                        return namedFactories[i].Item2.Prepare(amount);
                    }
                }
                Console.WriteLine("Incorrect input, try again.");
            }
        }

        //public IHotDrink MakeDrink(AvailableDrink drink, int amount)
        //{
        //  return factories[drink].Prepare(amount);
        //}
    }

　　

调用：

//
            Console.WriteLine("***工厂方法模式 Factory Pattern Demo.***");
            Console.WriteLine("***It's a modified version using method parameter(s).***\n");
            // Creating a factory that can produce animals
            AnimalFactory animalFactory = new ConcreteAnimalFactory();
            // Creating a tiger using the Factory Method
            IAnimal tiger = animalFactory.CreateAnimal("tiger");
            tiger.AboutMe();
            //Now creating a dog.          
            IAnimal dog = animalFactory.CreateAnimal("dog");
            dog.AboutMe();

            //抽象工厂模式
            var basic = Demo.GetFactory(false);
            var basicRectangle = basic.Create(Shape.Rectangle);
            basicRectangle.Draw();

            var roundedSquare = Demo.GetFactory(true).Create(Shape.Square);
            roundedSquare.Draw();


            // instead
             var foo = Foo.CreateAsync();// Foo.CreateAsync();
            // or
             var foo2 = AsyncFactory.Create<Foo>();
            //
            var machine = new HotDrinkMachine();
            //var drink = machine.MakeDrink(HotDrinkMachine.AvailableDrink.Tea, 300);
            //drink.Consume();

            IHotDrink drink = machine.MakeDrink();
            drink.Consume();

            Console.ReadKey();

　　

输出：

***工厂方法模式 Factory Pattern Demo.***
***It's a modified version using method parameter(s).***

The tiger says: Halum.I prefer hunting.
The dog says: Bow-Wow.I prefer barking.
Basic rectangle
Rounded square
some work here
some work here
Available drinks
0: Tea
1: Coffee