Un Référentiel De L'Usine De La Classe

public enum RepositoryType
{
    ClinicRepository,
    MedicationRepository,
    PatientRepository,
    TreatmentRepository
}

public class ObjectFactory<T>
{
    public static IRepository<T> GetRepositoryInstance(RepositoryType type)
    {
        switch (type)
        {
            case RepositoryType.ClinicRepository:
                return new what ?;

            default:
                return what ?
        }
    }
}

public interface IRepository<T>
{
    void Add(T item);
    void Remove(int id);
    void Update(T item);
    IList<T> GetAll();
    T GetItemById(int id);
}

Je suis en train de créer un RepositoryFactory classe et j'ai copié ce que j'ai fait jusqu'à présent. Quelqu'un pourrait-il m'aider à comprendre cela ? Je suis coincé !
Merci d'avance

edit :

Je veux quelque chose comme ceci à la fin. Est-il possible de faire 1 Référentiel de la classe et de mettre en œuvre quelque chose comme

dc.THATOBJECT.insertonsubmit(élément) ?

public class TreatmentRepository : IRepository<Treatment>
{
    public void Add(Treatment item)
    {
        using (PatientsDataContext dc = new PatientsDataContext())
        {
            dc.Treatments.InsertOnSubmit(item);
            dc.SubmitChanges();
        }
    }

OriginalL'auteur Kubi | 2011-01-12

c#repository

Le plus simple des usines, il faut juste que votre types dérivés de IRepository ont sans paramètre constructeurs.

public class ObjectFactory {
    public static TRepository GetRepositoryInstance<T, TRepository>() 
      where TRepository : IRepository<T>, new() {
        return new TRepository();
    }
}

Si vous avez besoin spécifique des constructeurs pour un type de référentiel, vous pouvez spécifier les objets comme un tableau d'objets et de les créer à l'aide de CreateInstance

public class ObjectFactory {
    public static TRepository GetRepositoryInstance<T, TRepository>(
      params object[] args) 
      where TRepository : IRepository<T> {
        return (TRepository)Activator.CreateInstance(typeof(TRepository), args);
    }
}

D'utiliser l'un de ces, vous avez juste besoin de dire

var treatmentRepo = 
    ObjectFactory.GetRepositoryInstance<Treatment, TreatmentRepository>();

Qu'est-ce que les avantages de l'utilisation d'un référentiel d'usine?

OriginalL'auteur Mark H

6

D'avoir quelque chose pour le retour, vous avez besoin d'écrire une classe qui implémente IRepository<T>.
```
public class SomeKindOfRepository<T> : IRepository<T>
{
    public void Add(T item)
    {
    }

    //and so on...
}
```
Il semble qu'il ya quatre grands types (ClinicRepository, MedicationRepository, etc.) - sont-ils très différents dans leur manière de "stocker" des choses? Si oui, faire une catégorie distincte pour chacun d'eux. Sinon l'utilisation de la même classe avec quelques champs de contrôler son comportement.

Mise à jour

Basé sur vos modifications et des commentaires, vous disposez d'un référentiel qui est vraiment quelques opérations sur une table. La seule chose qui varie, c'est la table dans laquelle il s'enroule autour de. Mais la table est un membre d'un contexte de données. De sorte que vous pourrait reporter le choix de la table à une classe dérivée.

Ce serait la classe de base:
```
public class GeneralRepository<TEntity, TContext> : IRepository<TEntity>
{
    protected abstract Table<TEntity> GetTable(TContext dc);

    public void Add(Treatment item)
    {
        using (TContext dc = new TContext())
        {
            GetTable(dc).InsertOnSubmit(item);
            dc.SubmitChanges();
        }
    }

    //and so on for other methods
}
```
Une classe dérivée n'aura qu'à spécifier comment sélectionnez une table dans le contexte:
```
public class TreatmentsRepository : GeneralRepository<Treatment, PatientsDataContext>
{
    protected override Table<Treatment> GetTable(PatientsDataContext dc)
    {
        return dc.Treatments;
    }
}
```
J'ai modifier la question. Je vais avoir un linqtosql contexte de données. Est-il faisable ?
+1 pour la mise à jour. Merci
basé sur la réponse que vous avez accepté, je dois dire avoir aucune idée de ce que votre question était en réalité! Vous avez demandé dans votre édition sur la réalisation de "cc.THATOBJECT.insertonsubmit(item)" c'est ce Que ma mise à jour.
Votre réponse était la réponse exacte pour ma question, mais le a accepté de répondre résout mon problème. Je souhaite que je pourrais choisir 2 réponses correctes.
Pas de problème, j'ai assez de points déjà.

OriginalL'auteur Daniel Earwicker
0

Vous pouvez le faire sans enum. Vous avez besoin soit d'un générique de référentiel de type, ou autre référentiel des types de la mise en œuvre de IRepository<T>. Si vous utilisez un générique référentiel, vous pouvez mettre en œuvre l'usine en faisant quelque chose le long des lignes de:
```
public class ObjectFactory<T>
{
    public static IRepository<T> GetRepositoryInstance()
    {
        return new Repository<T>();
    }
}
```
OriginalL'auteur Ilya Kogan

Je vous recommande d'utiliser une Inversion de Contrôle (IoC) conteneur pour cela. Dans l'Usine (ou vous pouvez même aller directement à le conteneur IoC), pourrait obtenir le type.

public interface IClinicRepository : IRepository<Clinic> {}


public class ObjectFactory
{
   public static IRepository<T> GetRepository(RepositoryType type)
   { 
     switch (type)
     {
         case RepositoryType.ClinicRepository:
             return container.Resolve<IClinicRepository>()
          default:
             throw new NotSupportedException()
     } 
   }
}

ou encore mieux, utiliser une méthode générique dans votre usine

   public static IRepository<T> GetRepository<T>()
   { 
       return container.Resolve<T>()
   }


   //to call it
   var repository = ObjectFactory.GetRepository<IClinicRepository>();

OriginalL'auteur bendewey

Vous devez vous connecter pour publier un commentaire.