C# Reflection property order

Question

I am using the code in https://stackoverflow.com/a/531388/528131 to successfully retrieve all the properties of an object instance from a base, the problem being that the derived type's properties are being iterated over first. Due to the nature of the protocol, i need the base properties first.

x |
y | B
z |
w | A

B and A are classes, B derives from A. x, y, z are properties from B and w is a property from A

This is a scheme of how A.GetProperties(); is returning. I need this instead:

w | A
x |
y | B
z |

Is there any way to get the fields in that order EXACTLY?

Answer 1

The fields in a type are not "ordered". The ordering of the items in those methods is an implementation detail and relying on them is strongly discouraged.

You should order the items yourself, with the expectation that they could start at any position, to ensure your program is robust instead of fragile.

Since each property can be asked for the type that declares it you can create a lookup at the start that gives a number to each class in the hierarchy from the type you start with all the way up to object by walking the BaseType property of Type and order by the lookup value of the declaring type of each property:

public static IEnumerable<PropertyInfo> GetOrderedProperties(Type type)
{
    Dictionary<Type, int> lookup = new Dictionary<Type, int>();

    int count = 0;
    lookup[type] = count++;
    Type parent = type.BaseType;
    while (parent != null)
    {
        lookup[parent] = count;
        count++;
        parent = parent.BaseType;
    }

    return type.GetProperties()
        .OrderByDescending(prop => lookup[prop.DeclaringType]);
}

Answer 2

All you have to do is group by declaring type and reverse the list

 var publicProperties = typeof(T).GetProperties()
                .GroupBy(p => p.DeclaringType)
                .Reverse()
                .SelectMany(g => g)
                .ToArray();

Answer 3

The documentation for the reflection subsystem says that you cannot rely on the order in which the elements are returned.

That said, it has always been my experience that elements are returned in order of declaration in the source file. This may or may not be true on Mono or on future revisions of .NET.

Your best option, should you wish to proceed in spite of the above, is to use the BindingFlags.DeclaredOnly option and manually traverse the inheritance hierarchy (scanning base types before subtypes to get them in the right order). You should write your code in such a way that the ordering of properties from a single declared type does not matter (such as, sorting them by name); this will make your code more robust, should the behavior of the .NET framework ever change.

Fasterflect does this (mostly in order to be able to filter out virtual properties that have been overridden). It also has helpers to obtain the properties, filtered or not, using it's own and more powerful Flags selector parameter.

If ordering of the elements within a single type is not important, you could get the list (using Fasterflect) like this:

var properties = type.Properties().Reverse().ToList();

You should be aware that overridden properties will be included multiple times when reflecting this way (by traversing and only getting the declared properties). Fasterflect offers options to filter these from the result:

var properties = type.Properties( Flags.InstancePublic | Flags.ExcludeBackingMembers ).Reverse().ToList();

If you don't wish to take a dependency on the library, the code is open source, so you could pick the bits you need. The traversal algorithm can be seen here (line 443).

Answer 4

As an alternative method of sorting:

PropertyInfo[] properties = type.GetProperties(...);
Array.Sort(properties, (pi1, pi2) =>
    {
        if (pi1.DeclaringType.IsSubclassOf(pi2.DeclaringType))
           return 1;
        else if  (pi2.DeclaringType.IsSubclassOf(pi1.DeclaringType))
            return -1;
        else
            return 0;
    });

Answer 5

As some people pointed out, relying on the reflection call may be a fragile approach. I'd use additional means to ensure the ordering intentionally, for example by applying an attribute. If you have control over the classes you work on, you may use the pre-existing DataMember attribute on your types. It has a neat Order property which is used to ensure the type fields are serialized in the specified order (some systems may require objects in their communication protocols to respect field oreder, and .NET's data contract serialization achieves this with the help of that attribute field).

However, we may use the semantics ot this to achieve your requirement as well (which could be fine, since your task seems like a form of serialization). You're, of course, free to define a custom attribute class if you feel that the DataMemberAttribute is not OK to be used.

Rougly, I've modified @Rawling's interesting solution like this:

Array.Sort(
    typeof(T).GetProperties(),
    (a, b) =>
    {
        if (a.DeclaringType.IsSubclassOf(b.DeclaringType))
        {
            return -1; // order any property of base class before derived
        }
        else if (b.DeclaringType.IsSubclassOf(a.DeclaringType))
        {
            return 1; // order any property of base class before derived
        }
        else
        {
            // order two properties of the same class 
            // based on order attribute value

            int orderOfA = a.GetCustomAttributes<DataMemberAttribute>().SingleOrDefault()?.Order ?? 0;
            int orderOfB = b.GetCustomAttributes<DataMemberAttribute>().SingleOrDefault()?.Order ?? 0;
            return orderOfB - orderOfA;
        }
    });

If you want to mix base and derived properties in a custom order, you can just use the below snippet, as long as the attribute order values on each property in the base and derived class(es) are chosen with respect of each other:

Array.Sort(
    typeof(T).GetProperties(),
    (a, b) =>
    {
        int orderOfA = a.GetCustomAttributes<DataMemberAttribute>().SingleOrDefault()?.Order ?? 0;
        int orderOfB = b.GetCustomAttributes<DataMemberAttribute>().SingleOrDefault()?.Order ?? 0;
        return orderOfB - orderOfA;
    });

Answer 6

You can get the declaring type from the instance of PropertyInfo and order by its distance from Object.

This is how I would go about it:

void Main()
{
    typeof(B).GetProperties()
    .Select((x,i) => new {
        Prop = x,
        DeclareOrder = i,
        InheritanceOrder = GetDepth(x.DeclaringType),
    })
    .OrderByDescending(x => x.InheritanceOrder)
    .ThenBy(x => x.DeclareOrder)
    .Dump();
}

public class A
{
    public string W {get; set;}
}

public class B : A
{
    public string X {get; set;}
    public string Y {get; set;}
    public string Z {get; set;}
}

static int GetDepth(Type t)
{
    int depth = 0;
    while (t != null)
    {
        depth++;
        t = t.BaseType;
    }
    return depth;
}