CODEWITHSUNDEEP
c#arraysgenericsreflectiondynamic-cast
Mohammad Javad
Mohammad Javad

Reputation: 584

Cast array of unknowClass to array of otherClass in c#

How Can I dynamically cast at runtime.That is I am passing a child class object in the parent class object.

    public abstract class tObject
    {
       public tObject[] someMthode(){;}
    }
    public  class myClass : tObject
    {
       public string Oth0 { get; set; }
       public string Oth1 { get; set; }
       public string Oth2 { get; set; }
    }

I want 

 myClass mc=new myClass();
 tObject to=mc;
 myClass[] mcArray=(myClass[])mc.someMthode();//System.InvalidCastException
 //Unable to cast object of type 'tObject[]' to type 'myClass[]'

but when check any element of mcArray is correct

if (mcArray[0] is myClass)
{
   //return true and run this ;
}

In fact I want cast when a method return array of tObject according to the base class :

 subClass[] mcArray=(subClass[])instanceOfsubClass.someMthode()

subClass or myClass and ... are unknown class , and i don't know theirs name.

Solution

    public T[] Cast<T>(tObject[] mcArray ) where T : tObject
    {
        if (mcArray != null)
        {
            int cnt = mcArray.GetLength(0);
            T[] t = new T[cnt];
            for (int i = 0; i < cnt; i++)
            {
                t[i] = (T)mcArray[i];
            }
            return t;
        }
        return null;
    }

Thanks all for replies.

Upvotes: 0

Views: 148

Answers (4)

D Stanley
D Stanley

Reputation: 152501

Why not solve it one step up the chain and make someMethod (spelling corrected) generic:

public abstract class tObject<T> where T:tObject
{
   public T[] someMethod(){;}
}
public class myClass : tObject<myClass>
{
   public string Oth0 { get; set; }
   public string Oth1 { get; set; }
   public string Oth2 { get; set; }
}

now myClass.someMethod returns a myclass[] and that problem is solved. However, since I'm assuming that tObject does other things that just create an array of tObjects, it may cause other problems that aren't inferrable from the code you provided.

Plus it's not 100% foolproof. There's nothing stopping you (or someone else) from defining:

public class myWeirdClass : tObject<myClass>
{
}

now myWeirdClass.someMethod also returns a myClass[], and the pattern is broken. Unfortunately there's no generic constraint that requires that the generic parameter be the defining class itself, so there's no way to prevent this flaw at compile-time.

Another option may be to move the array creation outside of the class itself, since it is a code smell in itself:

public class ObjectFactory<T> where T:tObject
{
    public T[] SomeMethod() 
    {
        ... create an array of Ts    
    }
}

Upvotes: 0

MakePeaceGreatAgain
MakePeaceGreatAgain

Reputation: 37000

Well, you can call IEnumerable.Cast for that:

var myArr = mc.someMethod().Cast<MyClass>().ToArray();

As MyClass[] implements IEnumerable<MyClass>.

EDIT: What you want is quite dangerous. Look the following code:

subClass[] mcArray=(subClass[]) new BaseClass[] {...};

If this conversion would work we could now simply make the following also:

mcArray[0] = new AnotherClass();

Now you have an array of subClasses containin one item of AnotherClass also.

If you do not know the type at compile-time you cannot expect the compiler to provide any compile-time-logic for a type it doesn´t know. Thus casting to an unknown type and calling members on isn´t supported. However you may achieve this using reflection:

var runtimeType = myArr[0].GetType();
var mi = runtimeType.GetMethod("SomeMethod");
var value = mi.Invoke(myArr[0]);

This is similar to the call 

var value = ((subClass)myArr[0]).SomeMethod();

Upvotes: 0

Eric Lippert
Eric Lippert

Reputation: 659964

C# does not support that kind of array conversion. C# does -- unfortunately! -- support dangerous array covariance. That is, if you had an array myClass[] then you could implicitly convert it to an array tObject[]. This means that you can do this:

Tiger[] tigers = new Tiger[10];
Animal[] animals = tigers;
animals[0] = new Turtle();

and now we have a turtle inside an array of tigers. This crashes at runtime.

That's bad enough, but you want it to go the other way -- I have an array of animals and I'd like it to be treated as an array of tigers. That does not work in C#.

As other answers have noted, you'll need to make a second array and copy the contents of the first to the second. There are a number of helper methods to do so.

Upvotes: 2

Marcus
Marcus

Reputation: 8659

Maybe?

        myClass mc = new myClass();
        tObject to = mc;
        //myClass[] mcArray = (myClass[])mc.someMthode();//System.InvalidCastException
        //Unable to cast object of type 'tObject[]' to type 'myClass[]'

        var mcArray = Array.ConvertAll(mc.someMthode(), item => (myClass) item);

Upvotes: 0

Related Questions