Método de refactorización que contiene consultas LINQ

Question

Tengo problemas para decidir la mejor forma de refactorizar un método que contiene consultas LINQ que son muy similares pero no idénticas.

Considere un método que es algo a lo largo de estas líneas:

public SomeObject GetTheObject(IMyObject genericObject) { 
    Type t = genericObject.GetType(); 
    SomeObject so = null; 

    switch(t.Name) { 
     case "Type1": 
      var object1 = (from o in object1s where o.object1id == genericObject.id).FirstOrDefault(); 
      so = (SomeObject)object1; 
     break; 
     case "Type2": 
      var object2 = (from o in object2s where o.object2id == genericObject.id).FirstOrDefault(); 
      so = (SomeObject)object2; 
     break; 
     default: 
     break; 
    } 

    return so; 
} 

Esto es sólo un ejemplo, pero imagino que estoy necesitando para ejecutar una consulta diferente (diferente, ya que utiliza una ObjectSet diferente, utiliza un poco diferentes campos (object1id vs object2id) y devuelve un tipo diferente. Aparte de eso, las consultas son las mismas.

¿Hay alguna manera sensata de refactorizar este tipo de método? Parece que me he perdido algo obvio. Tal vez tengo que usar el método exacto y no puedo evitar volver a escribir la consulta, solo se ¡ems como DEBO poder de alguna manera!

Cualquier punteros apreciado considerablemente

Answer 1

Tal vez lo que ha simplificado el escenario, pero la parte mal olor de su función es el elenco de SomeObject. ¿No podría simplemente trabajar con interfaces y (si es necesario) emitir el resultado en el sitio de llamadas? Puede hacer que su Type1 y Type2 implementen una interfaz común donde id1 e id2 están expuestos como id, por ejemplo (o decorarlos si no controla Type1 y Type2)

I.e.

public static IMyObject GetTheObject(List<IMyObject> theList, int id) 
{ 
    var ret = (from o in theList 
     where o.id==id 
     select o).FirstOrDefault(); 

    return ret; 
} 

Por ejemplo, si usted tiene:

public interface IMyObject {int id {get;}} 

    public class Foo : IMyObject {public int id {get; set;}} 
    public class Bar : IMyObject {public int id {get; set;}} 

que puede hacer:

var l1 = new List<IMyObject>(){new Foo(){id=1}, new Foo(){id=2}}; 
var l2 = new List<IMyObject>(){new Bar(){id=1}, new Bar(){id=2}}; 

var obj1 = Test.GetTheObject(l1, 1); 
var obj2 = Test.GetTheObject(l2, 2); 

y emitir los objetos después de llamar a la función, si es necesario.

EDIT: si le pegan con objetos concretos y moldes, la mejor refactorización que podía llegar a es:

public static SomeObject GetTheObject(IMyObject genericObject) { 
    Type t = genericObject.GetType(); 

    Func<SomeObject, bool> WhereClause = null; 
    IEnumerable<SomeObject> objs = null; // IEnumerable<T> is covariant, 
         // so we can assign it both an IEnumerable<object1> 
         // and an IEnumerable<object2> (provided object1 and 2 are 
         // subclasses of SomeObject) 

    switch(t.Name) { 
     case "Type1": 
      WhereClause = o => ((Object1)o).object1id == genericObject.id;  
      objs = object1s; 
     break; 
     case "Type2": 
      WhereClause = o => ((Object2)o).object2id == genericObject.id;  
      objs = object2s; 
     break; 
    } 

    var ob = objs 
    .Where(WhereClause) 
    .FirstOrDefault(); 

    return (SomeObject)ob; 
}