Styjun

I am looking for a way to combine x amount of very similar CRUD functions into one without having to use x amount of if else statements to check the type of a generic.

I have Web API controllers that I want to make calls from like this:

Service.Get<FooModel>(number, type, part, version); 

This is to prevent having to have an extremely similar function for 40+ API endpoints. The issue is when I receive this in my service, I have to check the type of the generic given and compare with those 40+ object types in the one function. All of the models currently inherit from a base inherited model.

Current generic function

(Create, Update, Delete functions are similar):

public T Get<T>(string documentNr, string type, string part, string version) where T : InheritedModel, new()

 try
 
 T model = new T();

 if (typeof(T) == typeof(InheritedModel))
 
 using (var repo = new InheritedModelConsumer(ref _helper))
 
 model = (T)repo.Get(documentNr, type, part, version);
 
 
 else if (typeof(T) == typeof(FooModel))
 
 using (var repo = new FooModelConsumer(ref _helper))
 
 model = (T)(object)repo.Get(documentNr, type, part, version);
 
 
 else if (typeof(T) == typeof(ComponentModel))
 
 using (var repo = new ComponentModelConsumer(ref _helper))
 
 model = (T)(object)repo.Get(documentNr, type, part, version);
 
 
 else if (typeof(T) == typeof(BarModel))
 
 using (var repo = new BarModelConsumer(ref _helper))
 
 model = (T)(object)repo.Get(documentNr, type, part, version);
 
 
 ... and so on
 ... and so on
 ...
 else
 throw new Exception("Type T structure not defined");

 return model;
 
 catch (Exception)
 

 throw;
 
 finally
 
 _helper.Dispose();
 

This does work, but if it is possible I am looking for something where I can say at run time, "oh I have this object of Type T, and well since I know the functions all have the same inputs I'm going to instantiate this consumer of Type TConsumer, call consumer.Get(inputs), and then return an object of T to whatever API controller called me."

Edit

Example of a simple consumer class in use

 internal sealed class FooConsumer : RepositoryConsumer<Foo, FooRepository, FooFilter>
 
 public FooConsumer(ref SqlHelper helper) : base(ref helper) 

 public List<Foo> GetAll(string token)
 
 return _repo.Get().Where(x => Extensions.StringContainsToken(x.AccountName, token)).ToList();
 
 

Repository Consumer that all consumers inherit from .
T is the model, K is the Repository (custom ORM class), and O is Filter for the WHERE clause the ORM executes.

 public abstract class RepositoryConsumer<T, K, O> : IDisposable, IRepositoryConsumer<T> where T : class, new() where K : Repository<T, O>, new() where O : QueryFilter, new()
 
 /// <summary>
 /// Repository instance
 /// </summary>
 protected K _repo;

 /// <summary>
 /// Only constructor avaialble. MUst pass SqlHelper instance for transaction support
 /// </summary>
 /// <param name="sql"></param>
 public RepositoryConsumer(ref SqlHelper sql)
 
 _repo = Activator.CreateInstance(typeof(K), new object[] sql ) as K;
 

 /// <summary>
 /// Allow consumer initializations in using statements
 /// </summary>
 public void Dispose()
 

 

 /// <summary>
 /// Create instance of T
 /// </summary>
 /// <param name="data"></param>
 /// <returns></returns>
 public virtual int Create(T data)
 
 return _repo.Create(data);
 

 /// <summary>
 /// Bulk create instances of T
 /// </summary>
 /// <param name="contract"></param>
 /// <returns></returns>
 public virtual int Create(BaseBulkable<T> contract)
 
 return _repo.BulkCreate(contract);
 

 /// <summary>
 /// Get an instance of T based on a single PK field id
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public virtual T Get(long id)
 
 return _repo.Get(id);
 

 /// <summary>
 /// Gets all instances of T
 /// </summary>
 /// <returns></returns>
 public virtual List<T> GetAll()
 
 return _repo.Get();
 

 /// <summary>
 /// Updates an instance of T
 /// </summary>
 /// <param name="data"></param>
 /// <returns></returns>
 public virtual int Update(T data)
 
 return _repo.Update(data);
 

 /// <summary>
 /// Updates an instance of T based on a single PK field id
 /// </summary>
 /// <param name="id"></param>
 /// <param name="data"></param>
 /// <returns></returns>
 public virtual int Update(long id, T data)
 
 return _repo.Update(id, data);
 

 /// <summary>
 /// Deletes an instance of T
 /// </summary>
 /// <param name="data"></param>
 /// <returns></returns>
 public virtual int Delete(T data)
 
 return _repo.Delete(data);
 

 /// <summary>
 /// Deletes an instance of T based on a single PK field id
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public virtual int Delete(long id)
 
 return _repo.Delete(id);