标签: factory-pattern

我在阅读了许多关于 C# 中的抽象工厂设计模式的文章后写了这个问题。我真的无法从所有这些文章提供的示例中获得现实世界的用例意义。我所能看到的只是汽车/计算机/电话等的一些基本示例。我知道它们对于提供简单的解释很重要。但我真的无法将其映射到现实世界中的任何东西，因为如果我真的遵循这样的示例，当我想要引入新对象时，我的代码将每隔一周更改一次。

下面是它的示例代码

namespace ClassLibrary1
{

    public interface AbstractProductA { }
    public class ProductA1 : AbstractProductA { }
    public class ProductA2 : AbstractProductA { }


    public interface AbstractProductB { }
    public class ProductB1 : AbstractProductB { }
    public class ProductB2 : AbstractProductB { }


    public interface AbstractFactory
    {
        AbstractProductA CreateProductA();
        AbstractProductB CreateProductB();
    }


    public class ConcreteFactoryA : AbstractFactory
    {
        public AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }

        public AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    public class ConcreteFactoryB …

我正在Room使用ViewModel. 一切都运转良好。但要求是我想提供一些对ViewModel使用的依赖AndroidViewModelFactory。我能够创建ViewModelFactory实现ViewModelProvider.Factory. 我将一个普通字符串作为 ViewModel 的依赖项传递。工厂类的代码是

public class TestViewModelFactory  implements ViewModelProvider.Factory{
    private static final String DEFAULT_LIMIT = "4";
    static Application application;
    static String created="ViewModelFactorySuccess";

