如何创建动态类型的C＃迭代器块？

Question

I am doing an AOP kind of layer and I would like to return an iterator block for a generic collection (ie something like "IEnumerable"). However, the type T is dynamically discovered. I can find that type and have it locally as a "Type" variable but how do I go beyond that and return an iterator block for that dynamically-discovered type?

What I want is something like this (as close as I can express it in conventional C#):

public IEnumerator<runtimeDiscoveredType>  EntryIteratorBlock(Type desiredElementType)
{
     // One can assume that desireElementType is the same as (or convertible to) runtimeDiscoveredType
     TypeConverter tc = new TypeConverter()
     var actualItem = ....; // some code goes here to pick up the actual item from
     ...                    // some collection.

     if (ChooseThisItem(actualItem))
         yield return tc.ConvertTo(actualItem, desiredElementType);
     else
         yield break;
}

I would like to then return the EntryIteratorBlock so that I can dynamically walk through the collection. (The elements in the collection are expensive to load and so I want to load them lazily.)

Answer 1

The compiler has to work out the return type of calls to EntryIteratorBlock , which it cannot do with a runtime type. IEnumerator<runtimeDiscoveredType> is a contradiction in terms.

The most information you have at compile-time is that the sequence will contain objects:

public IEnumerator<object> EntryIteratorBlock(Type desiredElementType)
{
    // ...
}

Or, if the items in the sequence share a common type:

public IEnumerator<BaseElementType> EntryIteratorBlock(Type desiredElementType)
{
    // ...
}

If you post some information about the problem you are trying to solve with the iterator, we might be able to offer help at a more fundamental level.

Answer 2

Although it's not clear that this is the right way to do this, here's a way that works:

class Program
{
    // this method is not called directly
    // but it is public so it is found by reflection
    public static IEnumerable<U> EntryIteratorBlock<T, U>(
        IEnumerable<T> source, Func<object, bool> selector)
    {
        TypeConverter tc = new TypeConverter();
        foreach (T item in source)
            if (selector(item))
                yield return (U)tc.ConvertTo(item, typeof(U));
    }

    static IEnumerable CreateIterator(
        // these are the type parameters of the iterator block to create
        Type sourceType, Type destType,
        // these are the parameters to the iterator block being created
        IEnumerable source, Func<object, bool> selector)
    {
        return (IEnumerable) typeof(Program)
            .GetMethod("EntryIteratorBlock")
            .MakeGenericMethod(sourceType, destType)
            .Invoke(null, new object[] { source, selector });
    }

    static void Main(string[] args)
    {
        // sample code prints "e o w o"
        foreach (var i in CreateIterator(typeof(char), typeof(string),
                          "Hello, world", c => ((char)c & 1) == 1))
            Console.WriteLine(i);
    }
}