Bevorzugte Möglichkeit, ein Objekt zwischen den Listen zu „verschieben“

Question

Ich habe zwei separate Listen von Entitäten:

class EntityCollection : IList<Entity>
{
    //...
}

EntityCollection Foo;
EntityCollection Bar;

Ich möchte einen Vorgang implementieren, um ein Objekt zu verschieben Qux Das steht auf List Foo zu Bar. Was ist der beste Weg, um es umzusetzen?

• Als ein MoveTo Instanzmethode auf EntityCollection:

  public void MoveTo(EntityCollection to, Entity entity);
  
  // Client code
  Foo.MoveTo(Bar, Qux);
  

• Als ein MoveFrom Instanzmethode auf EntityCollection:

  public void MoveFrom(EntityCollection from, Entity entity);
  
  // Client code
  Bar.MoveFrom(Foo, Qux);
  

• Als statische Move Methode auf EntityCollection:

  public static void Move(Entity entity, EntityCollection from, EntityCollection to);
  
  // Client code
  EntityCollection.Move(Qux, Foo, Bar);
  

• Als ein Move Instanzmethode in der Klasse, die beide Kollektionen enthält:

  public void Move(Entity entity, EntityCollection from, EntityCollection to);
  
  // Client code
  Holder.Move(Qux, Foo, Bar);
  

Alternativ und da die Entitäten jeweils nur in einer Sammlung sein können, könnte ich die Entitäten selbst verfolgen und sie auf der Entität selbst implementieren:

    public void MoveTo(EntityCollection to)
    {
       if(Location != null)
           Location.Remove(this);
       to.Add(this);
       Location = to;
    }

    // Client code
    Entity e;
    e.MoveTo(Foo);

    // Later on...
    e.MoveTo(Bar);

Wenn ich so viele Möglichkeiten präsentiert habe, möchte ich wissen: Wo gehört die Bewegungsmethode? Und warum?

Answer 1

Letztendlich denke ich nicht, dass es zu sehr wichtig ist, also wäre meine weiche Antwort, sich nicht zu ärgern.

Sprachlich gesehen scheint Moveto natürlicher zu sein als Move aus - obwohl ich mir vorstellen kann, beide für die Vollständigkeit zu implementieren.

Konzeptionell fühlt es sich für mich an, dass weder Sammlungsinstanzen noch das Unternehmen "verantwortlich" für die Bewegung sind, und das könnte mich dazu neigen, dies als statische Methode zu setzen - ansonsten verleihen Sie einem der drei Dinge zusätzliche Bedeutung in Betrieb.

Einen Halter zu konstruieren, um dann den Umzug zu erreichen, scheint ziemlich übermäßig zu sein.

Aber es liegt wirklich an Ihnen, und mehr Wissen darüber, wie diese Dinge normalerweise konsumiert werden, kann darüber informieren, was die "richtige" Lösung ist.

Answer 2

MoveTo und MoveFrom werden beide einen Aufruf zu add () und remove () verwenden, damit Sie beide in einer Funktion ausführen können. In diesem Fall könnten Sie so etwas tun:

enum MoveDirection
{
    ToFoo = 0
    ToBar = 1
}

MoveItem(Entity entity, MoveDirection direction)
{
    if direction = 0
       //move entity from Bar to Foo
    elseif direction = 1
       //move entity from Foo to Bar
    endif
}

Answer 3

Wie wäre es mit einer Erweiterungsmethode?

Client -Code wäre:

Foo.Move(Qux).To(Bar);

Die Unterschriften:

public static Entity Move(this EntityCollection from, Entity entity)
public static void To(this Entity entity, EntityCollection to)

Fließend!