получение всей информации свойств объекта алгоритма для использования стека или рекурсивных вызовов

Question

Существует следующий тип

public class Nested1
{
   public int Id {get; set;}
   public string Name {get; set;}
   public string Address {get; set;}
} 

public class Nested2
{
  public int Id {get; set;}
  public Nested1 Nested {get; set;}
}

Я бы хотел получить через type.GetProperties список всех свойств класса Nested2 и его подкласса Nested1, чтобы список был Nested2.Id, Nested2.Nested, Nested1.Id, Nested1.Name, Nested1.Address. Я сделал это с помощью рекурсии, возможно ли использование стека? Спасибо

Answer 1

Я не знаю, правильно ли это или неправильно то, что вы используете, но вы можете использовать отражение вместо него.

ИСПОЛЬЗУЙТЕ ЭТУ ССЫЛКУ НА ССЫЛКУ, надеюсь, это поможет вам

Answer 2

Я думаю, что алгоритм похож на

  SomeStructure GetFromObject(object o)
    { var tt = new Stack<Helper>();
            types.Push(new Helper { Type = o.GetType(), Name = string.Empty });

            while (tt.Count > 0)
            {
                Helper tHelper = tt.Pop();
                Type t = tHelper.Type;
                ProcessTheResults( add to a list, whatever ...);
                if (t.IsValueType || t == typeof(string))
                    continue;

                if (t.IsGenericType)
                {
                    foreach (var arg in t.GetGenericArguments())
                        tt.Push(new Helper { Type = arg, Name = string.Empty });
                    continue;

                }

                foreach (var propertyInfo in t.GetProperties())
                {
                    tt.Push(new Helper { Type = propertyInfo.PropertyType, Name = propertyInfo.Name });

                }
            }

            return result;
        }

, где класс Helper

 class Helper {public Type Type{get; set;}  public string Name {get; set;}}

Единственное, чего я не понимаю, это наличие следующей структуры:

  public class SimpleClass
{
    public int IdSimpleClass { get; set; }
    public string NameSimpleClass { get; set; }
}

public class NestingClass
{
    public string Address { get; set; }
    public List<SimpleClass> SimpleClass { get; set; }
}

public class SuperNestingClass
{
    public string SomeId { get; set; }
    public string AnotherId { get; set; }
    public Guid Guid { get; set; }
    public List<NestingClass> NestingClass { get; set; }
}

результат в консоли , так как вы можете указать, что адресом должно быть AddressNestingClass, а не просто Adress, поскольку свойство Address является членом NestingClass, а не SuperNestingClass.Есть идеи, почему это происходит?

Answer 3

Что-то вроде этого?

var types = new Queue<Type>();
var props = new List<PropertyInfo>();
types.Enqueue(typeof(Nested2));

while (types.Count > 0) {
    Type t = types.Dequeue();
    foreach (var prop in t.GetProperties()) {
        if (props.Contains(prop)) { continue; }
        props.Add(prop);
        if (IsCustomType(prop.PropertyType)) { types.Enqueue(prop.PropertyType); }
    }
}

Возможно, вам лучше использовать HashSet, как предложил Вячеслав Смитюх, если список может увеличиться.

Answer 4

Мне кажется, тебе нужно что-то вроде этого

public List<PropertyInfo> GetAllProperties(Type type)
{
    var result = new List<PropertyInfo>();
    var queue = new Queue<Type>();
    var processedTypes = new HashSet<Type>();

    queue.Enqueue(type);
    while (queue.Count > 0)
    {
        var currentType = queue.Dequeue();
        processedTypes.Add(currentType);

        var properties = currentType.GetProperties();
        result.AddRange(properties);

        var typesToProcess = properties
            .Select(p => p.PropertyType)
            .Distinct()
            .Where(pt => !pt.IsPrimitive)
            .Where(pt => !processedTypes.Contains(pt));

        foreach(var t in typesToProcess)
        {
            queue.Enqueue(t);
        }
    }

    return result;
}