为伪类工厂实现类字典

Question

我正在尝试建立一个这样的类工厂：

public class Toyota() {};
public class Bmw() {};
public class Mercedes() {};

public class BrandFactory
{
    private Dictionary<string, object> _Brands = new Dictionary<string, object> {
        {"Toyota", Toyota},
        {"Bmw", Bmw}, 
        {"Mercedes", Mercedes}
    }

   public object GetBrand(string brandName)
   {
       return = BusinessManagers[brandName].Invoke;
   }
}

这是一个想法，但它不起作用 - 我什至无法编译上面的代码，因为 Dictionary 无法将 'object' 与该函数相关联。我也试过Func<>，但在这种情况下，它需要以前的类型。

所以，这是我的问题： 这是实现这个“伪工厂”的正确方法吗？代码来自example code的示例

如果是这样，上面的代码中需要修复什么？

我之所以这么问是因为我需要基于从使用 Ajax 的客户端应用程序接收到的字符串创建一个新对象。喜欢：

AjaxCall -> String Containing Object Name -> Object Inoke -> Method Call -> Send result back to client

方法调用是所有Brand 实现的标准。

请问有人可以帮我吗？

谢谢。

Answer 1

您有多种选择。如果您最终使用Dictionary，我建议使其不区分大小写并注意避免使用KeyNotFoundExceptions。

public class CaseInsensitiveStringComparer : IComparer<string>
{
    public int Compare(string x, string y)
    {
        return string.Compare(x, y, ignoreCase: true);
    }
}

第一个选项是使用Dictionary<string, Func<object>>。

private IDictionary<string, Func<object>> _Brands 
    = new Dictionary<string, Func<object>> (new CaseInsensitiveStringComparer())
{
    {"Toyota", () => new Toyota() },
    {"BMW", () => new Bmw() }, 
    {"Mercedes", () => Mercedes() }
};

public object GetBrand(string brandName)
{
    Func<object> func;
    return _Brands.TryGetValue(brandName, out func)
        ? func() // invoking the delegate creates the instance of the brand object
        : null;  // brandName was not in the dictionary
}

第二个选项是使用Activator。您可以使用Dictionary<string,Type>，但如果您的类型名称与字符串匹配，则可能没有必要（请参阅下面的注释）。

public object GetBrand(string brandName)
{
    Type type;
    return  _Brands.TryGetValue(brandName, out type)
        ? Activator.CreateInstance(type) // activator invokes a parameterless constructor
        : null; // brandName was not in the dictionary
}

// vs.

return Activator.CreateInstance(null, brandName).Unwrap();
// Case sensitivity would be an issue here.
// Security could be an issue here.
// Creating objects based directly off of user input means any class 
// from any referenced assembly could be created if a hacker can learn
// out the namespaces and class names.

第三种选择是使用 IoC 容器进行解析。这为您提供了生命周期管理的一些灵活性。

第二种方法目前假定一个无参数的构造函数，而第一种和第三种方法将允许不同的构造函数签名。

在所有情况下，结果都是简单的object，这使得这种方法的实用性有限。如果所有这些“品牌”类都可以共享一个公共接口，那么您可以使用IBrand 或Dictionary 中的任何内容作为返回类型。

我正在检查错误数据（不在Dictionary 中的值）并返回null；如果这对您的用例更有意义，您可以选择抛出 Exception。*

Answer 2

你根本不需要字典：

public class DynamicFactory<T>  
{
    public static T Create(string className)
    {
        Type t = typeof(T);
        return (T)Activator.CreateInstance(
                    t.Assembly.FullName, 
                    t.Namespace + "." + className
                  ).Unwrap();
    }
}
namespace Brands
{
    public class CarBrand { }

    // The brands should be in the same namespace and assembly with CarBrand
    // and should inherit from CarBrand
    public class Toyota : CarBrand { };
    public class Bmw : CarBrand { };
    public class Mercedes : CarBrand { };

    public class Titanic { } // this one is not CarBrand

    class BrandFactory: DynamicFactory<CarBrand> { }

    // Below are unit tests using NUnit

    namespace BrandFactorySpecification 
    {
        static class Create
        {
            [TestCase("Toyota", Result = typeof(Toyota))]
            [TestCase("Bmw", Result = typeof(Bmw))]
            [TestCase("Mercedes", Result = typeof(Mercedes))]
            [TestCase("Titanic", ExpectedException = typeof(InvalidCastException))]
            [TestCase("unknown", ExpectedException = typeof(TypeLoadException))]
            [TestCase("String", ExpectedException = typeof(TypeLoadException))]
            [TestCase("System.String", ExpectedException = typeof(TypeLoadException))]
            [TestCase("ACarBrandFromAnotherNamespace", 
                          ExpectedException = typeof(TypeLoadException))]
            [TestCase("AnotherNamespace.ACarBrandFromAnotherNamespace",
                          ExpectedException = typeof(TypeLoadException))]
            //
            public static Type ShouldReturnCorrectType(string brandName)
            {
                return BrandFactory.Create(brandName).GetType();
            }

            [Test]
            public static void ForTitanic()
            {
                DynamicFactory<Titanic>.Create("Titanic")
                    .ShouldBeType(typeof(Titanic));
            }
        }

        namespace AnotherNamespace
        {
            public class ACarBrandFromAnotherNamespace : CarBrand { };
        }
    }
}

更新：在以下方面对代码进行了改进：

• 修复了 cmets 中提到的安全问题
• 提高了灵活性
  • 一个新的通用 class DynamicFactory<T> 现在可以在其他地方重复使用
  • Brands 可以位于其他命名空间和程序集然后 BrandFactory
• 添加了单元测试作为用法和规范的示例（使用它们需要的 NUnit）

Answer 3

这根本不是工厂的运作方式。首先，您需要一个可以作为汽车模型父级的超类：

public class CarModel() {};
public class Toyota() : CarModel {};
public class Bmw() : CarModel  {};
public class Mercedes() : CarModel  {};

现在您可以创建一个返回正确模型的工厂：

public class BrandFactory
{
    public T GetBrand<T>() where T : CarModel
    { 
        return new T(); 
    }
}

现在，当你想创建一个对象时，它很简单：

var factory = new BrandFactory();
var bmw = factory.GetBrand<Bmw>();