Generate a generic list of some given type

My friend is trying to create a utility function that is given some Type and in that function it creates a generic List of that type. We're having trouble creating that list:

public static List<T> GetQueryResult(string xpathQuery, Ty开发者_如何转开发pe itemType) {

  // this line does not work:
  List<itemType> lst = new List<itemType>();

  return lst;
}

Are there any easy solutions to this?

UPDATE:

Is there any way to basically do this???

List<T> lst = new List<T>(); 
foreach (Sitecore.Data.Items.Item i in items) { 
  lst.Add(new T(i)); 
}

---

public static List<T> GetQueryResult<T>(string xpathQuery/*, Type itemType you don't need this because you specified the Type with T*/) {

  // this line works now:
  List<T> lst = new List<T>();

  return lst;
}

Then you would call the method like so:

List<int> results = GetQueryResult<int>("xpathQuery");

Edit:

Are you wanting to do something like this?

List<YourType> lst = items.Select<Sitecore.Data.Items.Item, YourType>(
siteCoreItem => new YourType()
{
   PropertyA = siteCoreItem.PropertyA,
}
);

If YourType inherrits from Sitecore.Data.Items.Item you can use Cast:

List<YourType> list = items.Cast<YourType>();

---

Define that method like this:

    public static List<T> GetQueryResult<T>(string xpathQuery)
    {
        List<T> lst = new List<T>();

        // do stuff

        return lst;
    }

and call it like this:

 List<SomeType> items = SomeClass.GetQueryResult<SomeType>("query");

---

It is possible using reflection, for example:

var type = typeof(int); // var type = itemType : put this line to fit the method
var genericListType = typeof(List<>).MakeGenericType(type);
var genericList = Activator.CreateInstance(genericListType);

Assert.IsTrue(genericList is List<int>);

In your example, ehere do you get T from that you use in the return type? Maybe there is no need to use here reflection.

If you do not get T as generic argument then you cannot return the List as generic List and the method will have to return a non generic type (like IList instead of List).

---

While Elisha's answer shows you how you can create a constructed generic type from a Type instance, it's not going to help you because what I think you want to do is not possible: the signature of the GetQueryResult method is illegal because T is unspecified (unless the method is a member of a generic type itself).

The method will not compile as given.

If you already know the type, you can change it to

public static List<T> GetQueryResult<T>(string xpathQuery)
{
    var lst = new List<T>();
    return lst;
}

but that's probably not what you want...

---

Generic type arguments are resolved compile time, so to have the code working you'd need to pass itemType as a type argument or change the return type to IList And Them use the solution given by ELisha but that would mean loosing type information on the Call site

---

Answer to the updated question:

public List<T> GetQueryResult<T>(string xPathQuery)
{
    var items = ;// logic to get items
    var list = new List<T>();
    foreach (Sitecore.Data.Items.Item item in items)
    {
        list.Add((T) Activator.CreateInstance(typeof(T), item));
    }

    return list;
}

I assume that T has a constructor that gets Sitecore.Data.Items.Item, if it won't have the code will fail at runtime.

There must be a safer way to do it, it'll be better if you can give wider context to the problem.

---

As others have demonstrated, the only way to solve your updated question for any T is with reflection. However, if T is restricted to a well known set of types that you can modify, you could do this:

public interface IItemContainer
{
  void SetItem(Sitecore.Data.Items.Item item);
}

public static List<T> GetQueryResult<T>(string xpathQuery)
  where T : IItemContainer, new() {
  IList<Sitecore.Data.Items.Item> items = GetAListOfItemsSomehow(xpathQuery);

  List<T> result = new List<T>();
  foreach (Sitecore.Data.Items.Item item in items) {
    T obj = new T();
    obj.SetItem(item);
    result.add(obj);
  }

  return result;
}

Any types you want to use for T would then have to implement IItemContainer.

---

public static List<T> GetQueryResult<T>(string xpathQuery) {
    List<T> lst = new List<T>();
    return lst;
}

is the only way if you want static typing. Otherwise you could do

public static IList GetQueryResults(string xpathQuery, Type itemType) {
    Type tp = typeof(List<>).MakeGenericType(itemType);
    IList lst = (IList)Activator.CreateInstance(tp);
    return lst;
}

but using a non-generic list would probably be better in that case.

Edit: You asked another question in the same post:

The 3 ways of creating an instance of a generic type are

1. use the where T : new() constraint and use the default constructor (doesn't seem good enough for you).
2. Use reflection. Rarely the best idea.
3. Specify a creator function

like this:

public static List<T> GetQueryResults<T>(string xpathQuery, Func<int, T> creator) {
    var result = new List<T>();
    foreach (i in something)
        result.add(creator(i));
    return result;
}

and then invoke it like:

List<int> l = GetQueryResults("something", i => new MyObject(i));