5

更新：这是 Codecampserver 中的 StaticFactory 是众所周知的模式的副本吗？

4

3 回答 3

0

你可以试试这样的...

public static class FooFactory
{
    private static readonly Dictionary<Type, Type> FooTypesLookup;

    static FooFactory()
    {
        FooTypesLookup = (from type in typeof(FooFactory).Assembly.GetExportedTypes()
                          let fooInterface =
                            type.GetInterfaces().FirstOrDefault(
                                x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IFoo<>))
                          where fooInterface != null
                          let firstTypeArgument = fooInterface.GetGenericArguments().First()
                          select new { Type = type, TypeArgument = firstTypeArgument })
            .ToDictionary(x => x.TypeArgument, x => x.Type);
    }

    public static IFoo<T> CreateFoo<T>()
    {
        var genericArgumentType = typeof(T);
        Type closedFooType;
        return FooTypesLookup.TryGetValue(genericArgumentType, out closedFooType)
                ? (IFoo<T>) Activator.CreateInstance(closedFooType)
                : null;
    }
}

或者更好的是，引入您最喜欢的 IoC 容器（Windsor、结构映射等）并在其中注册所有实现 IFoo 的类型，然后在需要时解析它们以代替 Activator.CreateInstance 调用。

于 2010-04-12T18:17:27.040 回答
0

你能描述一下你用这个机制解决的问题吗？很可能有一种更清晰的方法来处理它。

编辑

是的，代码有味道。您已经为任何类型留出了空间，但您随后将其约束回单一类型并生成运行时异常。为什么在这种情况下有一个类型参数？

于 2010-04-12T17:05:04.193 回答
0

编辑：请注意，这个答案是在编辑完全改变问题之前给出的。因此，它现在指的是最初陈述的问题中仅存在的事物。请原谅所有“悬空指针”。:-)

简短的回答：

使用您发布的代码，我看不到强制转换为IFoo<T>. 如果你不这样做，编译器会发出警告（至少在我的机器上）。

更详细的答案：

你的代码真的必须这样吗？更具体地说，您首先需要有问题的演员吗？

我假设您将或多或少地像这样调用您的工厂方法：

var stringFoo = FooFactory.CreateFoo<string>();

您必须string显式提供模板参数（在这种情况下），因为它不能从任何方法参数派生（在这种情况下是因为实际上根本没有任何参数）。显然，工厂方法将返回一个IFoo<string>.

现在，由于您必须在运行时显式指定类型，您也可以编写：

var stringFoo = StringFoo.Create();

因此在里面有一个工厂方法StringFoo，就像这样，无条件地做显而易见的事情：

public class StringFoo : IFoo<string>
{
    ...

    public static StringFoo Create()  // or alternatively, return an IFoo<string>
    {
        return new StringFoo();
    }
}

通过将此模式也应用于其他IFoo<T>实现，这将为您节省if链或switch块内部FooFactory.CreateFoo<T>，使您的代码更容易，并摆脱强制转换的必要性（您担心）。

不要误会我的意思，我知道支持多种对象类型的工厂方法在某些情况下很有用；但在你的情况下，它似乎造成的麻烦比它的价值还多。

PS：您可能会发现某些 IoC 容器的一个方面很有趣。它们通常需要配置，这包括为抽象接口注册具体类型（即实现类）的过程；例如（这里使用Autofac）：

var builder = new ContainerBuilder();
builder.RegisterType<StringFoo>().As<IFoo<string>>();

然后稍后，您可以请求抽象类型的对象实例：

using (var container = builder.Build())
{
    var stringFoo = container.Resolve<IFoo<string>>();
    ...
}

该Resolve方法是有趣的部分。您为它提供一个抽象类型，并使用注册的类型，它将返回一个具体的 type 对象StringFoo。看看它，如果它对你来说听起来不是矫枉过正！:-)

于 2010-04-12T17:32:12.123 回答