C# Pass Generics At Runtime

Question

I have a method like the following:

public IEnumerable<T> GetControls<T>()
 : where T : ControlBase
{
 // removed.
}

I then created a class:

public class HandleBase<TOwner> : ControlBase
 : TOwner
{
 // Removed
}

I'd like to be able to call

GetControls<HandleBase<this.GetType()>>; 

where it would use the type of THIS class to pass to the HandleBase. This would in essentially get all HandleBase that have an owner of THIS type.

How can I achieve this?

EDIT:

I'm using .NET 2.0 so solutions greater than 2.0 will not work.

The idea is to have ControlBase have a collection of other ControlBase for "children". Then they can be queried based on their type with GetControls<T>(). This would allow me to, for example, get all HandleBase for a Shape. Then I can take all of these and set Visible=false or do something else with them. Thus I can manipulate children of a specific type for a collection.

HandleBase<TOwner> requires the TOwner since it has a reference to the "owning type". So you can only add anything that extends HandleBase to a Shape. Make sense?

Thanks for all the help!

Answer 1

You can't. Generics is a compile-time feature. You would need to include the type as a non-generic parameter to the method, and pass it in there.

Answer 2

You can do this either by specifying a type at compile-time or by using reflection.

You can do it with reflection like this:

typeof(SomeClass).GetMethod("GetControls")
    .MakeGenericMethod(typeof(HandleBase<>).MakeGenericType(GetType()))
    .Invoke(someObject, null);

Note that it would return an object; you would not be able to cast it to IEnumerable<T> (Unless you know what T is at compile-time, in which case there's no point). You would be able to cast it to IEnumerable.

However, this is a bad idea.
There is probably a better solution for you; please provide more detail.

Answer 3

Note that type parameters are not variables. Therefore, you cannot use a variable in place of a type parameter.

You could, however, do this through reflection, or by using a special construct which is pretty limited but may solve your case:

public class MyClass<TSelf> where TSelf: MyClass<TSelf> {
    public IEnumerable<T> GetControls<T>() where T: ControlBase {
     // removed.
    }

    public void MyCall() {
        GetControls<HandleBase<TSelf>>(); 
    }
}

public class MyConcreteClass: MyClass<MyConcreteClass> {
}

Answer 4

Probably there is no way to do what you ask for. Extending your example:

X x = GetControls<HandleBase<this.GetType()>>; 

What should the type X be here? However from other background information it seems that you need to get list of all controls of given type. You could do this for example in such way:

public IEnumerable<ControlBase> GetControls(Type type) {
//your logic here
}

Depending on your other usages and goals you might also want to return non-generic IEnumerable.

Answer 5

Since GetControls() returns an enumeration, you might find a way to filter the resulting enumeration with .OfType<T>, something like

List<T2> list = controlList.GetControls<T>().OfType<T2>().ToList();

You would need a generic constraint somehwere along the lines of

where T2 : T

Answer 6

This is specific to my implementation of this but I was able to solve this by creating a non-generic HandleBase first and then a generic HandleBase<TOwner> since the only place TOwner was being used was the property Owner.

Then when I can call GetControls<HandleBase> and get all HandleBase regardless of the Owner.

Thanks all for answers!