Alternative To Generic Methods where Type is known at runtime

Curry generics

Since you don't want to use reflection to call generic methods, I'll give you an alternative: Curry the generic parameter. I hope that makes sense.

---

To handle operations that depend on the generic type, we will have three auxiliary types:

• A non-generic interface.
• A generic helper class that implements the interface.
• A static non-generic utility with a dictionary of those.

The idea is that the interface will have non-generic versions of the methods you want to call. And we will use the utility to get an object that implement the interface passing passes the generic parameter we want.

---

For the interface, I'll call it ITypeCurry for the answer. Hopefully you can give it a better name. And a class that implements it TypeCurry<T>.

internal class TypeCurry<T>: ITypeCurry { // … } 

And a non-generic utility, which will have a a dictionary of these, it looks like this:

internal static class CurryUtility { Dictionary<Type, ITypeCurry> _curryDictionary = new(); // C# 9.0 public static ITypeCurry GetOrCreate<T>() { var type = typeof(T); if (_curryDictionary.TryGetValue(type, out var curry)) { return curry; } curry = new TypeCurry<T>(); _curryDictionary[type] = curry; return curry; } public static ITypeCurry? Get(Type type) { if (_curryDictionary.TryGetValue(type, out var curry)) { return curry; } return null; } } 

And we will use that to solve the problem.

---

Example

Instead of this:

Sync.AddTablePoco(typeof(MyTablePoco1)); 

We will do this:

Sync.AddTablePoco<MyTablePoco1>(); 

Inside of AddTablePoco<T>, we need to call CurryUtility.GetOrCreate<T>(). So that when we get to:

Sync.SyncTable<pocoClass>(); <-- compiler does not like this 

We can do this instead:

CurryUtility.Get(pocoClass)?.SyncTable(); 

How does that work? Like this:

internal interface ITypeCurry { void SyncTable(); } internal class TypeCurry<T>: ITypeCurry { public void SyncTable() { Sync.SyncTable<T>(); } } 

As you can see ITypeCurry only needs to have SyncTable, and does not need the generic parameter. It has been curried.

---

What if we just use reflection?

Calling a generic method looks like this:

var method = typeof(Sync).GetMethod(nameof(Sync.SyncTable)); var generic = method.MakeGenericMethod(pocoClass); generic.Invoke(null, null); 

Of course we don't want to do that every time. So let us wrap it in a delegate and store it to use it later…

Wrap that in a delegate:

var deleg = (Action)generic.CreateDelegate(typeof(Action)); // Pre .NET 5.0 

Store in a dictionary… Hey!

internal static class CurryUtility { static Dictionary<Type, Action> _syncTableActions = new(); // C# 9.0 public static void SyncTable(Type type) { if (_syncTableActions.TryGetValue(type, out var action)) { action(); } var method = typeof(Sync).GetMethod(nameof(Sync.SyncTable)); var generic = method.MakeGenericMethod(pocoClass); action = (Action)generic.CreateDelegate(typeof(Action)); _syncTableActions[type] = action; action(); } } 

If we are going to have multiple of these methods to call per type, instead of having a dictionary for each one, it would be useful to have an object that holds all the methods for a type. That object would have a non-generic interface, because that is the point. We can make that an explicit literal interface, and just return the object. Plus, if the actual class that implements the interface is generic, we don't need any reflection (simpler code, easier to read, less error prone). And I have already shown how that looks like.

I could add that you can use Activator if you need to instantiate the generic class without knowing the type…

internal static class CurryUtility { static Dictionary<Type, ITypeCurry> _curryDictionary = new(); // C# 9.0 public static ITypeCurry GetOrCreate<T>() { var type = typeof(T); if (_curryDictionary.TryGetValue(type, out var curry)) { return curry; } curry = new TypeCurry<T>(); _curryDictionary[type] = curry; return curry; } public static ITypeCurry? GetOrCreate(Type type) { if (_curryDictionary.TryGetValue(type, out var curry)) { return curry; } curry = (ITypeCurry)Activator.CreateInstance(typeof(TypeCurry<>).MakeGenericType(type)); _curryDictionary[type] = curry; return curry; } } 

---

Aside

For your FindRecordsToSync, which looks like this:

async Task<Ienumerable<?>> FindRecordsToSync(Type tableEntity) 

You could have it be like this:

async Task<IEnumerable<T>> FindRecordsToSync<T>() 

What I don't know is where. However I suspect that would be part of TypeCurry<T>, which makes it:

async Task<IEnumerable<T>> FindRecordsToSync() 

Alternatively and since you are using reflection (e.g. GetProperty) to read the POCO anyways, you could do this:

async Task<IEnumerable> FindRecordsToSync() 

Classes that implement IEnumerable<T> also implement the non-generic interface IEnumerable, so you can just use that.

Change this:

private async Task<Ienumerable<?>> FindRecordsToSync(Type tableEntity) 

To this:

using System.Collections; private async Task<IEnumerable> FindRecordsToSync(Type tableEntity) 

Now as I understand it from your comment, your code uses typeof(T) to get the type, so you believe you need the T. But you can actually get the type from the object itself, like this:

public static async Task<int> UpsertAsync(this IDbConnection db, IEnumerable entitiestoUpsert, IDbTransaction transaction = null) where T : class { var contribType = typeof(SqlMapperExtensions); var type = entitiestoUpsert.GetType().GetGenericArguments().Single(); //Etc....