假设我有一个Player 课程。它有一个接收方向参数的Move 方法、一个接收两个整数的ChangePosition 方法、一个Disappear void 方法等。
我希望允许用户（可能使用列表框）能够将其中一些方法添加到 Player 对象的行为中。例如，他们可以选择让它向右移动，然后向下移动，然后消失。然后将他们选择的方法添加到事件中，以便当该事件发生时，他们选择的方法将执行。
以前有人做过类似的事情吗？做这个的最好方式是什么？ （我今年 13 岁，对设计模式了解不多）
【问题讨论】：
标签： c# winforms events delegates
首先，您应该将所有游戏逻辑放入一个 Engine 项目中，使用一个 Engine 类，该类单独负责（处理所有游戏逻辑并与 UI 和框架 [以及更低层，如果有是任何])。
其次，您可以拥有一个EngineAction 类，该类具有枚举EngineActionType（Move、ChangePos、Disappear、...）和其他属性。大致思路是这样的：
有一个枚举来保存类型：
public enum EngineActionType
{
Move,
ChangePos,
Disappear,
...
}
创建一个抽象类，对所有引擎动作类进行逻辑分组，并使用公共类型属性添加它们：
public abstract class EngineAction
{
public readonly EngineActionType Type;
protected EngineAction(EngineActionType type)
{
this.Type = type;
}
}
为每个引擎操作创建一个类，将所有需要的参数作为属性保存。它应该派生自 EngineAction 并将适当的 EngineActionType 发送到基本构造函数：
public class EngineActionMove : EngineAction
{
public int XDelta;
public int YDelta;
public EngineActionMove() : base(EngineActionType.Move)
{
}
}
public class EngineActionChangePos : EngineAction
{
...
}
...
毕竟，您可以将这些对象放在一个列表中，按照用户的命令，并对其进行迭代，根据它们的类型一个一个地执行它们：
foreach (EngineAction action in actionsToDo)
{
switch (action.Type)
{
case EngineActionType.Move:
EngineActionMove mvAction = (EngineActionMove)action;
// Example:
player.Position = player.Position.Offset(mvAction.XDelta,
mvAction.YDelta);
break;
case EngineActionType.ChangePos:
EngineActionChangePos cpAction = (EngineActionChangePos)action;
// Example:
player.Position = new Point(cpAction.X, cpAction.Y);
break;
case EngineActionType.Disappear:
// Just make the player disappear,
// because the operation needs no parameters
player.Disappear();
break;
case ...:
default:
// maybe throw an error here, to find errors during development
// it helps you find non-handled action types
}
}
进一步提示：UI 中的逻辑越少越好。总是。
编辑：Charleh 的好主意：
public interface IEngineAction
{
void Do(Player target);
}
public class EngineActionMove : IEngineAction
{
public int XDelta;
public int XDelta;
public void Do(Player target)
{
// Example
target.Position = ...
}
}
public class EngineActionDisappear : IEngineAction
{
public void Do(Player target)
{
// Example
target.Visible = false;
}
}
...
添加到列表示例：
var actionsToDo = new List<IEngineAction>();
actionsToDo.Add(new EngineActionDisappear());
actionsToDo.Add(new EngineActionMove { XDelta = 10, YDelta = 20 });
和迭代：
foreach (IEngineAction action in actionsToDo)
{
action.Do(player);
}
【讨论】：
有很多方法可以做到这一点。一种方法是使用工厂模式和策略模式。
public static class PlayerBuilder
{
public static Player BuildPlayer(BuildDefinition definition)
{
//logic in here to build a player -- pseudo-return value below as an example
var strategy = new PlayerMovementStrategy();
return new Player(strategy);
}
}
您的BuildDefinition 类可以根据您的用户选择构建。听起来他们不能只添加任何东西，而是从预定义选项列表中进行选择。根据您的 UI 选择创建适当的策略。
abstract class MovementStrategy
{
public abstract void Move();
public abstract void ChangePosition(Direction d);
}
class PlayerMovementStrategy
{
public override void Move()
{
//move
}
public override void ChangePosition(Direction d)
{
//change position
}
}
abstract class VisibilityStrategy
{
public abstract void Disappear();
}
class PlayerVisibilityStrategy
{
public void Disappear()
{
//poof
}
}
class Player
{
private readonly PlayerMovementStrategy movement;
private readonly PlayerVisibilityStrategy visibility;
public Player(PlayerMovementStrategy movement, PlayerVisibilityStrategy visibility)
{
this.movement = movement;
this.visibility = visibility;
}
public void Disappear()
{
visibility.Disappear();
}
public void Move(Direction d)
{
movement.Move(d);
}
}
【讨论】：
另一种选择是使用 Action 泛型，只需添加您想要的方法，然后您就可以在任何特定的播放器对象上调用这些操作。
这只是对别人提出的界面设计思路的一种替代，但你的风格可能更喜欢这种方法。
Action<Player> playerActions = p => {}; //Do Nothing
playerActions += p => { p.Move(3); }; //Move
playerActions += p => { p.ChangePosition(1, 1); }; //Change position
playerActions += p => { p.Disappear(); }; //Disappear
//Invoke Actions
Player player = new Player();
playerActions(player);
//Invoke on another object as well
Player player2 = new Player();
playerActions(player2);
【讨论】：