Question

我有以下课程

public class Car
{
    public int CarId { get; set;}
    public string Description { get; set;}
    public Engine Engine { get; set;}
}

public class Engine
{
    public int EngineId { get; set;}
    public int Description { get; set;}
}

现在我想迭代Car中的所有属性以及Engine中的所有属性，我不想硬编码属性名称“Car or Engine”

获取Car的所有属性的示例，其中obj是Car的实例。

var properties = obj.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public);

但这并没有迭代Engine的属性。

Answer 1

FlattenHierarchy不会按照您的想法执行，而是遵循静态成员的继承权限。

如果你想获得对象的子属性，你需要自己做：

static IEnumerable<PropertyInfo> FlattenProperties(Type type)
{
    // Assumption #1: you do not want "simple" types enumerated
    if (!type.IsClass)
        return Enumerable.Empty<PropertyInfo>();

    // Assumption #2: you want to ignore "the usual suspects"
    if (type.Namespace != null && type.Namespace.StartsWith("System"))
        return Enumerable.Empty<PropertyInfo>();

    // Assumption #3: your class hierarchy won't destroy recursion
    // Assumption #4: you simply want the PropertyInfo
    return type.GetProperties(BindingFlags.FlattenHierarchy
                            | BindingFlags.Instance
                            | BindingFlags.Public)
               .SelectMany(pi => new[] { pi }
                              .Concat(FlattenProperties(pi.PropertyType)));
}

如果在代码中使用它（a）知道递归的深度，（b）有改变代码的方法，我建议为这些类型创建基类，接口或属性/属性。

// Replace Assumptions #1 and #2 above with this:
// Assumption #5: given interface ISomething { }
if (!typeof(ISomething).IsAssignableFrom(type))
    return Enumerable.Empty<PropertyInfo>();

如果您需要“属性树”（即假设＃4不正确）：

static IEnumerable<IEnumerable<PropertyInfo>> FlattenProperties(
    Type type,
    IEnumerable<PropertyInfo> ancestors = null)
{
    // change to Assumptions #1/#2 or #5 to yield break
    // ...

    ancestors = ancestors ?? Enumerable.Empty<PropertyInfo>();
    var properties = type.GetProperties(
                          BindingFlags.FlattenHierarchy
                        | BindingFlags.Instance
                        | BindingFlags.Public);
    foreach (var property in properties)
    {
        // again, Assumption #3: your class hierarchy won't destroy recursion
        // Assumption #6: you actually want the initial nested property too
        yield return ancestors.Concat(new[] { property });
        foreach (var nested in FlattenProperties(
            property.PropertyType, 
            ancestors.Concat(new [] { property })))
        {
            yield return nested;
        }
    }
}

在第二种情况下，产生的输出类似于：

// foreach (var tree in FlattenProperties(typeof(Car)))
// {
// Console.WriteLine("{0}", String.Join(".", tree.Select(pi => pi.Name)));
// }
CarId
Description
Engine
Engine.EngineId
Engine.Description

Answer 2

试试这个。您必须为类型的所有属性重复相同操作才能获得嵌套属性。

var properties = obj.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public);
foreach(var pi in properties)
{
    var nestedProperties = pi.PropertyType.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public);
}

Answer 3

您可以只迭代每个属性PropertyType的属性，就像您获取第一级属性一样。

这是使用Linq的一个快速而肮脏的例子：

var properties =
    from p1 in obj.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public)
    from p2 in p1.PropertyType.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public).DefaultIfEmpty()
    select new { OuterProperty = p1, InnerProperty = p2 };

foreach(var prop in properties)
{
    Console.WriteLine(prop.OuterProperty.Name + (prop.InnerProperty != null ? "." + prop.InnerProperty.Name : ""));
}

产生输出：

CarId
Description.Chars
Description.Length
Engine.EngineId
Engine.Description

您可能只想评估给定命名空间中的类（例如，您最终不会捕获Length的{{1}}属性）：

Description

产生输出：

var properties =
    from p1 in obj.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public)
    from p2 in p1.PropertyType.Namespace == "MyNamespace" 
        ? p1.PropertyType.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public).DefaultIfEmpty()
        : new PropertyInfo[] { null }
    select new { OuterProperty = p1, InnerProperty = p2 };

或者更优雅的是，如果您定义某个属性来标记要遍历的属性：

CarId
Description
Engine.EngineId
Engine.Description

这将产生与前一个示例相同的输出。

Answer 4

如果您只需要原始类及其第一个较低层次级别的属性，那么您可以像这样创建以下属性。

public class BrowsableAttribute : Attribute { }

现在只需装饰要浏览属性的类，在您的情况下，就是Engine类。

[Browsable]
class Engine
{
    public int EngineId { get; set; }
    public int Description { get; set; }
}

现在您需要做的就是使用以下扩展方法。

public static class TypeExtensions
{
    public static void BrowseProperties(this Type type)
    {
        var h1 = typeof(Car).GetProperties().ToList();            
        var h2 = h1.Where(x => x.PropertyType.GetCustomAttributes(true).OfType<BrowsableAttribute>().Any());                       

        h2.ToList().ForEach(x => h1.AddRange(x.PropertyType.GetProperties()));
        h1.ForEach(x => Console.WriteLine(x.Name));
    }
}

这将产生所需的结果。要查看此内容，请执行以下代码行。

class Program
{
    static void Main()
    {
        typeof(Engine).BrowseProperties();

        Console.Read();
    }
}

迭代属性和嵌套的第一级属性

4 个答案: