There is a slight possibility I could have worded the title incorrectly and I apologize if this comes across as already answered (and I just have not found it).
Having said that I have searched this site for several hours and have come across several very involved attempts (not clear enough) of using reflection, which I don't want to use because of performance reasons. I am already using Type.GetType() which searches through the .dll to find the type.
So, without further ado, here goes..
I have a method in a class that accepts a generic type:
public class SomeClass
{
public TList Execute<TList, TItem>(string text)
where TList : ICollection<TItem>, new()
where TItem : new()
{
TList list = new TList();
TItem item = new TItem();
...set properties and add to list...
...implementation not important...
return list;
}
}
Usage (calling method):
public void callingMethod(string typeNameString, string typeItemNameString)
{
Type T = Type.GetType(typeNameString);
Type Ti = Type.GetType(typeItemNameString);
SomeClass sc = new SomeClass();
// and here is where things falls apart drastically..
// not sure exactly what to do here as it seems noting works
var result = sc.Execute<T,Ti>("hello text"); //no luck..'T' is a variable but used as a type
var result = sc.Execute<Type.GetType(typeNameString),Ti>("hello text"); //no luck...operator '<' cannot be appliedto operands of type 'method group' and 'Type'
//This works fine
List<Invoice> _invoices = sc.Execute<Invoices, Invoice>("hello text");
}
public class Invoice
{ //properties omitted }
public class Invoices : List<Invoice>
{}
This seems like a very straight forward/logical approach, but is proving not to be the case.
What am I missing?
I appreciate the time and dedication individuals take to respond to questions on this forum.
