如何投放清单 <Object> 列出 <Foo> 当foo是类型变量并且我不知道类型时

Question

I have a situation where through reflection I have List>object<. I also have a reflected method that takes List>foo<. List>object< contains a whole bunch of foos, but List>object< cannot be directly casted to List>foo<. I have a Type variable that contains foo, but do not know it at compile time. My code looks something like below

var ASM = Assembly.LoadFrom("foo.dll");
var bar = List<string>() { /*A whole bunch of string literals*/ };

var FooType = ASM.GetType("Foo")
List<object> foos = new List<object>; 
foreach (var str in bar)
{
   foos.add(Activator.CreateInstance(FooType, new [] {str}));
}

var Flags = BindingFlags.Static | BindingFalgs.Public;
FooType.GetMethod("DoSomethingWithAListOfFoo", Flags).Invoke(null, foos)

At this point I'm told that a List cannot be converted to a List via a runtime exception

Answer 1

Reflection go you into this mess, so you're going to need reflection to get you out, only it's going to be deeper darker nastier reflection. Reflection of Generic Methods.

---

So lets say you've aleady got your foos variable populated. It's a list of objects. How do you cast a list of something to a list of something else? Cast! In your instance, you want Cast but you don't have access to that from what I understand, so we need to create an instance of the Cast method. First we need to get the Generic Cast method

var GenericCastMethod = typeof(System.Linq.Enumerable)
  .GetMethod("Cast", BindingFlags.Public | BindingFlags.Static);

Now we need to make a type specific cast method

var SpecificCastMethod = GenericCastMethod.MakeGenericMethod(FooType);

Finally, we need to call this on your list

var FoosOfTypeFoo = SpecificCastMethod.Invoke(null, new object[] { foos });

You can now use FoosOfTypeFoo as an IEnumerable . This if of course, not what you want. So we need to do the same thing on ToList method. Sparing you the gory details, all put together it should look like this

var GenericCastMethod = typeof(System.Linq.Enumerable)
  .GetMethod("Cast", BindingFlags.Public | BindingFlags.Static);
var SpecificCastMethod = GenericCastMethod.MakeGenericMethod(FooType);
var IEnumerableOfFoo = SpecificCastMethod.Invoke(null, new object[] { foos });

var GenericToListMethod = typeof(System.Linq.Enumerable)
  .GetMethod("ToList", BindingFlags.Public | BindingFlags.Static);
var SpecificToListMethod = GenericToListMethod .MakeGenericMethod(FooType);
var ListOfFoo = SpecificToListMethod .Invoke(null, new object[] { FoosOfTypeFoo });

---

The moral of this story is that black magic code begets fouler darker black magic code.

Answer 2

Don't use Reflection, use an ArrayList (no, really)

Do you remember the old type, ArrayList ? Nobody uses it much any more; it's just like List<object> . But there is one key difference: ArrayList has a ToArray(Type) method (not a ToArray<T> method, since generics didn't exist back then). So you easily can make an array with any type, as long as you can get a Type object for them.

Here are two solutions that take advantage of this feature.

Solution 1. One line change.

If DoSomethingWithAListOfFoos accepts an IEnumerable<Foo> (and doesn't require it to be a List<Foo> ), you can just use this:

FooType.GetMethod("DoSomethingWithAListOfFoo", Flags)
    .Invoke(
        null, 
        new ArrayList(foos).ToArray(FooType)  //Magic!!!
    );

Easy enough, right? You didn't even have to reflect anything.

Solution 2. Extension method.

If DoSomethingWithAListOfFoos truly requires a List<Foo> we have a little more work to do because we have to construct the generic list.

First, add this extension method somewhere in your code:

static public ICollection ToGenericList(this ICollection input, Type itemType)
{
    return (ICollection) typeof(List<>)
        .MakeGenericType(itemType)
        .InvokeMember(
            null, 
            BindingFlags.CreateInstance, 
            null, 
            null, 
            new object[] { new ArrayList(input).ToArray(itemType) }
        );
}

This works because every List<T> comes with a constructor that will accept an array. And we already figured out how to make the array very easily. We just locate the right constructor and pass it in, and the runtime does the rest.

Now just call it like this:

FooType.GetMethod("DoSomethingWithAListOfFoo", Flags)
    .Invoke(
        null, 
        new foos.ToGenericList(FooType)   //Our new extension method
    );