如何将 Invoke 返回的值转换为 IEnumerable<type> type 是 T 类型的变量吗？

Question

I have the situation, where I want to call some generic method on another object and get IEnumerable result.

private void SomeFunction(Type type)
{
     var method = context.GetType()
       .GetMethods()
       .FirstOrDefault(_ => _.Name == "GetStorage" && _.IsGenericMethod);

     var storage = getStorage.MakeGenericMethod(type)
                    .Invoke(context, new object[] {})
                    .AsEnumerable();
                    //Some magic needed here. Something like Cast<type>, 
                    //but type - variable
     //More code ...
}

Could anyone suggest me how to figure out this situation. Thank you.

I have already seen this and similar questions: Casting Results from Generic Method Invocation? But they doesn't answer on my question, how to do same, when I don't know type, to which I want to cast, and type is stored as variable.

I can't make SomeFunction a generic method, because the real situation is that I am iterating some list with System.Type and calling lambda (ie SomeFunction ) on each element

Answer 1

There are some things you need to do to get what you want. You say you want to have a lambda, but that means that you need to define that lambda, which is on a type you do not know yet. You can redesign your lambda into an interface.

Also, I find it much easier to define a generic class that does exactly what I want. By creating an instance of this class through reflection, and only there, I can implement the rest of the class in a strong typed way. This takes away the 'not knowing what type I have' in most places.

Like this. First, the executor interface:

public interface ISomeFunctionExecutor
{
    void Execute(SomeContext context);
}

Then the interface that I need to implement on the entities, which is the lambda so to speak.

public interface IEntityWithSomeFunction
{
    void SomeFunction();
}

Now the implementation of the executor.

public class SomeFunctionExecutor<TType> : ISomeFunctionExecutor
{
    public void Execute(SomeContext context)
    {
        var data = context.GetStorage<TType>().Cast<IEntityWithSomeFunction>();
        foreach (var item in data)
        {
            item.SomeFunction();
        }
    }
}

And finally, the usage of it all:

// Usage:
SomeContext context = new SomeContext();
Type type = typeof(SomeEntity);
var executorType = typeof(SomeFunctionExecutor<>).MakeGenericType(type);
var executor = Activator.CreateInstance(executorType) as ISomeFunctionExecutor;
if (executor != null)
{
    executor.Execute(context);
}

Basically the point is: define a generic class to do what you need to do where you do know the type, and create an instance of this class using reflection. It makes it much easier than having a whole method where you do not know the type.