解析程序集中的类型层次结构

Question

Consider the following types in an assembly: BusinessPartnerList, BusinessPartner, PrivateData, CompanyData, AddressList, Address

Type BusinessPartnerList 
{ 
    BusinessPartner[] 
}

Type BusinessPartner 
{
   PrivateData
   CompanyData
   AddressList
}

Type PrivateData
{
    System.String FirstName
    System.String SurName
}

Type PrivateData
{
    System.String CompanName1
    System.String CompanName2
}

Type AddressList
{
  Address[]
}

I want to generic parse the type hierarchy, and represent them in a tree eg simple nodes

BusinessPartnerList[] BusinessPartner PrivateData CompanyData AddressList[] Address

What is the best way to do this?

Answer 1

Unfortunately you didn't use proper C# syntax for your sample data. So I have to make some assumptions:

• Type is actually class (or struct ).

• The contents of the types ( BusinessPartner , PrivateData , CompanyData etc.) represent the types of some public properties.

To parse the type hierarchy you can use reflection. Find all public properties of a given type and return their types. Since you only want the types you can use a HashSet which will only contain distinct types:

public static HashSet<Type> GetPropertyTypes(Type type)
{
    return new HashSet<Type>(type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
                                 .Select(prop => prop.PropertyType));
}

However, it seems that you don't want to get information on arrays but rather on the type of the array elements. The same goes for lists. So if a type implements IEnumerable<T> you want to get information on the type T :

private static Type GetElementType(Type type)
{
    Type enumerableType = type.GetInterfaces().FirstOrDefault(IsGenericEnumerable);

    if (enumerableType != null)
    {
        Type[] genericArguments = enumerableType.GetGenericArguments();

        return genericArguments[0];
    }

    // return 'object' for a non-generic IEnumerable
    return typeof(IEnumerable).IsAssignableFrom(type) ? typeof(object) : type;
}

private static bool IsGenericEnumerable(Type type)
{
    return type.IsGenericType &&
           type.GetGenericTypeDefinition() == typeof(IEnumerable<>);
}

Note that for the type System.String this will return char because string implements IEnumerable<char> (I will adress that later).

The .NET framework does not have a tree structure you can use out of the box. So you need to implement it yourself:

public class Node<T>
{
    public Node(T value, IEnumerable<Node<T>> children)
    {
        Value = value;
        Children = children.ToList();
    }

    public T Value
    {
        get;
        private set;
    }

    public List<Node<T>> Children
    {
        get;
        private set;
    }
}

This is a very basic implementation just for demonstration purposes.

Instead of returning List<Type> the GetPropertyTypes method can now return Node<Type> and it should be renamed to CreateTypeNode :

public static Node<Type> CreateTypeNode(Type type)
{
    var children = type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
                       .Select(prop => GetElementType(prop.PropertyType))
                       .Select(CreateTypeNode);

    return new Node<Type>(type, children);
}

This method uses recursion to create the full tree for the given type.

There is still a problem: What if type A references type B and vice versa? This would end up in an infinite recursive loop. And also: if a type has already been visited there is no need to do that again.

What we need is a cache for the types that have been visited. If a type is in the cache we use the information from the cache:

private static readonly Dictionary<Type, Node<Type>> _visitedTypes = new Dictionary<Type, Node<Type>>();

public static Node<Type> CreateTypeNode(Type type)
{
    Node<Type> node;
    if (_visitedTypes.TryGetValue(type, out node))
    {
        return node;
    }

    // add the key to the cache to prevent infinite recursion; the value will be set later
    // if this type will be found again in a recursive call CreateTypeNode returns null
    // (null will be filtered out then)
    _visitedTypes.Add(type, null);

    var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);

    var types = new HashSet<Type>(properties.Select(prop => GetElementType(prop.PropertyType)));

    var children = types.Select(CreateTypeNode).Where(n => n != null);

    node = new Node<Type>(type, children);
    _visitedTypes[type] = node;

    return node;
}

I you don't want the string type to be reported as char (because string implements IEnumerable<char> ) you can just add a node for string to the cache before you call GetOrCreateTypeNode for the first time:

_visitedTypes.Add(typeof(string), new Node<Type>(typeof(string), new List<Node<Type>>()));

Then check the cache in the GetElementType method:

private static Type GetElementType(Type type)
{
    if (_visitedTypes.ContainsKey(type))
    {
        return type;
    }

    ...
}