Get properties of anonymous type in declared order

Question

I need to get names of all properties of anonymous type exactly in the order they are declared.

To get them, I can use Type.GetProperties method. It seems to return properties in "correct" order, but according to MSDN I cannot depend on it, because that order might vary.

I also found TypeInfo.DeclaredProperties property which gives me result I expect, but I cannot found any info whether the order is guaranteed or not (at least MSDN doesn't explicitly state it's not guaranteed).

Or is there any other way? It's probably irrelevant, but the anonymous type is actually part of Expression. But I'm not aware of anything in Expression Trees API which can help.

I'm targeting .NET Standard 2.0 and it should work on full .NET framework, .NET Core and Mono/Xamarin.

Sample code:

static void Main(string[] args)
{
    Foo(() => new { Lorem = 1, Ipsum = 2, Dolor = "sit amet" });
}

static void Foo<T>(Expression<Func<T>> expression)
{
    var node = (NewExpression)expression.Body;

    // seems to work, but GetProperties doesn't guarantee order according to MSDN
    var names1 = node.Type.GetProperties().Select(p => p.Name).ToArray();
    // names1 = "Lorem", "Ipsum", "Dolor"

    // seems to work, but is it "bulletproof"?
    var names2 = node.Type.GetTypeInfo().DeclaredProperties.Select(p => p.Name).ToArray();
    // names2 = "Lorem", "Ipsum", "Dolor"
}

Edit: I purposely didn't write exactly why I need it, because I find my specific scenario unnecessarily complicated to explain and wanted to keep the question simple. Long story short - I'm exploring possibilities for micro-ORM API based on parsing expression trees. Not my original case, but here is an example of hypothetical use case where knowing the order is important (I'm not saying such API for sorting is good idea! I just want to know whether something like this is possible):

// translates to SELECT Column1, Column2 FROM Table ORDER BY Column3, Column1
db.From<Table>()
  .Select((x) => new { x.Column1, x.Column2 })
  .OrderBy((x) => new { x.Column3, x.Column1 });

Answer 1

For an anonymous type, there is always a constructor that takes all of initial property values as arguments, in the same order they are declared. You can get the position of the constructor argument with the Position property.

See this question to figure out how to get the constructor parameters' names. You can then match those to the type's properties.

public static class ExtensionMethods
{
    public static IEnumerable<PropertyInfo> GetPropertiesInOrder<T>(this T This)
    {
        var type = typeof(T);
        var ctor = type.GetConstructors().Single();
        var parameters = ctor.GetParameters().OrderBy( p => p.Position );
        foreach (var p in parameters)
        {
            yield return type.GetProperty(p.Name);
        }
    }
}

public class Program
{
    public static void Main()
    {
        var o = new { Id = 12, Name="Foo" };
        var list = o.GetPropertiesInOrder();
        foreach (var p in list)
        {
            Console.WriteLine("{0} {1}", p.PropertyType.Name, p.Name);
        }
    }
}

Output:

Int32 Id
String Name

Note: The order of constructor parameters is reliable as it is detailed in the C# language specification (section 7.6.10.6):

An anonymous object initializer declares an anonymous type and returns an instance of that type. An anonymous type is a nameless class type that inherits directly from object. The members of an anonymous type are a sequence of read-only properties inferred from the anonymous object initializer used to create an instance of the type. Specifically, an anonymous object initializer of the form

    new { p1 = e1 , p2 = e2 , … pn = en }

declares an anonymous type of the form

class __Anonymous1
{
    private readonly T1 f1 ;
    private readonly T2 f2 ;
    …
    private readonly Tn fn ;
    public __Anonymous1(T1 a1, T2 a2,…, Tn an) {
        f1 = a1 ;
        f2 = a2 ;
        …
        fn = an ;
    }
    public T1 p1 { get { return f1 ; } }
    public T2 p2 { get { return f2 ; } }
    …
    public T1 p1 { get { return f1 ; } }
    public override bool Equals(object o) { … }
    public override int GetHashCode() { … }
}

where each Tx is the type of the corresponding expression ex.

This specifically defines an anonymous type as a sequence of properties where order is significant and the constructor accepts the initialization data in the same order.

Answer 2

Based on the example you added to explain why you are doing this... I would like to propose a simple answer, assuming you have an X/Y Problem.

Can you change this (which isn't valid syntax anyway):

// translates to SELECT Column1, Column2 FROM Table ORDER BY Column3, Column1
db.From<Table>()
  .Select((x) => new { x.Column1, x.Column2 })
  .OrderBy((x) => new { x.Column3, x.Column1 });

To something more like this?:

// translates to SELECT Column1, Column2 FROM Table ORDER BY Column3, Column1
db.From<Table>()
  .Select((x) => new [] { x.Column1, x.Column2 })
  .OrderBy((x) => new [] { x.Column3, x.Column1 });

Notice now instead of an anonymous type (where getting the order of properties is a problem) we are using an array (where getting the order is trivial). The syntax is very similar (we just had to add []) but the behavior is much more clearly defined.