Activator.CreateInstance con un repository generico

Question

Sto provando a giocare con (quello che penso sia) una factory che crea un repository a seconda dell'enum che viene passato al metodo. Si presenta così:

RepositoryFactory

public class RepositoryFactory 
{ 
    public IRepository<IEntity> GetRepository(FormTypes formType) 
    { 
     // Represents the IRepository that should be created, based on the form type passed 
     var typeToCreate = formType.GetAttribute<EnumTypeAttribute>().Type; 

     // return an instance of the form type repository 
     IRepository<IEntity> type = Activator.CreateInstance(typeToCreate) as IRepository<IEntity>; 

     if (type != null) 
      return type; 

     throw new ArgumentException(string.Format("No repository found for {0}", nameof(formType))); 
    } 
} 

IRepository

public interface IRepository <T> 
    where T : class, IEntity 
{ 
    bool Create(IEnumerable<T> entities); 

    IEnumerable<T> Read(); 

    bool Update(IEnumerable<T> entities); 

    bool Delete(IEnumerable<T> entities); 
} 

FormTypes

public enum FormTypes 
{ 
    [EnumType(typeof(Form64_9C2Repository))] 
    Form64_9C2, 

    [EnumType(typeof(Form64_9BaseRepository))] 
    Form64_9Base 
} 

EnumExtensions

public static class EnumExtensions 
{ 

    /// <summary> 
    /// Get the Enum attribute 
    /// </summary> 
    /// <typeparam name="T">The attribute</typeparam> 
    /// <param name="enumValue">The enum</param> 
    /// <returns>The type to create</returns> 
    public static T GetAttribute<T>(this System.Enum enumValue) 
     where T : Attribute 
    { 
     FieldInfo field = enumValue.GetType().GetField(enumValue.ToString()); 
     object[] attribs = field.GetCustomAttributes(typeof(T), false); 
     T result = default(T); 

     if (attribs.Length > 0) 
     { 
      result = attribs[0] as T; 
     } 

     return result; 
    } 

} 

Form64_9C2Repository

public class Form64_9C2Repository : IRepository<Form64_9C2> 
{ 
    public bool Create(IEnumerable<Form64_9C2> entities) 
    { 
     throw new NotImplementedException(); 
    } 

    public bool Delete(IEnumerable<Form64_9C2> entities) 
    { 
     throw new NotImplementedException(); 
    } 

    public IEnumerable<Form64_9C2> Read() 
    { 
     throw new NotImplementedException(); 
    } 

    public bool Update(IEnumerable<Form64_9C2> entities) 
    { 
     throw new NotImplementedException(); 
    } 
} 

IEntity

public interface IEntity { } 

Form64_9C2 (stub)

public class Form64_9C2 : IEntity { } 

Calling tutto come:

class Program 
{ 
    static void Main(string[] args) 
    { 
     Console.WriteLine("Repository Factory Example \n\n"); 

     Business.Factory.RepositoryFactory factory = new Business.Factory.RepositoryFactory(); 

     // Get a 64 9C2 repository 
     var repo9c2 = factory.GetRepository(FormTypes.Form64_9C2); 
     Console.WriteLine(repo9c2); 
    } 
} 

Il mio problema è il mio type è sempre la risoluzione a null. Mi aspetto di ottenere un NotImplementedException, ma sto invece ottenendo il ArgumentException per non avere un formType valido.

Prima di implementare il mio IRepository<T>type/repository è stata con successo essere creato (codice funzionante here), tutte le idee? Sto solo iniziando a giocare con fabbriche, generici e simili - quindi se sto facendo qualcosa di sbagliato, ti prego di avvisare!

Answer 1

Il tuo codice non funziona per lo stesso motivo esattamente per cui questa linea non può essere compilato:

IRepository<IEntity> repo = new Form64_9C2Repository(); 

Fondamentalmente IRepository<IEntity> non è lo stesso di IRepository<Form64_9C2> anche se Form64_9C2 implementa IEntity.

Questo avrebbe potuto funzionare se il T parametro generico sull'interfaccia IRepository era covariant:

public interface IRepository<out T> where T : class, IEntity 
{ 
    IEnumerable<T> Read();  
} 

ma purtroppo questo significherebbe che può apparire solo come tipo di ritorno per i metodi, non come parametro. Che è un no-go per i tuoi metodi Update, Delete e Create. Si potrebbe comunque definire una struttura del genere:

public interface IReadonlyRepository<out T> where T : class, IEntity 
{ 
    IEnumerable<T> Read();  
} 

public interface IRepository<T>: IReadonlyRepository<T> where T : class, IEntity 
{ 
    bool Update(IEnumerable<T> entities); 
    bool Delete(IEnumerable<T> entities); 
    bool Create(IEnumerable<T> entities); 
} 

e avere il vostro metodo di GetRepository restituire un IReadonlyRepository<IEntity>.

Se questo non funziona per voi avrete bisogno di un ulteriore parametro per specificare il tipo di entità concreta in modo che si esegue la corretta fusione:

public IRepository<TEntity> GetRepository<TEntity>(FormTypes formType) where TEntity: class, IEntity 
    { 
     // Represents the IRepository that should be created, based on the form type passed 
     var typeToCreate = formType.GetAttribute<EnumTypeAttribute>().Type; 

     // return an instance of the form type repository 
     IRepository<TEntity> type = Activator.CreateInstance(typeToCreate) as IRepository<TEntity>; 

     if (type != null) 
      return type; 

     throw new ArgumentException(string.Format("No repository found for {0}", nameof(formType))); 
    } 
} 

e quando si chiama oltre a specificare il tipo di repository sarà necessario specificare il tipo di entità:.

var repo9c2 = factory.GetRepository<Form64_9C2>(FormTypes.Form64_9C2);