标签: factory

Autofac的文档有一个有趣的页面,描述了它自动生成委托工厂的能力.它还强烈建议您在没有Autofac的情况下手动编写可以获得类似的结果.

我正在使用Unity for IoC并且希望避免将容器传递给需要创建其他对象的对象,那么如何在没有Autofac的情况下编写委托工厂？

我有一个带有自定义StructureMap控制器工厂的ASP.NET MVC 2应用程序来处理我的控制器的依赖注入:

public class StructureMapControllerFactory : DefaultControllerFactory
{
    public override IController CreateController(RequestContext context, string controllerName)
    {
        Type controllerType = base.GetControllerType(context, controllerName);
        return ObjectFactory.GetInstance(controllerType) as IController;
    }
}

我想知道如何在这个控制器工厂中处理异常,以便它们可以像在具有HandleError属性的控制器中一样重定向到〜/ Views/Shared/Error.aspx.尽管将CustomErrors属性设置为"On",但目前异常不会执行此操作.

目前我可以使用像"〜/ DoesNotExist/edit/1"这样的URL生成这样的异常.使用默认路由:

routes.MapRoute(
    "Default", // Route name
    "{controller}/{action}/{id}", // URL with parameters
    new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
);

MVC匹配此路由并将控制器名称"DoesNotExist"传递给我的控制器工厂.GetControllerType然后返回null并在对StructureMap的调用中导致空引用异常.然后我希望能够处理这个异常.

请注意,添加后续捕获所有路由将无法解决此问题 - MVC匹配默认路由.

我知道我可以通过在控制器的默认路由上设置约束来解决这个特殊问题,但问题是如何在工厂中使用普通的MVC~/Views/Shared/Error.aspx.

请注意,我不希望答案要求将控制器工厂紧密耦合到特定的MVC应用程序.理想情况下,此工厂应位于不在同一解决方案中的引用程序集中.

如果我想创建和实例使用"创建"构建策略然后想要使用"attributes_for"构建策略进行验证,是否可以这样做？如果我在工厂使用序列？机械师宝石有可能吗？

每当我遇到一个工厂将一个基于某种"低级"类型参数(如协议或外部资源的格式)的抽象基类实现返回给用户的情况时,我总是试图将其转换为将抽象类转换为具有内部"策略工厂"的具体类,以便用户可以将实现类型传递给构造函数并直接使用基类.

我注意到.Net框架选择以这种方式实现Socket(而不是创建一个DatagramSocket,你在构造时传递SocketType).有哪些指导方针可以决定何时将层次结构扁平化为像这样的单个具体类？

我最近一直在阅读有关工厂模式的文章.我试图找出实现它的最佳方法.在C#Agile Principles模式和实践的书中,建议是像这样创建工厂:

public class ShapeFactoryImplementation : ShapeFactory {
    public Shape Make(string name) {
        if (name.Equals("Circle"))
            return new Circle();
        else if (name.Equals("Square"))
            return new Square();
        else
            throw new Exception("ShapeFactory cannot create: {0}", name);
        }
    }

而不是...

public class ShapeFactoryImplementation : ShapeFactory {
    public Shape MakeCircle() {
        return new Circle();
    }

    public Shape MakeSquare() {
        return new Square();
    }
}

请告诉我你的想法是什么？或者可能有更好的方法来实现工厂模式？

我正在玩设计模式,事情进展顺利.我不确定的一件事是,当目前只有一个对象时,是否值得抽象出对象创建？

例如,我正在处理的项目包含两种不同的用户类型,它们之间没有任何关联.他们是IStudent和IStaff.对于有问题的应用程序,将永远不会有任何其他类型的用户(工作人员角色处理所有非学生与系统的交互).

在我的控制器中我可以简单地:

IStudent student = new Student();

或者我是这样的:

public static class UserFactory
{
    public static T Create<T>() where T : class
    {
        if(typeof(T) == typeof(IStudent))
            return new Student() as T;

        if (typeof(T) == typeof(IStaff))
            return new Staff() as T;

         throw new Exception("The requested user type is not valid.");
    }
}

然后:

IStudent student = UserFactory.Create<IStudent>();

这有点矫枉过正吗？我正试图在这些情况下找出最佳实践.

我已经使用Java很长一段时间了,但我从来没有发现过,有什么factories特别之处.有人可以向我解释一下吗？我有什么理由想要实现自己的factory(如果可能的话)？

在一个非常大的遗留应用程序中,我有没有实现这些接口的接口和类.

接口是基于类生成的,因此签名是相同的(除了接口在顶部添加另一个异常)并且名称相似(因此很容易从接口名称中找到类名).

为了获得接口的实现,我们做了一堆处理和记录调用,但基本上用于java.lang.reflect.Proxy委托给类.简化它看起来像这样:

// This will create a proxy and invoke handler that calls HelloWorld.doSomething
HelloWorldInterface i = MyProxyUtil.getInstance(HelloWorldInterface.class);
i.doSomething();

public interface HelloWorldInterface {
    public void doSomething() throws Exception;  
}

public class HelloWorld {
    public void doSomething() {
     //something
    }
}

是否有可能使用Spring注释处理,一般来说@Autowire所有类型的字段*Interface都有弹簧用于MyProxyUtil.getInstance(*Interface.class)注入实现？

这样

@Autowire HelloWorldInterface a;

HelloWorldInterface b = MyProxyUtil.getInstance(HelloWorldInterface.class);

@Autowire AnotherInterface c;

AnotherInterface d = MyProxyUtil.getInstance(AnotherInterface.class);


a == b
c == d

让我们假设我们有一个特征T.实现以下目标的最佳方法是:

• 编写实现的每个人都T应该被迫提供允许无参数初始化的可能性T,即我们可能必须强制执行可配置工厂.
• 所有仅依赖于实际初始化参数(某个实现A的T)的逻辑/数据应集中处理/存储,但应在工厂和工厂都可用A.

我看到实现这个(大约)的最简单/最简单的方法是为工厂添加特征并链接T到这个工厂:

trait T {
  val factory: TFactory
}
trait TFactory {
  def build(): T
  val description: String   // example for logic/data that only depend on the parameters
}

// example implementation:
class A(val factory: AFactory, paramA: Int, paramB: Int, paramC: Int) extends T

class AFactory(paramA: Int, paramB: Int, paramC: Int) extends TFactory {
  def build = new A(this, paramA, paramB, paramC)
  val description …

在Effective Java中,它提到"与构造函数不同,静态工厂方法在每次调用时都不需要创建新对象".

class Car{
     String color;
     Boolean spoiler;

     public Car(String s){
        color=s;
        spoiler = false;
     }

     public static Car redCar(){
        return new Car("red");
    }
  }

在主类:

    Car c2 = Car.redCar();
    Car c3 = Car.redCar();        

c2和c3是不同的对象.我没有得到"每次调用都不需要创建新对象"的上下文.