2

我有很多这样的方法：

public UIPCompanyButton AddCompanyButton (string name, Company company, UIEventListener.VoidDelegate methodToCall, GameObject contents)
{
    return UIPCompanyButton.Create (name, company, methodToCall, contents);
}

我想用这样的单一方法替换：

    public T AddButton<T,K>(string name, K item, UIEventListener.VoidDelegate methodToCall, GameObject contents) where T:UIPMenuButton
{
    return T.Create(name, item, methodToCall, contents);
}

这显然不适用于 T.Create 部分。我需要使用某种语法来执行此操作吗？

我也对具有相同结果的不同方法持开放态度：一个方法接受派生的 menuButton 并使用正确的“item”类创建正确的方法。

4

4 回答 4

3

不，你不能在泛型类型上调用静态方法——不能没有反射。除此之外，没有办法将泛型类型限制为具有特定的静态成员。最接近的是无参数构造函数约束。

于 2013-07-31T20:24:41.973 回答
2

你想要的是一个工厂来创建你的对象。这是一个小的工作示例。这可能不是实现工厂模式的最佳方式，但它应该能让你前进。

有关更深入的示例和说明，请参阅此页面。

public class Button {
    public string Whatever { get; set; }

    public Button() {
        Whatever = "Hello, world!";
    }
}

public interface IAddButton {

    Button CreateButton();
}

public class ClassToMakeButtonFor1 {

    public static void RegisterMe() {
        ButtonFactory.Register(typeof(ClassToMakeButtonFor1), new ButtonFactory1());
    }
}

public class ButtonFactory1 : IAddButton {

    public Button CreateButton() {
        return new Button();
    }
}

public class ClassToMakeButtonFor2 {

    public static void RegisterMe() {
        ButtonFactory.Register(typeof(ClassToMakeButtonFor2), new ButtonFactory2());
    }
}

public class ButtonFactory2 : IAddButton {

    public Button CreateButton() {
        var b = new Button { Whatever = "Goodbye!" };
        return b;
    }
}

public static class ButtonFactory {
    private static Dictionary<Type, IAddButton> FactoryMap = new Dictionary<Type, IAddButton>();

    public static void Register(Type type, IAddButton factoryClass) {
        FactoryMap[type] = factoryClass;
    }

    public static Button MakeMeAButton<T>() where T : class {
        return FactoryMap[typeof(T)].CreateButton();
    }
}

internal class Program {

    private static void Main(string[] args) {
        ClassToMakeButtonFor1.RegisterMe();
        ClassToMakeButtonFor2.RegisterMe();

        Button b = ButtonFactory.MakeMeAButton<ClassToMakeButtonFor1>();
        Console.WriteLine(b.Whatever);

        b = ButtonFactory.MakeMeAButton<ClassToMakeButtonFor2>();
        Console.WriteLine(b.Whatever);
        Console.ReadLine();
    }
}
于 2013-07-31T21:02:42.970 回答
1

您可以考虑使用一些接口（例如 ICreator）来定义您要调用的 Create 方法。

然后，您将类型参数限制为实现接口的类型（其中 T：ICreator）。

然后你会在实例上调用该方法，而不是静态方法。所以在你的情况下，也许你可以调用 item.Create(...)。

对你的情况有任何意义吗？

于 2013-07-31T20:54:55.893 回答
0

听起来您可能可以使您的 Button 类通用。根据每个派生类中存在多少逻辑，这可能对您不起作用。

class Button<T>
{
    public T Item { get; private set; }

    public Button(string name, T item, ...)
    {
        // Constructor code
    }
}

// Helper class for creation
static class Button
{
    public static Button<T> Create<T>(string name, T item, ...)
    {
        return new Button<T>(name, item, ...);
    }
}

然后，使用这个：

Button<Company> button = Button.Create("Name", company, ...);
于 2013-07-31T22:57:45.637 回答