Question

For the sake of argument, I have an object. I can’t modify the signature of my function because I am extending someone else’s class.

To give a concrete example, I have the following:

class Foo<T> : SomeBaseClass
{
    public override MyFunction(object value)
    {
        // TODO: Figure out if value is an instance of Foo, though I don't care
        // what type was associated with it.
    }
}

Is there a way to make sure that value is some instance of a Foo type?

Answer 1

Well, if you want to check whether it’s exactly a Foo<something> it’s fairly easy:

Type type = value.GetType();
if (!type.IsGenericType)
{
    throw new ArgumentException("Not a generic type");
}
if (type.GetGenericTypeDefinition() != typeof(Foo<>))
{
    throw new ArgumentException("Not the right generic type");
}

If you need to decide whether it’s some type derived from Foo<T> it’s slightly harder – because you don’t necessarily know where it’ll be generic. For example, it could be:

class Bar : Foo<string>

or

class Baz<T> : Foo<T>

One alternative to make things easier might be to introduce another non-generic class:

abstract class Foo : SomeBaseClass

class Foo<T> : Foo

Then you can just do:

if (value is Foo)

Of course that would also allow for other types deriving from Foo. In many cases that wouldn’t really be a problem, but it depends on your exact situation. You could also put any members which don’t need to refer to T into Foo, so you could access them in cases like this where you don’t care about T.