标签: factory-method

我在我的数据库模型之上有一个模型,并在我的存储库中映射对象.

然而,显然我是否直接在我的GetUsers中"选择新"或"选择工厂结果"如下所示.我在运行时得到错误,方法CreateFromDbModel没有转换为sql(System.NotSupportedException).

有没有解决的办法？我能以某种方式修补它吗？

想要使用工厂方法的原因是我可能会在其他地方实例化对象,并希望将"映射代码"保存在一个地方......

感谢任何评论,安德斯

    public IQueryable<User> GetUsers(bool includeTeams)
    {
        return from u in _db.sc_Players
               where (includeTeams || (!u.aspnet_User.sc_Player.IsTeam))
               select UserFactory2.CreateFromDbModel(u);
    }


    public static User CreateFromDbModel(sc_Player player)
    {
        return new User
                   {
                       Id = player.sc_PlayerID,
                       FirstName = player.FirstName.Trim(),
                       LastName = player.LastName.Trim(),
                       PresentationName = player.FirstName.Trim() + " " + player.LastName.Trim(),
                       LoginName = player.aspnet_User.LoweredUserName,
                       IsTeam = player.IsTeam,
                       Email = player.aspnet_User.aspnet_Membership.Email,
                       Password = player.aspnet_User.aspnet_Membership.Password
                   };
    }

根据这本书:

工厂模式的本质是"定义用于创建对象的接口,但让子类决定实例化哪个类.Plant方法允许类将实例化延迟到子类.

说我有一个创作者类:

