does GetType() guarantee casting?

Question

if o.GetType() == sometype is it guaranteed that o can be casted to sometype ?

that is if:

void f<T>(T o1, object o2) {
   if (o1.GetType() != o2.GetType()) return;
   T t = o2 as T;
   // can I assert that t is not null ??
}

This looks like an XY problem, or at least there's a code smell here... — DavidG, Mar 17 '19 at 22:28
Yes, it's guaranteed, but that code doesn't make a lot of sense as-is — Camilo Terevinto, Mar 17 '19 at 22:28
To be specific, your code violates this: https://en.wikipedia.org/wiki/Liskov_substitution_principle — , Mar 17 '19 at 22:30
Sounds to me like you actually want to use interfaces. Generics are not that. — GolezTrol, Mar 17 '19 at 22:30
it's part of a bigger thing, if you look at my extension method here https://stackoverflow.com/a/54934113/460084 I was wondering if the `&& obj is T o && thisEquals(o)` can be safely shortcutted to `&& thisEquals(o as T)` ? — kofifus, Mar 17 '19 at 22:34
Obviously not going to work for value types. Regular cast would be fine — Alexei Levenkov, Mar 17 '19 at 22:56
There is no guarantee that `T` and `o1.GetType()` will be the same type (`T` could be `object` for example, while `GetType()` would return the **real** type). I am not saying that is a problem, just pointing it out in case it impacts your solution. — mjwills, Mar 17 '19 at 23:45

score 1 · Answer 1 · answered Mar 18 '19 at 01:48

Yes, you can, but I'd suggest going one step further and do this:

void f<T, U>(T t, U u) where T : class
{
    if (!t.GetType().IsAssignableFrom(u.GetType())) return;
    T ut = u as T;
    // can I assert that t is not null ?? Yes, you can
}

IsAssignableFrom should nail it for any type.

TheGeneral · Answer 2 · 2019-03-18T03:00:29.020

1

Why not just use the is operator, ¹Albeit "maybe" a little slower

if (o2 is SomeType result) o1 = result;

or as a method

private void SomeThingWeird<T>(ref T o1, object o2)
{
   if (o2 is T result)
      o1 = result;
}

References

¹ Drilling into .NET Runtime microbenchmarks: ‘typeof’ optimizations.

edited Mar 18 '19 at 03:00

answered Mar 18 '19 at 02:35

TheGeneral

79,002
9
103
141

@Enigmativity maybe wrongly assumed this was a swappsies method and OP wanted the result to reflect back to the caller – TheGeneral Mar 18 '19 at 03:24
Reading the comments, i see what the extended method does, so them there was a fly (again) – TheGeneral Mar 18 '19 at 03:25

score -1 · Answer 3 · edited Mar 18 '19 at 03:14

-1

Why not doing :

void f<T>(T o1, T o2) {
   if (o1.GetType() != o2.GetType()) return;
   // can I assert that t is not null ??
}

For what I understand you want, by checking if (o1.GetType() != o2.GetType()) return; to make sure that o2 is of type T and not a derived type. So o2 has to be of type T and you don't have any problem casting.

edited Mar 18 '19 at 03:14

Enigmativity

113,464
11
89
172

answered Mar 17 '19 at 23:59

La pieuvre

438
2
9

does GetType() guarantee casting?

3 Answers3