i am attempting to create an 

```
    IEnumrable<PropertyInfo> 

```

iv'e got a method called Disassemble which iterates recursively throw a given object and all it's child objects of it's properties .

**please do not concern your self with the Inner wrapper objects of type INameValueWrapper**

The problem below is when i encounter a property which is a Class i wan't to call Disassemble on it as well 
and add it to the same iteration of the IEnumrable , the Dissasemble does not occur again when it is called 
where i put the comment :
 **// The problem is here .**

```
    public static IEnumerable<T> Dissasemble<T>(this object sourceObj) where T : INameValueWrapper
    {
        var properties = sourceObj.GetType().GetProperties();

        foreach (var prop in properties)
        {
            var wrapper = (T)prop.WrapPropertyInfo(sourceObj);
            yield return wrapper;

            if (wrapper is CollectionPropertyInfoWrapper)
            {
                var colWrapper = wrapper as CollectionPropertyInfoWrapper;
                var collection = (IList)colWrapper.Value;

                int index = 0;
                foreach (var item in collection)
                {
                    yield return (T)item.WrapItem(collection, index + 1);
                    index++;
                }
            }
            else
            {
                var propWrapper = wrapper as PropertyInfoWrapper;
                if (!propWrapper.IsPrimitive)
                {
                    var childObject = prop.GetValue(sourceObj);
                    childObject.Dissasemble<T>(); // here is the problem 
                }
            }
        }

        yield break;
    } 

```

1) Why does it not get called and added to the iteration ?

2) What is the work around this issue ? , 

```
 i could call childObject.Dissasemble<T>().ToList() 
 and then iterate that collection calling yield return on it's items 
 but that seems like re doing something i already did.

```

thanks in advance.