class Product; //this is what the Factory Method should return
class Creator {
    public:
        Creator()   //ctor
        { //... }

        virtual Product make(//args)
        { //... }
}

好吧,这是我的创作者课程,但我不明白

Factory方法允许类将实例化延迟到子类

它与子类有什么关系？我应该使用什么子类？

有谁可以给​​我一些例子？

我正在尝试生成一个代表java.nio.file.Path使用静态方法的bean Paths.get(String path).我目前的Spring设置如下:

<bean id="myPath" class="java.nio.file.Paths" factory-method="get">
    <constructor-arg value="c:\\tmp\\" />
</bean>

但它带来了一个令人兴奋的回归No matching factory method found: factory method 'get'.任何想法为什么会这样？

介绍

MacApp Macintosh应用程序框架[App89]始终声明将工厂方法定义为Class*DoMakeClass()的抽象操作,其中Class是Product类.

这句话让我想到了有关工厂方法设计模式的命名约定的问题.

期望

我希望看到最佳实践或有用的示例,它们提供明确的工厂方法命名.

由于它可能依赖于一种语言,让我们考虑一组最流行的语言:C#,Java,C++和JavaScript.

上下文

对于上下文,我建议考虑以下类结构.我们有两个抽象类:Document和Application.应用程序包含文档列表,应该可以创建新文档.应用程序有一个工厂方法CreateDocument().

谢谢

在我的工厂方法中,我使用Switch语句来创建具体对象.这导致非常高的圈复杂度.这是一个示例代码:

private static UnitDescriptor createUnitDescriptor(string code)
{
     switch (code)
     {
         case UnitCode.DEG_C:
             return new UnitDescriptorDegC();

         case UnitCode.DEG_F:
             return new UnitDescriptorDegF();

         :
         :
         default:
             throw new SystemException(string.format("unknown code: {o}", code);
      }
  }

我怎样才能重构这个以减少圈复杂度？如果我使用反射创建对象或其他东西来构建对象,它比上面的方法更好吗？

在objective-c上下文中使用工厂方法的目的是什么？

我对Objective-c中工厂方法的使用有点困惑？这样做的用处是什么？

在objective-c中使用工厂方法的示例是什么？

有点困惑.任何解释都会有帮助!

TL;DR：Autofac 支持类似 AutoFixture 的fixture.Get()机制吗？

我正在使用 Autofac 并且需要调用异步工厂方法，如下所示：

class AppModel
{
     public static async Task<AppModel> CreateAsync(IDependency x, IDependency2 y)
     { ... }
}

对我来说执行此类方法并由 Autofac 提供参数的最简单方法是什么？即，我希望能够做类似的事情：

Task<AppModel> creationTask = <some autofaccery>(AppModel.CreateAsync);
var appModel = await creationTask();

其中<some autofaccery>表示与ContainerBuilder和/或IContainer和/或某种形式的生成的委托或类似的交互的某种机制，它本质上是简洁的，并且使我无法显式指定工厂方法的参数。即，我想避免像 atm 那样显式解析每个参数 [和/或必须在依赖项发生变化时更新它们]：

var appModel = await AppModel.CreateAsync( 
    container.Resolve<IDependency>(),
    container.Resolve<IDependency2>());

我位于基础设施组件领域，靠近组合根，可能会以编程方式定义组件注册和/或执行其他应限制在此处的肮脏操作。我不介意参与反射，因为它只被调用一次。

关键是我确实需要观察Exception所产生的任何结果Task。

这Task<T>在很大程度上是一个转移注意力的话题，但重点是，遵循定义同步工厂方法并让 Autofac 完成工作的正常模式不会成功（至少不会直接），即我不能只是改变它到：

     public static AppModel CreateAsync(IDependency x, IDependency2 y)
     { ... } …

我似乎无法在 Autofac 中解决这种情况：

• 我的业务逻辑需要一个 IFinal 类型的对象。
• 实现类 Final 有几个业务逻辑不知道的依赖，但可以通过 IoCContainer 直接解析。
• Final 还具有其他依赖项，这些依赖项仅在运行时由业务逻辑知道。
• 我希望能够在 IFinal 上使用拦截器，因此应通过 IFinal 注册和解析类 Final。

所以我试图为 IFinal 创建一个工厂，但我似乎无法得到正确的解决方案。

示例代码：

    public static void Main(string[] args)
    {
        ContainerBuilder builder = new ContainerBuilder();

        builder.RegisterType<Dependency>().As<IDependency>();

        builder.RegisterType<Final>().As<IFinal>();

        // this fails because context c is not available at the time finalObjectFactoryMethod is used
        builder.Register<Factory>((c,p)=>{
            var dependency = c.Resolve<IDependency>();
            Func<int, IFinal> finalObjectFactoryMethod =
                rta => c.Resolve<IFinal>(
                    new TypedParameter(typeof(IDependency), dependency),
                    new TypedParameter(typeof(int), rta)
                );
            return new Factory(finalObjectFactoryMethod);
        }).As<IFactory>();

        // this works but doesn't use …

GOF 谈论“工厂方法”模式的框架。框架需要对象，但对象的实现取决于应用程序，因此创建了创建对象的抽象方法。此外，由于需要返回类型，因此定义了所需对象的接口，它定义了该对象所需的 api。实际对象是由子类（具体应用程序）创建的。这是一种创作模式。

对于模板模式，唯一的变化是封装类不知道某些行为的实现，因此它将其抽象为方法，使用它，但将实现留给子类。这是行为模式。

两者之间唯一的区别是

1. Factory method is creational and Template is behavioural.
2. Factory method abstracts a method to create an object where as template pattern abstracts a method for some policy or algorithm. 

示例代码

 /**factory-method example**/
 public abstract class Application{          
        public void create(){
              View contentView = createContentView();
              Menu menu = contentView.obtainMenu();
              generateMenuItems(menu);
        }
        public abstract View createContentView(); //factory-method
        public void generateMenuItems(Menu menu){
              // some code
        }
 }

  /** Product Specification**/            
 public interface View{
      public abstract Menu obtainMenu(); …

我想构建某种FactoryFactory：基本上是一个返回工厂函数的通用函数。编写函数本身很简单，但我不知道如何为它做 TypeScript 类型。

该函数应该像这样使用：

const stubFactoryFunction = (...props) => (...values) => ({ /* ... */ });

const factory = stubFactoryFunction("prop1", "prop2");
const instance = factory("foo", 42);
console.log(instance); // { prop1: "foo", prop2: 42 }

起初，我尝试将值类型作为数组提供：

type FactoryFunction<T extends any[]> =
  <K extends string[]>(...props: K) =>
    (...values: T[number]) =>
      {[key in K[number]]: T[number]}

但这将导致{ prop1: string | number, prop2: string | number}，因为类型与数组索引不匹配。

接下来，我尝试将整个对象提供为泛型类型：

type FactoryFunction<T extends {[key: string]: any}> =
  (...props: (keyof T)[]) =>
    (...values: ???) => …