1.簡單工廠模式：調用類只需要向工廠類請求方法，由工廠決定創建出哪個類的實例，而不需要關心被調用類的實現過程。

優勢：調用類 和 被調用類分離，調用類需要時只需要向工廠請求，避免了調用類和被調用類之間的硬耦合。

缺陷：被調用類更改 工廠類也需要同步更改。

實例：

 public interface IAnimal
    {
        void Eat();
    }
    public class Cat : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine(
 
"我是小貓咪，當然吃魚了..");
        }
    }
    public class Dog : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小狗狗，記得給我帶骨頭來啊..");
        }
    }

    public class AnimalFactory
    {
        public IAnimal GetAnimal(string animalType)
        {
            
 
if (animalType=="cat")
            {
                return new Cat();
            }
            if (animalType=="dog")
            {
                return new Dog();
            }
            return null;
        }
    }

  class Program
    {
        static void Main(string[] args)
        {
            IAnimal animal;
            animal 
 
= new AnimalFactory().GetAnimal("cat");
            animal.Eat();
            Console.WriteLine("----------------");

            animal = new AnimalFactory().GetAnimal("dog");
            animal.Eat();
            Console.ReadLine();
        }
    }

2.工廠模式：如果我們不想在工廠類中加判斷，可以為不同的類提供不同的工廠，不同的工廠生產不同的產品。

缺陷：調用類和工廠類之間存在硬編碼耦合。

實例：

  public interface IAnimal
    {
        void Eat();
    }
    public class Cat : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小貓咪，當然吃魚了..");
        }
    }
    public class Dog : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小狗狗，記得給我帶骨頭來啊..");
        }
    }

    public class CatFactory
    {
        public IAnimal GetAnimal()
        {
            
                return new Cat();
         }
    }

    public class DogFactory
    {
        public IAnimal GetAnimal()
        {

            return new Dog();
        }
    }

 class Program
    {
        static void Main(string[] args)
        {
            IAnimal animal;
            animal = new CatFactory().GetAnimal();
            animal.Eat();
            Console.WriteLine("----------------");

            animal = new DogFactory().GetAnimal();
            animal.Eat();
            Console.ReadLine();
        }
    }

3.抽象工廠： 使用簡單工廠模式，需要在工廠類增加邏輯判斷，而使用工廠模式，又造成了調用類和工廠類的硬編碼耦合，所以我們可以在新建一個類，這個類不制造具體的被調用對象，而是只制造工廠對象。

實例：

  public interface IAnimal
    {
        void Eat();
    }
    public class Cat : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小貓咪，當然吃魚了..");
        }
    }
    public class Dog : IAnimal
    {
        public void Eat()
        {
            Console.WriteLine("我是小狗狗，記得給我帶骨頭來啊..");
        }
    }


    public  interface IFactory{
        IAnimal GetAnimal();
    }

    public class CatFactory:IFactory
    {
        public IAnimal GetAnimal()
        {
            
                return new Cat();
         }
    }

    public class DogFactory : IFactory
    {
        public IAnimal GetAnimal()
        {

            return new Dog();
        }
    }


    public class AbstractFactory
    {
        public IFactory GetFactory(string factoryname)
        {
            if (factoryname == "cat")
            {
                return new CatFactory();
            }
            if (factoryname == "dog")
            {
                return new DogFactory();
            }
            return null;
        }
    }

 class Program
    {
        static void Main(string[] args)
        {
            IFactory factory;
            factory = new AbstractFactory().GetFactory("cat");
            factory.GetAnimal().Eat();
            Console.WriteLine("----------------");

            factory = new AbstractFactory().GetFactory("dog");
            factory.GetAnimal().Eat();
            Console.ReadLine();
        }
    }

簡單工廠模式、工廠模式、抽象工廠模式