在c#中通过反射在对象内部爬行时防止堆栈溢出

我有这个方法叫做MatchNodes: IEnumerable<bool> MatchNodes<T>(T n1, T n2)

它基本上从两个T对象(通过反射，不包括基类的属性/字段)获得每个属性和字段，并比较它们，返回结果作为一个IEnumerable of bools。

当它找到一个基本类型或字符串时，if只返回它们之间的==。

当它找到从集合派生的类型时，它迭代每个成员并为每个成员调用MatchNodes(哎哟)。

当发现任何其他类型时，它为每个属性/字段调用MatchNodes。

我的解决方案显然是请求堆栈溢出异常，但我不知道如何使它更好，因为我不知道对象将进入多深。

代码(请尽量不要哭，它很难看):

public static IEnumerable<bool> MatchNodes<T>(T n1, T n2)
    {
        Func<PropertyInfo, bool> func= null;
        if (typeof(T) == typeof(String))
        {
            String str1 = n1 as String;
            String str2 = n2 as String;
            func = new Func<PropertyInfo, bool>((property) => str1 == str2);
        }
        else if (typeof(System.Collections.IEnumerable).IsAssignableFrom(typeof(T)))
        {
            System.Collections.IEnumerable e1 = (System.Collections.IEnumerable)n1;
            System.Collections.IEnumerable e2 = (System.Collections.IEnumerable)n2;
            func = new Func<PropertyInfo, bool>((property) =>
            {
                foreach (var v1 in e1)
                {
                    if (e2.GetEnumerator().MoveNext())
                    {
                        var v2 = e2.GetEnumerator().Current;
                        if (((IEnumerable<bool>)MatchNodes(v1, v2)).All(b => b == true))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
                if (e2.GetEnumerator().MoveNext())
                {
                    return false;
                }
                else return true;
            });
        }
        else if (typeof(T).IsPrimitive || typeof(T) == typeof(Decimal))
        {
            func = new Func<PropertyInfo, bool>((property) => property.GetValue(n1, null) == property.GetValue(n2, null)); 
        }
        else
        {
            func = new Func<PropertyInfo, bool>((property) =>
                    ((IEnumerable<bool>)MatchNodes(property.GetValue(n1, null),
                    property.GetValue(n2, null))).All(b => b == true));
        }
        foreach (PropertyInfo property in typeof(T).GetProperties().Where((property) => property.DeclaringType == typeof(T)))
        {
            bool result =func(property);
            yield return result;
        }
    }

我正在寻找的是一种无需递归调用我的方法就可以爬进对象的方法。

编辑

说明一下，例如:

public class Class1 : RandomClassWithMoreProperties{
    public string Str1{get;set;}
    public int Int1{get;set;}
}
public class Class2{
    public List<Class1> MyClassProp1 {get;set;}
    public Class1 MyClassProp2 {get;set;}
    public string MyStr {get;set;}
}

MatchNodes(n1,n2)，其中n1.GetType()和n2.GetType()是Class2，如果:

• MyClassProp1中的每个Class1对象都有相同的Str1, Int1
• MyClassProp2对于两个对象具有相同的Str1, Int1
• MyStr对于两个对象是相等的

我不会比较RandomClassWithMoreProperties中的任何属性

 var stack = new Stack<Tuple<object, object>>();
 // prime the stack
 foreach (var prop in n1.GetType().GetProperties())
 {
     stack.Push(Tuple.Create(prop.GetValue(n1), prop.GetValue(n2));
 }
 while (stack.Count > 0)
 {
     var current = stack.Pop();
     // if current is promitive: compare
     // if current is enumerable: push all elements as Tuples on the stack
     // else: push all properties as tuples on the stack
 }