C# 如何控制/处理/编辑多个对象？

我对OOP很陌生，但我一直在玩弄C。如何控制多个对象

假设您有几何对象（三角形、球体等），它们都共享一个特性，即空间中的（x、y、z）点坐标。现在，单独移动每个不同的对象很容易。例如，rectangle.moveright（）；诸如此类

但假设我有n个不同的对象，我想作为一个组移动，有点像在桌面上标记图标/快捷方式，然后作为一个组移动它们

如何做到这一点？基本上，您有一个控制子对象的父对象

---

编辑：一个更具体的例子；假设我有10个不同类型的对象，我只想移动其中5个具有某些功能的对象，然后我想将另外4个对象移动到其他位置。始终作为一个组

所有要移动的对象都有一个共同点：它们可以移动。移动对特定对象的意义可能不同，但它们仍然是可移动的

在对象结构中反映这一点的一种方法是使所有此类对象实现相同的接口，将其称为

imovable

，然后为每个可移动对象提供接口的实现

---

通过这种方式，代码的其余部分可以调用此接口的方法，而不必真正关心正在移动的特定对象

没有内在的方法以OOP中描述的方式对对象进行分组。但是有几种方法可以达到同样的效果

假设您使用继承层次结构进行设置

首先定义一个名为Shape的基类，它只实现了X、Y、Z

public class Shape
{
    public int X {get;set;}
    public int Y {get;set;}
    pulbic int Z {get;set;}
}

然后用几个不同的形状扩展该类

public class Triangle : Shape
{
    public string classification {get;set;}
}

public class Square : Shape
{
    public double area {get;set;}
}

然后，您可以创建一个形状列表，其中包含扩展形状的任何类型的对象

List<Shape> ShapeSet;

ShapeSet.Add(myTriangle);
ShapeSet.Add(mySquare1);
ShapeSet.Add(mySquare4);

根据需要，可以从单个对象实例动态构建列表

---

这只是完成任务的一种方式，不一定是最好的方式，也不是唯一的方式。但这是一个很好的例子。（同样的事情也可以使用shape接口而不是类来完成）

这里是一个非常简单的示例。请注意，移动功能和点并不精确，显然需要实现才能使其正常工作

创建一个接口和抽象类，以允许对象组的继承和多态性

public interface IPositionable
{
 void Move(int x, int y, int z);
}

public abstract class Positionable : IPositionable
{
 public int x { get; set; }
 public int y { get; set; }
 public int z { get; set; }

 public void Move( int x, int y, int z )
 {
    this.x += x;
    this.y += y;
    this.z += z;
 }
}

下一步，将这些应用到您将使用的形状类型中

public class Rectangle : Positionable{}
public class Triangle : Positionable{}
public class Square : Positionable{}

基本部件准备好后，应使用中介模式

public class PositionMediator
{
 public List<IPositionable> Group { get; set; }
 public PositionMediator()
 {
    Group = new List<IPositionable>();
    Group.Add(new Rectangle());
    Group.Add(new Triangle());
    Group.Add(new Square());
 }
 public void MoveGroup( int x, int y, int z )
 {
    foreach( var pos in Group )
    {
        pos.Move(x,y,z);
    }
 }
}

---

其中一个问题是将其视为试图移动现实世界中的对象。如果你有10个弹珠，你想移动其中的5个，你会怎么做？你可以一次一个地将它们全部移动到你想要它们去的地方；或者，您可以将它们分组并移动它们。无论哪种方式，它们都不会神奇地移动自己，它们必须被某种东西告知移动

我将识别组中行为的联合，并在某种界面中公开这些行为（例如

imovable

）。然后我会对“移动器”进行建模。移动器会拾取它感兴趣的对象（或者你可以给它一些对象，然后将拾取行为移动到“拾取器”对象），然后你告诉移动器去哪里。它将命令转换为它所引用的每个对象的命令

示例

IMoveable

：

public interface IMoveable
{
    void MoveTo(Position position);
    void MoveBy(int dx, int dy);
}

示例

Mover

：

public class Mover
{
    private List<IMoveable> _moveables = new List<IMoveable>();

    public void AddAsTarget(IMoveable moveable)
    {
        _moveables.Add(moveable); // Null checks, and such, yada...
    }

    public void Reposition(int dx, int dy)
    {
        foreach(var moveable in _moveables)
        {
            moveable.MoveBy(dx, dy);
        }
    }
}

公共类移动器
{
私有列表_moveables=新列表（）；
公共无效添加目标（IMoveable-moveable）
{
_moveables.Add（moveable）；//空检查等等，yada。。。
}
公共空间重新定位（int-dx，int-dy）
{
foreach（var可移动在_可移动中）
{
MoveBy（dx，dy）；
}
}
}

---

总的来说，它必须适合您的用例。你可能会对OOP发疯，但不应该模拟现实世界。只需建模，直到问题得到解决并被理解。更难的部分是确定是通过接口还是继承对对象进行分组。

+1对于中介模式，尽管我不知道我会将形状与基类绑定在一起。它很容易被滥用。

public interface IMoveable
{
    void MoveTo(Position position);
    void MoveBy(int dx, int dy);
}

public class Mover
{
    private List<IMoveable> _moveables = new List<IMoveable>();

    public void AddAsTarget(IMoveable moveable)
    {
        _moveables.Add(moveable); // Null checks, and such, yada...
    }

    public void Reposition(int dx, int dy)
    {
        foreach(var moveable in _moveables)
        {
            moveable.MoveBy(dx, dy);
        }
    }
}