How do I cast an object to an ArrayList or IEnumerable?

[KMinFL]

This is a C# VS 2008 question...

Our system has 2 base classes, SingleEntity and NewPluralEntity . SingleEntity provides access to properties and methods related to manipulating data in a database table and NewPluralEntity is a generic base class that I inherit from to create strongly typed collections of single entities.

Here is the declaration of our NewPluralEntity class:

public abstract class NewPluralEntity<T> : ICollection<T>, IEnumerable<T>

Here is a sample declaration of one of our inherited plural classes:

public class Workplaces : NewPluralEntity<Workplace>

My problem is that I have to use reflection to return an ArrayList (or some other type of collection that I may enumerate) that contains my Workplaces and I cannot find any way to get the object that is returned from reflection (PropertyInfo.G etValue()) to cast to an ArrayList (or other suitable type).

For example, I have an Insured object. The Insured object has a Workplaces property. I need to use reflection to return an ArrayList that contains my Workplaces.

Here is the code for my "GetNewPluralEn tityPropertyUsi ngReflection" method:

public ArrayList GetNewPluralEntityPropertyUsingReflection(string p_propertyName)
{
  PropertyInfo myProperty = this.GetType().GetProperty(p_propertyName);
  object res = myProperty.GetValue(this, null); //this is the fully loaded Insured object in this case
  return (ArrayList)res; //blows up...
}

When I invoke Insured.GetNewP luralEntityProp ertyUsingReflec tion("Workplace s"); and step into the code and place a breakpoint on my "return (ArrayList)res; " statement I can see that the "res" variable has a value and that its base type is NewPluralEntity <Workplace>, with a count and several other properties that are in NewPluralEntity , but I cannot get the cast to ArrayList to succeed.

Originally, I wanted the GetNewPluralEnt ityPropertyUsin gReflection() method to return a NewPluralEntity <Workplace> but I found no way to cast an object to a generic type when I did not know the type at compile time (in my case the type is just a string "Workplaces "). If someone knows how to do return NewPluralEntity <Workplace> in this case that would be great too but ArrayList will do.

Thanks in advance for any ideas.

[Plater]

I am pretty sure you cannot just "sideways" cast one derrived class to a different derrived class, even if they have the same parent object(s)

Is there a reason you need an arraylist so bad? Your object appears to support ICollection<T> and IEnumerable<T> already, just index it like normal?

[balabaster]

You could reflect over the interfaces the object implements and just cast it...

Dim t As Type = ReceivedObject.GetType()
If t.GetInterfaces().Contains(IEnumerable) Then
  Return DirectCast(ReceivedObject, IEnumerable)
ElseIf t.GetInterfaces().Contains(IList) Then
  Return DirectCast(ReceivedObject, IList)
...

Alas, what I think you're trying to achieve (if I interpret correctly) is this:

Return DirectCast(Rece ivedObject, ReceivedObject. GetType)

and I've come across numerous times where I've needed to be able to do that, and I've yet to come across a solution that doesn't require me to run a switch to check the type and then cast accordingly...

If you do manage to come up with a better solution, I'd welcome the feedback as I'd love to know there's a better way of doing this...

[mldisibio]

There might be a more type safe way to do this, but before I work up the code sample, let me get some clarification.
I understand (correct me if wrong)
- You have a generic NewPluralEntity collection.
- You have classes which will have a property which is a strongly typed NewPluralEntity collection, such as a Insured class which has a Workplaces property which is a NewPluralEntity <Workplace>.
- For any of those classes, you want to retrieve a working collection, be it the typed NewPluralEntity <T> collection or an ArrayList of T objects.

First, I don't think you need to go via ArrayList (and yes, that cast should just blow up - generics have limited variance, see Variance in Generic Types ), so lets focus back on getting a strongly typed list. I understand that because it is a generic collection, you don't necessarily know the type at runtime...but.. .

You state you have a "GetPropertyUsi ngReflection" method which takes the property name - so you do know SOMETHING at runtime.

My question is: is there a one-to-one relation between your property names and the type?
For example, in this instance, you are retrieving the "Workplaces " property, and expect NewPluralEntity <Workplace>. So will another class have a "Bars" property that is NewPluralEntity <Bar> and another class have a "Foos" property which is NewPluralEntity <Foo>?

If yes, I am pretty sure you can do this by making "GetPropertyUsi ngReflection(st ring)" into simply GetNewPluralCol lection<T>().

But tell me know before I start if your design intent is to have only one property name ("Workplaces ") with no guarantee of the type: i.e. Workplaces can be NewPluralEntity <Workplace> OR NewPluralEntity <Bar>.

