moyen privilégié de « déplacer » un objet entre les listes

Question

J'ai deux listes distinctes d'entités:

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

EntityCollection Foo; 
EntityCollection Bar; 

Je veux mettre en œuvre une opération pour déplacer un objet Qux qui est sur la liste Foo Bar. Quelle est la meilleure façon de l'implémenter?

• En tant que méthode d'instance MoveTo sur EntityCollection:

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

• En tant que méthode d'instance MoveFrom sur EntityCollection:

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

• En tant que procédé Move statique sur EntityCollection:

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

• En tant que méthode d'instance Move la classe qui détient des collections de Both:

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

Alternativement, et étant donné que les entités ne peuvent être une collection à la fois, je pouvais avoir la les entités suivent elles-mêmes leur emplacement et l'implémentent sur l'entité elle-même:

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

d avec autant d'options, je veux savoir: d'où vient la méthode de déplacement? Et pourquoi?

Answer 1

En fin de compte, je ne pense pas que ce soit trop important, donc ma réponse douce serait de ne pas s'inquiéter.

Linguisticement, MoveTo semble plus naturel que MoveFrom - bien que j'imagine que l'implémentation soit complète. D'un point de vue conceptuel, il me semble que ni les instances de collection ni l'entité déplacée ne sont "responsables" du déplacement, et cela pourrait m'inciter à mettre cela comme une méthode statique - sinon vous donnez une importance supplémentaire à un des trois choses en fonctionnement.

Construire un support pour ensuite accomplir le mouvement semble plutôt excessif.

Mais c'est vraiment à vous de décider, et une meilleure connaissance de la façon dont ces choses seront typiquement consommées peut informer quelle est la "bonne" solution.

Answer 2

Comment utiliser une méthode d'extension?

code client serait:

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

Les signatures:

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

Fluent! MoveTo et MoveFrom vont tous deux utiliser un appel à Add() et Remove() afin que vous puissiez faire les deux dans une seule fonction.

Answer 3

Dans ce cas, vous pourriez faire quelque chose comme ceci:

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 
}