Question

I have a C# method that returns very large number of objects. This is to be consumed in Matlab.

namespace MyNameSpace{
    public static class MyClass{
        public static IEnumerable<MyDataObject> GetVeryLargeResponse(){
            while(CheckForSomeFunkyConditionThatsRarelyTrue()){
               yield return GetMyNextDataObject();
            }
            yield break;
        }
    }
}

In Matlab when I make a call

result = MyClass.GetVeryLargeResponse();

I would expect result to be of type IEnumerable<MyDataObject>, so as to be able to get the Enumerator<MyDataObject> by calling result.GetEnumerator().

Where as I’m getting result which is of type MyNameSpace.<GetVeryLargeResponse>d_3 with no GetEnumerator() method available. I do see one of result‘s Super class being System.Collections.Generic.IEnumerable<MyClass>.

Is there a way I can iterate over this in Matlab or even to ‘cast’ result to IEnumerable<MyClass> in Matlab.

p.s.

1. Converting to Array / IList etc is not feasible due to data volume
2. This is not duplicate of How can I iterate over a C# IEnumerable in Matlab?, as that is dealing with IQueryable specifically.
3. I’m using Matlab 2010b

Answer 1

The result does have a GetEnumerator() method – it’s just may be implemented with explicit interface implementation.

If Matlab isn’t willing to handle that, you could always write your own mapping type and an extension method to make things simpler:

public static class Extensions
{
    public static EnumerableWrapper<T> Wrap<T>(this IEnumerable<T> source)
    {
        return new EnumerableWrapper<T>(source);
    }
}

public class EnumerableWrapper<T> : IEnumerable<T>
{
    private readonly IEnumerable<T> source;

    public EnumerableWrapper(IEnumerable<T> source)
    {
        this.source = source;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new EnumeratorWrapper<T>(source.GetEnumerator());
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class EnumeratorWrapper<T> : IEnumerator<T>
{
    private readonly IEnumerator<T> source;

    public EnumeratorWrapper(IEnumerator<T> source)
    {
        this.source = source;
    }

    public T Current { get { return source.Current; } }

    object IEnumerator.Current { get { return Current; } }

    public bool MoveNext()
    {
        return source.MoveNext();
    }

    public void Reset()
    {
        source.Reset();
    }

    public void Dispose()
    {
        source.Dispose();
    }

}

Then try:

result = MyClass.GetVeryLargeResponse().Wrap();

It seems very odd for Matlab not so support this out of the box though…