LINQ to SQL Covariance - est-ce la bonne façon de procéder?

Question

J'ai plusieurs bases de données - éléphants, girafes, gorilles, etc - dont chacun a un tableau d'entrées et de résultats nommé ElephantInputs, ElephantResults, GiraffeInputs, GiraffeResults, GorillaInputs, GorillaResults, respectivement. Je ne peux pas contrôler le nom de la table. J'utilise LINQ to SQL pour générer automatiquement les classes ElephantInputs, ElephantResults, GiraffeInputs, GiraffeResults, etc ....

Je souhaite écrire une seule classe, Processor(), capable de lire les entrées de l'une de ces bases de données et de les traiter. J'ai une méthode Factory qui instancie un processeur basé sur les choix de l'utilisateur.

La première chose que j'ai faite est de créer une interface pour les objets d'entrée et de résultat et une classe partielle pour chaque base de données afin que ses objets d'entrée et de résultat implémentent cette interface. Cela m'a donné une interface commune pour chaque animal. J'ai également créé une classe de référentiel pour chaque base de données qui a quelques méthodes pour renvoyer des éléments de la base de données.

public interface IBaseInput 
{ 
    int ID { get; set; } 
    string InputA { get; set; } 
    int InputB { get; set; } 
    double InputC { get; set; } 
} 

public interface IBaseResult 
{ 
    int ID { get; set; } 
    string ResultA { get; set; } 
    int ResultB { get; set; } 
    double ResultC { get; set; } 
} 

public interface IRepository<I, R> 
    where I : IBaseInput 
    where R : IBaseResult 
{ 
    IQueryable<I> GetInputs(); 
    IQueryable<R> GetResults(); 
} 

public partial class GorillaInput : IBaseInput 
{ 
} 

public partial class GorillaResult : IBaseResult 
{ 
} 

    // A concrete repository for Gorillas 
    public class GorillaRepository : IRepository<GorillaInput, GorillaResult> 
    { 

    GorillaDataContext db = new GorillaDataContext(GetConnectionString("Gorillas")); 

    public IQueryable<GorillaInput> GetInputs() 
    { 
     return from p in db.GorillaInputs select p; 
    } 

    public IQueryable<GorillaResult> GetResults() 
    { 
     return from r in db.GorillaResults select r; 
    } 
} 

Ensuite, je créé une interface pour mon processeur

public interface IProcessor 
{ 
    void Process(); 
} 

est ici un processeur de béton, et l'usine qui crée.

public class Processor<T, I, R> : IProcessor 
    where T : class, IRepository<I, R>, new() 
    where P : IBaseInput 
    where R : IBaseResult 
{ 

    public void Process() 
    { 
     // Do some stuff ... 

     T repository = new T(); // Get results from the rater tables 
     IEnumerable<I> inputs = repository.GetInputs(); 
     IEnumerable<R> results = repository.GetResults(); 

     // Do some stuff with inputs and outputs... 
    } 
} 

public static class ProcessorFactory 
{ 
    public static IProcessor GetProcessor(string animal) 
    { 
     switch (animal) { 
      case "Elephant": 
       return new Processor<ElephantRepository, ElephantInput, ElephantResult>(); 
      case "Giraffe": 
       return new Processor<GiraffeRepository, GiraffeInput, GiraffeResult>(); 
      case "Gorilla": 
       return new Processor<GorillaRepository, GorillaInput, GorillaResult>(); 
      default: 
       return null; 
     } 
    } 
} 

Enfin, voici le programme qui appelle le processeur:

class Program 
{ 
    public static void Main() 
    { 
     IProcessor processor = ProcessorFactory.GetProcessor("Gorilla"); 
     processor.Process(); 
    } 
} 

que je fais ce droit? Y a-t-il une manière moins compliquée? Merci

Answer 1

Avec tous vos types concrets mettant en œuvre des interfaces, pourquoi s'embêter avec des génériques du tout?

public class Processor 
{ 

    public void Process(IRepository repository) 
    { 
     // Do some stuff ... 

     IEnumerable<IBaseInput> inputs = repository.GetInputs(); 
     IEnumerable<IBaseResult> results = repository.GetResults(); 

     // Do some stuff with inputs and outputs... 
    } 
}