IsAssignableFrom, IsInstanceOfType and the is keyword, what is the difference?

Question

I have an extension method to safe casting objects, that looks like this:

public static T SafeCastAs<T>(this object obj) {
    if (obj == null)
        return default(T);

    // which one I should use?

    // 1. IsAssignableFrom
    if (typeof(T).IsAssignableFrom(obj.GetType()))
        return (T)obj;

    // 2. IsInstanceOfType
    if (typeof(T).IsInstanceOfType(obj))
        return (T) obj;

    // 3. is operator
    if (obj is T)
        return (T) obj;

    return default(T);
}

As you can see, I have 3 choice, so which one I should to use? Actually what is the difference between IsAssignableFrom, IsInstanceOfType, and is operator?

score 72 · Accepted Answer · answered Apr 06 '13 at 16:26

72

You use whatever you have the information for.

If you have an instance and a static type you want to check against, use is.

If you don't have the static type, you just have a Type object, but you have an instance you want to check, use IsInstanceOfType.

If you don't have an instance and you just want to check the compatibility between a theoretical instance of a Type and another Type, use IsAssignableFrom.

But really is seems like you are just re-implementing the as operator (except that yours would also work for non-nullable value types, which is usually not a big limitation).

answered Apr 06 '13 at 16:26

Jacob

1,699
10
11

4

There is an additional difference between IsAssignableFrom and IsInstanceOfType. There are some types where type A is assignable to type B even though type B is not an instance of type A. For example: class B { } class D : B { } interface IGeneric { } typeof(IGeneric).IsAssignableFrom(typeof(IGeneric); <== This expression is true typeof(IGeneric).IsInstanceOfType(typeof(IGeneric); <== This expression is false – Daniel Arant Feb 04 '19 at 22:57

Matthew Watson · Answer 2 · 2013-04-06T16:43:56.640

I guess you're effectively implementing a version of the as operator that works with value types as well as reference types.

I'd go for:

public static T SafeCastAs<T>(this object obj)
{
    return (obj is T) ? (T) obj : default(T);
}

IsAssignableFrom works with types, and is works with instances. They will give you the same results in your case, so you should use the simplest version IMHO.

As for IsInstanceOfType:That is implemented in terms of IsAssignableFrom, so there will be no difference.

You can prove that by using Reflector to look at the definition of IsInstanceOfType():

public virtual bool IsInstanceOfType(object o)
{
    if (o == null)
    {
        return false;
    }
    return this.IsAssignableFrom(o.GetType());
}

outcoldman · Answer 3 · 2014-04-25T17:52:22.210

3

I guess you should just go with "as" instead of your custom "SafeCastAs". But this will work only for classes (not structs), so if you want to use this method for structs as well I can get it.

Operator "is" basically gives you the same as Type.IsAssignableFrom, so you can keep only "is", it checks if you can safely cast obj to T, without exceptions. So it will cover both previous checks in your method. But you should be aware about that it does not check if you can assign obj to T, because of user defined conversions: explicit and implicit keywords.

edited Apr 25 '14 at 17:52

answered Apr 06 '13 at 16:38

outcoldman

11,584
2
26
30

I'm not sure your assertion here is correct. `typeof(int)` returns a object of type `Type` so the first statement will fail since that `Type` object is obviously not an `int`. However, if you change the first statement to `a.GetType().IsInstanceOfType(3)` it will return true. I think you are using `IsInstanceOfType` wrong here. – Jeff B Apr 25 '14 at 15:56
@JeffBridgman true, my guess I just tried to show the difference of using these two methods, something like ``` Console.WriteLine(typeof(int?).IsInstanceOfType(null)); Console.WriteLine(typeof(int?).IsInstanceOfType(1)); Console.WriteLine(typeof(int?).IsAssignableFrom(typeof(int))); ``` I'm going to remove some parts of this answer. – outcoldman Apr 25 '14 at 17:50

score 1 · Answer 4 · edited Aug 14 '17 at 11:27

These functions and operators have different meaning. If you have objects you can always get types. so you do not work on what you have, but you do what needs to be done.

When you are working with a class hierarchy differences are very clear.

Look at following example

      class ABase
        {

        }

        class BSubclass : ABase
        {

        }
    ABase aBaseObj = new ABase();
                BSubclass bSubclassObj = new BSubclass();

                ABase subObjInBaseRef = new BSubclass();

Different operations yield different results.

typeof(ABase).IsInstanceOfType(aBaseObj) = True

typeof(ABase).IsInstanceOfType(bSubclassObj) = True

typeof(ABase).IsInstanceOfType(bSubclassObj) = True

typeof(BSubclass).IsInstanceOfType(aBaseObj) = False

bSubclassObj is ABase = True

aBaseObj is BSubclass = False

subObjInBaseRef is BSubclass = True

subObjInBaseRef is BSubclass = True

typeof(ABase).IsAssignableFrom(typeof(BSubclass))  = True

typeof(BSubclass).IsAssignableFrom(typeof(ABase))= False

In case on no hierarchy, may be everything was same. But if you work with hierarchy, IsAssignableFrom , is , and IsInstanceOfType yield different results.

There are more possible combinations that could be tried. For example, you can introduce a class C which is not related in anyway with existing classes in this example.

IsAssignableFrom, IsInstanceOfType and the is keyword, what is the difference?

4 Answers4

Linked

Related