Cast Generic Object with getting type from Reflection

Question

I'm trying to cast an object in a generic object where I need to change the type dynamically.

Dog<T> inherits Animal, class "T" must inherit from EntityBase. For example, Chihuahua inherits EntityBase.

for (int i = 0; i < list.Count(); i++) {
    if (list?.ElementAt(i)?.GetType().GetTypeInfo().BaseType == typeof(Animal))
    {
        var type = list.ElementAt(i).GetType();
        // is wrong, must use a class no a type
        // var animal = list.ElementAt(i) as GenericObject<Dog<type>> 
        // Correct syntax but cast results null
        var animal = list.ElementAt(i) as GenericObject<Dog<EntityBase>> 
        // animal is null
        DoStuff(animal);
    }

If I use this code, it works:

if (list?.ElementAt(i)?.GetType() == typeof(Dog<Chihuahua>))
{   
    DoStuff(list.ElementAt(i) as Dog<Chihuahua>);
}

I want to do this as generically as possible, thanks a lot!

I will share the project I'm doing when I finish!

Please paste your code in as text. A screenshot of code isn't very useful. — 15ee8f99-57ff-4f92-890c-b56153, Oct 20 '16 at 14:17
Okey Thanks, I was on trying but the web stopped me with an error — Danielbahe, Oct 20 '16 at 14:20
Could you paste you **actual** code? What you posted have is full of errors. — 3Dave, Oct 20 '16 at 14:37
Sorry, my code works on a much larger project, add the classes should be enough @DavidLively — Danielbahe, Oct 20 '16 at 14:43
@SLaks wow! With a quick glance think you're right, I'll try as soon as possible. Thanks! — Danielbahe, Oct 20 '16 at 14:46

score 4 · Accepted Answer · edited Dec 27 '19 at 19:01

4

The ability to have a single list hold different kinds of related types is called covariance (contravariance is also related). This is achieved in .NET with the out and in keywoards respectively. With .NET 4.5, covariance is built into IEnumerable<T>. IEnumerable<T> is implemented by IList<T>, which is implemented by List<T>.

If you have a list of Animals, you can add any subtype of Animal to the list. However, when you get that animal out, in code, you get a variable of type Animal that points to your subtype of Animal. So it looks like you only have an Animal but it's really the subtype. You could try to manually cast everything as you suggested.

There is another workaround (.NET 4.5), you can use the dynamic keyword to have the type be determined at runtime. Then overload the DoStuff method, it should behave the way you want.

public class Animal
{
    public string Name;
    public Animal() { Name = "Animal"; }
}

public class Dog:Animal
{
    public Dog() { Name = "Dog"; }
}

[TestMethod]
public void Test()
{
    var list = new List<Animal>();
    list.Add(new Dog());
    list.Add(new Animal());
    foreach(dynamic a in list)
    {
        DoStuff(a);
    }
}

public void DoStuff(Animal animal)
{
    Console.WriteLine("{0} is wild", animal.Name);
}

public void DoStuff(Dog dog)
{
    Console.WriteLine("{0} is not wild", dog.Name);
}

This is the output

Test Name:  Test
Test Outcome:   Passed
Result StandardOutput:  
Dog is not wild
Animal is wild

Covariance and contravariance is a complex topic. Check out these other posts. Difference between Covariance & Contra-variance Difference between covariance and upcasting

edited Dec 27 '19 at 19:01

CarenRose

1,266
1
12
24

answered Oct 20 '16 at 15:42

Paul Tsai

893
6
16

1

I did not know that. Very cool. It works the same with `List – 15ee8f99-57ff-4f92-890c-b56153 Oct 20 '16 at 16:38
...and of course, [it also works whether or not Dog inherits from Animal](https://dotnetfiddle.net/MNyL9Y). – 15ee8f99-57ff-4f92-890c-b56153 Oct 20 '16 at 16:49
@EdPlunkett yes, using the dynamic keyword moves the topic away from covariance. Not sure how to classify it. – Paul Tsai Oct 20 '16 at 17:00
Well, it's overload resolution at runtime. But I don't know what a computer scientist would call it. To me it feels somewhat akin to pattern matching as in Scala/Swift/etc. Kinda sorta. – 15ee8f99-57ff-4f92-890c-b56153 Oct 20 '16 at 17:03
@EdPlunkett It works with List – Paul Tsai Oct 20 '16 at 17:13
The List works because all types inherit from object, certainly. And if you're throwing arbitrary pots and pans at it, naturally you'll want an Object overload as a backstop. – 15ee8f99-57ff-4f92-890c-b56153 Oct 20 '16 at 17:23
1

I don't understand why anybody isn't upvoting this answer. Am I the only one on Earth who didn't know that about `dynamic`? – 15ee8f99-57ff-4f92-890c-b56153 Oct 20 '16 at 17:24
Upvote thanks to @EdPlunkett's contagious enthusiasm for the answer. – elchido Oct 21 '16 at 13:41
As i promise here is the result! https://github.com/Danielbahe/PatternsSample I use it for disable xamarin Views – Danielbahe Nov 21 '16 at 10:39
Covariance in C# is NOT the ability of a list to hold multiple types of object, but rather the ability of e.g. an `IEnumerable` to also function as an `IEnumerable`. – M Kloster Jul 02 '18 at 08:53

Cast Generic Object with getting type from Reflection

1 Answers1