    public static TestViewModelFactory createFactory(Activity activity) {
        application = activity.getApplication();
        if (application == null) {
            throw new IllegalStateException("Not yet attached to Application");
        }
        return new TestViewModelFactory(application, created);
    }
    public TestViewModelFactory(Application application, String created) {
        application=application;
        created=created;

    }
    @NonNull
    @Override
    public <T extends ViewModel> T create(@NonNull Class<T> …

我正在尝试扩展泛型类型类，但我无法让 VS 查看扩展方法。

当然，有很多方法可以解决这个问题，而且它肯定不是所有情况下的最佳实践，但我无法弄清楚为什么在下面两个明显相同的情况下，第一个有效而另一个无效。

首先，一个成功尝试扩展 List 类的例子（只是为了证明我可以处理基础知识）：

namespace Sandbox.ExtensionsThatWork
{
    public static class ListExtensions
    {
        public static List<TheType> ExtendedMethod<TheType>(this List<TheType> original)
        {
            return new List<TheType>(original);
        }

    }

    public class ExtensionClient
    {
        public void UseExtensionMethods()
        {
            List<string> a = new List<string>();
            List<string> b = a.ExtendedMethod();
        }
    }

}

但是，我想扩展的对象是这样的

namespace Sandbox.Factory
{
    public class Factory<T>
    {
        public static Thing<T> Create()
        {
            return new Thing<T>();
        }
    }

    public class Thing<T>{}

    public static class FactoryExtensions
    {
        internal static Thing<FactoryType> CreateFake<FactoryType>(this Factory<FactoryType> original)
        { …

问题

您好，\n以下代码示例会引发错误：

TypeError: Super constructor null of SecondChild is not a constructor\n    at new SecondChild (<anonymous>:8:19)\n    at <anonymous>:49:13\n    at dn (<anonymous>:16:5449)\n

目前我正在尝试了解问题到底是什么以及如何在 typescript/javascript 中实现工厂模式。有几种行为我不太理解：

\n
1. 如果我删除代码的第二个子项，则一切正常，除非我交换子项和父项导出的 index.ts 文件中导出语句的顺序。
\n
2. 如果我将文件 child.ts 和 secondary-child.ts 合并到一个定义这两个类的文件中，则异常也消失了
\n

\n
• 该错误是否与循环依赖相关？如果是这样，那么 typescript/javascript 中循环依赖背后的问题到底是什么？
\n
• 有人可以向我解释代码示例的行为吗？
\n

如果我实现父类而不使用类型“this”与工厂方法结合使用，则可以防止错误，但它看起来相当方便。抽象方法重复背后的目标是它返回一个子类实例。我可以在每个子类中实现它，但在我的现实世界项目中，复杂性要高得多。

项目结构：

src/\n  child.ts\n  factory.ts\n  index.ts\n  parent.ts\n  main.ts\n  second-child.ts\n

文件内容

主要.ts:

TypeError: Super constructor null of SecondChild is not a constructor\n    at new …

我正在尝试创建一个将传入类型的工厂,而不是将其硬编码为类型.但是,当我尝试将类型添加到类型.cpp文件内的工厂时,我将收到链接器错误.例如,他是我目前得到的链接器错误.

1> RandomClass.obj:错误LNK2019:未解析的外部符号"public:short __thiscall TemplatedFactory :: AddType(char const*)"(?? $ AddType @ VRandomClass @@@ TemplatedFactory @@ QAEFPBD @ Z)在函数"void _"中引用cdecl`动态初始化器'私有:静态短的RandomClass :: ID''(void)"(?? _E？ID @ RandomClass @@ 0FA @@ YAXXZ)

我试图让测试用例尽可能小,虽然它确实跨越了五个文件,它们非常小

BaseClass.h:http://codepad.org/MhZMw7t0

#pragma once
class BaseClass{ };

RandomClass.h:http://codepad.org/xoObzP8G

#pragma once
#include "BaseClass.h"
class RandomClass : public BaseClass
{
private:
    static short ID;

public:
    RandomClass();
    virtual ~RandomClass();
};

TemplatedFactory.h:http://codepad.org/qkcTBw24

#pragma once
#include <map>
using std::map;
#include "BaseClass.h"

template<typename Type> BaseClass* createType() { return new …

我有一组需要从DAOFactory获取的DAO(数据访问对象)(使用工厂方法模式).

现在我们有了DAO必须始终用参数初始化的情况,例如:(带字符串参数)

MyDataDAO myDAO = new myDAO("myProject", "myProjectWallName");

现在,拥有一堆DAO需要我们重构(使用工厂模式),这里是冲突的力量:

1. 如果我们重构我们的DAO不使用任何默认参数(可能是一件好事),我们可能需要为必须初始化的强制成员设置setter/getter.暗示可能无效的检查/断言遍布整个过程(坏事IMO)
2. 另一种方法是强制DAO的每个方法携带相应的强制参数以及它们已有的(太多数据/长参数列表 - 可能不好但可能是唯一的选择？)
3. 用春天!好吧,我们为一些纯粹无状态的DAO做了,它们确实不需要设置任何默认值.但我不认为Spring真的支持运行时构造函数 - 参数初始化,因为它在启动时创建并缓存对象.所以回到原点(Spring可能支持这个,但我真的还没有找到任何关于这个.帮助？:)

那么应该如何为使用工厂实例化的类设计一个"良好"的接口,即在这方面要遵循的最佳实践.到目前为止,我总是遇到非参数化构造函数的情况,我觉得有一个有效的需要/原因来获得参数.我个人觉得只有一个默认的构造函数并通过setter-getters设置所有东西是很糟糕的,打败了目前存在的构造函数来解决!

困惑...

我正在编写一个带有子类的php应用程序,因为我想有多种方法来创建一个对象,我正在做不同的工厂方法而不是多个构造函数.

我有一个User工厂方法

User::from_id
User::from_netid

我有几个子类User.我之前调用了父超级构造函数,但是当我切换到工厂方法时,构造函数不存在.

我有Student,一个子类User.为了使它工作,我不得不将几乎所有的超类工厂代码复制User::from_id到load_by_id,因为在这种情况下实例已经存在:

// In Student.php - Student extends User
public static function from_id_and_course($id, $course){
    $instance = new self();
    $instance->load_by_id($id);
    $instance->course = $course;
    ...
}

我想从子类中调用超类工厂方法作为起点,然后继续添加其他字段.像这样......

$instance = User::from_id($id);

要么

$instance = Student::from_id($id);

但在这些情况下,它给了我一个User对象,我需要一个Student对象.我能做到这一点的唯一方法就是这样做$instance = new self().

如何从子类中调用超类工厂方法作为创建新子类工厂方法的起点？

工厂模式由实现特定接口的类组成.它总是必须是一个界面吗？当我有从其他类继承而不是接口的子类时,它仍然是一个工厂方法吗？

我遇到了一个工厂类,如果我想替换下面的XmlSerializer代码,我不完全确定如何使用它.

样本模型

public class SampleData
{
    public string Name { get; set; }
    public string Country { get; set; }
}

现有守则

List<SampleData> objects = new List<SampleData>();
objects.Add(new SampleData() { Country = "Australia", Name = "aus" });

StringWriter writer = new StringWriter();

XmlSerializer serializer = new XmlSerializer(typeof(List<SampleData>));
serializer.Serialize(writer, objects);

工厂类

public static class CachingXmlSerializerFactory
{
    private static readonly Dictionary<string, XmlSerializer> Cache = new Dictionary<string, XmlSerializer>();

    private static readonly object SyncRoot = new object();

    public static XmlSerializer …

我正在寻找以类似于Java类的方式编写面向对象的JavaScript(JS)代码的最佳方法.

工厂函数(FF)看起来像是一种在JS中提供类类功能的非常有前途的方式,到目前为止,我一直在构建它们:

function FF(constructorArg)
{
   var _privateName = constructorArg;

   var publicMessage = "Hello StackOverflow";

   function publicMethodGetName() {
      return _privateName;
   }

   return {
      publicMethodGetName: publicMethodGetName,
      publicMessage: publicMessage
   };
}

但是,我最近发现,与原型方法不同,这种样式的FF为每个FF实例重新创建每个方法,因此可能会降低性能.

在这个优秀主题的第二个答案中,Eric Elliot谈到了FF:

如果将原型存储在父对象上,这可能是动态交换功能的好方法,并为对象实例化启用非常灵活的多态性.

我在网上找不到这个例子.任何人都可以向我解释我如何使用上面的FF来做到这一点？

如果我知道将从同一个FF创建许多对象,这是否意味着我可以将FF切换为使用原型方法？