There may also be a workaround by modifying how you create the class which contains the collection...bu t one workthrough at a time...

[mldisibio]

P.S. balabaster:

"DirectCast " seems to be VB specific and I am not familiar with it. Would that be the same as the C# keyword "as" ?

return ReceivedObject as IEnumerable;

or is it a cast subject to exception:

return (IEnumerable)ReceivedObject;

[balabaster]

P.S. balabaster:

"DirectCast " seems to be VB specific and I am not familiar with it. Would that be the same as the C# keyword "as" ?

return ReceivedObject as IEnumerable;

or is it a cast subject to exception:

return (IEnumerable)ReceivedObject;

Yeah, in C# - I think (although don't quote me, I'm not 100% sure without digging) that

CType(MyObj, Type) is equivalent to (Type)MyObj

and...

DirectCast(MyOb j, Type) is equivalent to MyObj As Type

I'll confirm and get back to you

Edit[1]: Using the VB to C# converter at developer fusion translates both to (Type)MyObj so maybe I'm incorrect...

Edit[2]: The As keyword in C# converts like so:

string s = mystring as string;

converts to:

Dim s As String = TryCast(mystring, string)

(I never came across TryCast before: Here's an article about it - http://www.panopticoncentral.net/arc...03/02/281.aspx)

Dim s As String = DirectCast(MyObj, String)

is the same as:

string s = (string)MyObj;

So I'm now trying to figure out what the C# equivalent of CType is... or if this is implicitly handled in C# without the need to differentiate between DirectCast/CType.

Anyway, that's for another thread/article...

[mldisibio]

I guess I care about this more than the person requesting help, but I wanted to complete the proposed solution. Note: the following is neither the only solution nor the most efficient (in terms of design), but it is works within the constraints of the original question:

Unless someone is interested enough to ask any questions, I will post the following solution as is with the short comments in the code. The objective is to be able to retrieve a strongly typed collection, stored as a property in a class, without knowing anything about the types in the collection at runtime.
However, we know the "name" of the collection property, and this should have a relation to the type of the collection items;
We know we want the items to have some database functionality.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace bytes{

  // Your collection, as Collection for simplicity's sake.
  public abstract class NewPluralEntity<T> : Collection<T> { }

  // Since you want your SingleEntities to have data access, show that they do.
  public interface DBActive { void WriteToDB();}

  // Encapsulate your 'GetPropertyByName' method as a function of your class
  public abstract class ManagedGroup {
    public abstract NewPluralEntity<TPlace> GetListOfPlaces<TPlace>();
    public abstract ICollection<DBActive> GetListOfDBItems();
  }

  // Example SingleEntity
  public class Workplace : DBActive {
    string s;
    public Workplace(string name) { this.s = name; }
    public string Company { get { return this.s; } }
    public void WriteToDB() { Console.WriteLine("Wrote Workplace {0} to DB.", s); }
  }

  // Example SingleEntity
  public class Funplace : DBActive {
    string s;
    public Funplace(string name) { this.s = name; }
    public string Name { get { return this.s; } }
    public void WriteToDB() { Console.WriteLine("Wrote Funplace {0} to DB.", s); }
  }

  // Your defined Plural Entity
  public class Workplaces : NewPluralEntity<Workplace> { }

  // Another defined Plural Entity
  public class Funplaces : NewPluralEntity<Funplace> { }

  // The class containing your collection of Workplaces
  public class Insured : ManagedGroup {
    Workplaces internalList;
    public Insured() {this.internalList = new Workplaces();}
    public Workplaces PlacesToWork { get { return this.internalList; } }
    public override NewPluralEntity<TPlace> GetListOfPlaces<TPlace>() {
      if (typeof(TPlace) == typeof(Workplace))
        return this.internalList as NewPluralEntity<TPlace>;
      else
        throw new InvalidCastException();
    }
    public override ICollection<DBActive> GetListOfDBItems() {
      List <DBActive> tempList = new List<DBActive>(this.internalList.Count);
      foreach (Workplace w in this.internalList) tempList.Add(w);
      return tempList;
    }
  }

  // Another class containing a collection of Funplaces
  public class AtRisk : ManagedGroup {
    Funplaces internalList;
    public AtRisk() { this.internalList = new Funplaces(); }
    public Funplaces PlacesToPlay { get { return this.internalList; } }
    public override NewPluralEntity<TPlace> GetListOfPlaces<TPlace>() {
      if (typeof(TPlace) == typeof(Funplace))
        return this.internalList as NewPluralEntity<TPlace>;
      else
        throw new InvalidCastException();
    }
    public override ICollection<DBActive> GetListOfDBItems() {
      List<DBActive> tempList = new List<DBActive>(this.internalList.Count);
      foreach (Funplace f in this.internalList) tempList.Add(f);
      return tempList;
    }
  }

  public class Program{
    static void Main() {

      // SOMEWHERE (anywhere) you will have to create the Insured class and, you will know what it is.
      Insured insuredGroup = new Insured();
      insuredGroup.PlacesToWork.Add(new Workplace("GM"));
      insuredGroup.PlacesToWork.Add(new Workplace("Chrysler"));
      insuredGroup.PlacesToWork.Add(new Workplace("Ford"));

      // SOMEWHERE (anywhere) you will have to create the AtRisk class and, you will know what it is.
      AtRisk atRiskGroup = new AtRisk();
      atRiskGroup.PlacesToPlay.Add(new Funplace("Disneyland"));
      atRiskGroup.PlacesToPlay.Add(new Funplace("Six Flags"));
      atRiskGroup.PlacesToPlay.Add(new Funplace("Sears Racepoint"));

      // This assummes that if you know you are looking for the property name "Workplaces"
      // you can take advantage and get the strongly typed collection.
      NewPluralEntity<Workplace> insuredPlaces = insuredGroup.GetListOfPlaces<Workplace>();
      NewPluralEntity<Funplace> funPlaces = atRiskGroup.GetListOfPlaces<Funplace>();

      foreach (Workplace w in insuredPlaces) Console.WriteLine(w.Company);
      foreach (Funplace f in funPlaces) Console.WriteLine(f.Name);
      Console.WriteLine();

      // If you have NO IDEA what object you are dealing with, you can still have it execute 
      // the desired Database action.
      ManagedGroup managedGroupA = insuredGroup as ManagedGroup;
      ManagedGroup managedGroupB = atRiskGroup as ManagedGroup;
      ICollection<DBActive> listDBItemsA = managedGroupA.GetListOfDBItems();
      ICollection<DBActive> listDBItemsB = managedGroupB.GetListOfDBItems();
      foreach (DBActive dbItem in listDBItemsA) dbItem.WriteToDB();
      foreach (DBActive dbItem in listDBItemsB) dbItem.WriteToDB();

    }
}

Output:

GM
Chrysler
Ford

Disneyland
Six Flags
Sears Racepoint

Wrote Workplace GM to DB.
Wrote Workplace Chrysler to DB.
Wrote Workplace Ford to DB.

Wrote Funplace Disneyland to DB.
Wrote Funplace Six Flags to DB.
Wrote Funplace Sears Racepoint to DB.

[balabaster]

Damn that's a lot of reading... :oP

[Plater]

without the need to differentiate between DirectCast/CType.

The only difference between those two is one allows casting to "similar" or base types (can cast a double to an int, with loss, for example) and the other requires an exact type.
(type)object works like the one that allows casting to similar or base types.

For the functionality of the other, I think you would just go
if(object.GetTy pe() == (type))

[KMinFL]

My solution .. MethodInfo.Invo ke()

Thanks to everyone for your thoughts. I did not get any notifications about all of the activity and I apologize for not keeping current.

Anyhow, here is how I finally solved my problem. I'll read and fully process the other thoughts as well but since I was able to think of a solution I figured I better post it as an alternative.

Basically, I decided, "If reflection is what is causing my problem maybe I can use reflection to solve my problem." So I decided to use the Invoke() method of the MethodInfo class to invoke my ToArrayList() method on my NewPluralEntity <T> base class.

I am not sure if this is the fastest code in the world but it does work and it allows me to return the ArrayList even though the type of my generic if unknown.

    public ArrayList GetPluralEntityPropertyUsingReflection(string p_propertyName)
    {
      System.Reflection.PropertyInfo myProperty = this.GetType().GetProperty(p_propertyName);
      object res = myProperty.GetValue(this, null); 
      Type t = res.GetType();
      System.Reflection.MethodInfo mi = t.GetMethod("ToArrayList");
      return (ArrayList)mi.Invoke(res, null); 
    }

Thanks for all of the replies. Next time I won't rely on being subscribed to threads and check them every day.

[Curtis Rutland]

The only difference between those two is one allows casting to "similar" or base types (can cast a double to an int, with loss, for example) and the other requires an exact type.
(type)object works like the one that allows casting to similar or base types.

I found the explanation of the difference on the MSDN:

The as operator is like a cast except that it yields null on conversion failure instead of raising an exception.

Link: as (C#)

[balabaster]

Good find - thanks for the update.