抽象工厂模式

Question

抽象工厂模式的定义:提供一个接口，用于在不指定具体类的情况下创建相关或依赖对象的系列。

1. 在这里创建类意味着什么？
2. 能解释创建对象而不指定抽象工厂模式中的具体类意味着什么吗？

Answer 1

如果您熟悉.NET，请检查DbProviderFactory类。这个类提供了对任何数据库访问的抽象。该类定义了用于创建数据库连接、数据库命令等的工厂方法。所有这些方法都再次返回一般的抽象类型。工厂的具体实现取决于返回依赖于特定数据库服务器/驱动程序的连接类或命令类的具体实现。例如，SqlClientFactory返回SqlConnection、SqlCommand等，但是OracleClientFactory创建了OracleConnection、OracleCommand等。仅仅通过实例工厂，您就可以获得对所有提供者依赖类的单一访问点。

Answer 2

当客户端需要创建某种相关的对象时，此模式非常有用。如果我们需要创建相关或依赖对象的家族，那么我们可以使用抽象的工厂模式。我们可以在此模式中使用以下类：

AbstractFactory:为创建抽象产品的操作声明一个接口

ConcreteFactory:实现创建具体产品对象的操作

AbstractProduct:为产品对象类型声明接口

产品:定义要由相应的具体工厂创建的产品对象，实现AbstractProduct接口

Client:使用AbstractFactory和AbstractProduct类声明的接口

这里是工厂设计模式的实现。

interface IWorst
    {
        string Name();
        string Cost();
        string Millage();
    }
    interface IBest
    {
        string Name();
        string Cost();
        string Millage();
    }
    class Splender : IWorst
    {
        public string Name()
        {
            return "Splender";
        }
        public string Cost()
        {
            return "40000 Rupees";
        }
        public string Millage()
        {
            return "70 KM/Lit";
        }
    }
    class platina : IWorst
    {
        public string Name()
        {
            return "Platina";
        }
        public string Cost()
        {
            return "35000 Rupees";
        }
        public string Millage()
        {
            return "90 KM/Lit";
        }
    }
    class Vector : IWorst
    {
        public string Name()
        {
            return "Victor Plus";
        }
        public string Cost()
        {
            return "38000 Rupees";
        }
        public string Millage()
        {
            return "80 KM/Lit";
        }
    }
    class Shine : IWorst
    {
        public string Name()
        {
            return "Shine";
        }
        public string Cost()
        {
            return "45000 Rupees";
        }
        public string Millage()
        {
            return "60 KM/Lit";
        }
    }
    class Karizma : IBest
    {
        public string Name()
        {
            return "Karizma ZMR";
        }
        public string Cost()
        {
            return "115000 Rupees";
        }
        public string Millage()
        {
            return "30 KM/Lit";
        }
    }
    class Plusar : IBest
    {
        public string Name()
        {
            return "Plusar 220";
        }
        public string Cost()
        {
            return "90000 Rupees";
        }
        public string Millage()
        {
            return "35 KM/Lit";
        }
    }
    class Apache : IBest
    {
        public string Name()
        {
            return "Apache 200";
        }
        public string Cost()
        {
            return "85000 Rupees";
        }
        public string Millage()
        {
            return "40 KM/Lit";
        }
    }
    class CBR : IBest
    {
        public string Name()
        {
            return "CBR 250";
        }
        public string Cost()
        {
            return "125000 Rupees";
        }
        public string Millage()
        {
            return "25 KM/Lit";
        }
    }
    interface iBikeFactory 
    {
        IBest GetBest();
        IWorst GetWorst();
    }
    class HeroFactory : iBikeFactory
    {
        public IBest GetBest()
        {
            return new Karizma();
        }
        public IWorst GetWorst()
        {
            return new Splender();
        }
    }
    class BajajFactory : iBikeFactory
    {
        public IBest GetBest()
        {
            return new Plusar();
        }
        public IWorst GetWorst()
        {
            return new platina();
        }
    }
    class TVSFactory : iBikeFactory
    {
        public IBest GetBest()
        {
            return new Apache();
        }
        public IWorst GetWorst()
        {
            return new Vector();
        }
    }
    class HondaFactory : iBikeFactory
    {
        public IBest GetBest()
        {
            return new CBR();
        }
        public IWorst GetWorst()
        {
            return new Shine();
        }
    }
    enum MANUFACTURERS
    {
        HERO,
        BAJAJ,
        TVS,
        HONDA
    }
    class BikeTypeChecker
    {
        iBikeFactory factory;
        MANUFACTURERS manu;
        public BikeTypeChecker(MANUFACTURERS m)
        {
            manu = m;
        }
        public void CheckProducts()
        {
            switch (manu)
            {
                case MANUFACTURERS.HERO:
                    factory = new HeroFactory();
                    break;
                case MANUFACTURERS.BAJAJ:
                    factory = new BajajFactory();
                    break;
                case MANUFACTURERS.TVS:
                    factory = new TVSFactory();
                    break;
                case MANUFACTURERS.HONDA:
                    factory = new HondaFactory();
                    break;
            }
            Console.WriteLine("\n"+manu.ToString() + ":\n\nBest Bike: " +
            factory.GetBest().Name() + "\nCost : " + factory.GetBest().Cost() + "\nMillage : " + factory.GetBest().Millage()+ "\n\nWorst Bike: " + factory.GetWorst().Name() + "\nCost : " + factory.GetWorst().Cost() +
            "\nMillage : " + factory.GetWorst().Millage());
        }
    }
    class MainApp
    {
        static void Main(string[] args)
        {
            BikeTypeChecker checker = new BikeTypeChecker(MANUFACTURERS.HERO);
            checker.CheckProducts();
            Console.ReadLine();
            checker = new BikeTypeChecker(MANUFACTURERS.BAJAJ);
            checker.CheckProducts();
            Console.ReadLine();
            checker = new BikeTypeChecker(MANUFACTURERS.HONDA);
            checker.CheckProducts();
            Console.ReadLine();
            checker = new BikeTypeChecker(MANUFACTURERS.TVS);
            checker.CheckProducts();
            Console.Read();
       }
  }

Answer 3

我认为这里的模式是基于一组类的。我已经将它用于与类相关的一组类，这些类通过访问数据库的方式进行关联。

所以我会有一个名为NWindAbstractFactory.的抽象类这个类将返回一个IProductRepository和一个IOrderRepository.的两个抽象方法您不能直接实现任何东西，但是您的业务逻辑是针对这个抽象工厂和接口进行编程的。

然后，我将创建IProductRepository和IOrderRepository的具体实现。也许他们被称为SqlProductRepository和SqlOrderRepository.然后，我可以创建抽象工厂的具体实现，并将其命名为类似于NWindSqlFactory.的东西。

也许我会有另一个名为NWindXMLFactory的混凝土工厂，它能够创建一个XmlProductRepository和XmlOrderRepository.

然后，我可以在运行时决定我想要使用的抽象工厂的实现。也许是NWindSqlFactory或者NWindXMLFactory，甚至是NWindAccessFactory。

同样，我认为如果您有一组相关的类，但您不希望针对它们的具体实现进行编程，它就会工作。

您可以使用配置设置，该设置将使用反射来实例化所需的实际实现。你只需要一个设置就可以做到这一点。你只需要指定具体工厂--因为一旦你有了混凝土工厂，它就能得到所有其他的实现。