在这种情况下如何停止投射？

Question

我有以下操作：

abstract class AAction
{}

class BlueAction: AAction
{
    void Foo1(){// do stuff}
    void Foo2(){// do stuff}
}

以及应该包含动作的插件：

class APlugin
{
    AAction _action;

    APlugin(AAction action)
    {
        _action = action;
    }

}

class BluePlugin: APlugin
{
    BluePlugin(): base(new BlueAction());
    {
    }

    voif Foo()
    {
        // do stuff with BlueAction's methods
        ((BlueAction)_action).Foo1();
        ((BlueAction)_action).Foo2();
    }
}

我正在尝试将此设计与设计模式相匹配，但没有成功。

我只想强制APlugin 的派生类拥有AAction

我可以这样做：

BlueAction act = (BlueAction)_action;
act.Foo1();
act.Foo2();

使用泛型（如建议的那样）不允许我拥有我真正需要的 APlugins 列表。

但这对我来说是不行的。有什么想法吗？

Answer 1

只保留 BlueAction 实例：

class APlugin
{
    AAction _action;

    APlugin(AAction action)
    {
        _action = action;
    }
}

class BluePlugin: APlugin
{
    BlueAction _blueAction = new BlueAction();

    BluePlugin(): base(_blueAction) 
    { 
    }

    void Foo()
    {
        // do stuff with BlueAction's methods
        _blueAction.Foo1();
        _blueAction .Foo2();
    }
}

Answer 2

假设你希望构造函数保持不变，你可以这样做：

class APlugin
{
    public AAction Action { get; private set; }

    APlugin(AAction action)
    {
        Action = action;
    }

}

class BluePlugin: APlugin
{
    private ActualAction
    {
        get { return Action as BlueAction; }
    }

    BluePlugin(): base(new BlueAction());
    {
    }

    void Foo()
    {
        // do stuff with BlueAction's methods
        ActualAction.Foo1();
        ActualAction.Foo2();
    }
}

Answer 3

使用泛型：

class APlugin<TAction> where TAction : AAction
{
    TAction _action;

    APlugin(TAction action)
    {
        _action = action;
    }

}

class BluePlugin: APlugin<BlueAction>
{
    BluePlugin(): base(new BlueAction());
    {
    }

    void Foo()
    {
        // do stuff with BlueAction's methods
        _action.Foo1();
        _action.Foo2();
    }
}