Maneira preferida de "mover" um objeto entre listas

Question

Eu tenho duas listas separadas de entidades:

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

EntityCollection Foo;
EntityCollection Bar;

Eu quero implementar uma operação para mover um objeto Qux Isso está na lista Foo para barrar. Qual é a melhor maneira de implementá -lo?

• Como um MoveTo método de instância em EntityCollection:

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

• Como um MoveFrom método de instância em EntityCollection:

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

• Como uma estática Move método em EntityCollection:

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

• Como um Move Método da instância na classe que contém as duas coleções:

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

Como alternativa, e como as entidades só podem estar em uma coleção de cada vez, eu poderia fazer com que as entidades rastreiam sua localização e a implementassem na própria entidade:

    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);

Quando apresentado com tantas opções, quero saber: onde o método de movimentação pertence? E porque?

Answer 1

Por fim, acho que não importa demais, então minha resposta suave seria não se preocupar.

Linguisticamente, o Moveto parece mais natural que o movimento - embora eu possa imaginar a implementação de ambos para a completude.

Conceitualmente, parece -me que nem instâncias de coleta nem a entidade que está sendo movida é "responsável" pela mudança, e isso pode me inclinar para colocar isso como um método estático - caso contrário, você está transmitindo alguma importância extra a uma das três coisas em operação.

Construir um titular para realizar o movimento parece bastante excessivo.

Mas depende de você realmente, e mais conhecimento de como essas coisas serão normalmente consumidas podem informar qual é a solução "certa".

Answer 2

Moveto e movefrom vão usar uma chamada para adicionar () e remover () para que você possa fazer os dois em uma função. Nesse caso, você pode fazer algo assim:

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

Que tal usar um método de extensão?

O código do cliente seria:

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

As assinaturas:

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

Fluente!