Отримати властивості в порядку оголошення за допомогою відображення

Мені потрібно отримати всі властивості, використовуючи відображення в тому порядку, в якому вони оголошені в класі. Згідно з MSDN, замовлення не може бути гарантоване під час використанняGetProperties()

Метод GetProperties не повертає властивості в певному порядку, наприклад алфавітному порядку чи порядку декларування.

Але я вже читав, що є обхідний шлях шляхом упорядкування властивостей за MetadataToken. Тож моє запитання: чи це безпечно? Здається, я не можу знайти про це інформацію на MSDN. Або існує інший спосіб вирішення цієї проблеми?

Моя поточна реалізація виглядає так:

var props = typeof(T)
   .GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
   .OrderBy(x => x.MetadataToken);

На .net 4.5 (і навіть .net 4.0 у vs2012) ви можете зробити набагато краще за допомогою відображення, використовуючи розумний трюк з [CallerLineNumber]атрибутом, дозволяючи компілятору вставляти порядок у ваші властивості для вас:

[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public sealed class OrderAttribute : Attribute
{
    private readonly int order_;
    public OrderAttribute([CallerLineNumber]int order = 0)
    {
        order_ = order;
    }

    public int Order { get { return order_; } }
}


public class Test
{
    //This sets order_ field to current line number
    [Order]
    public int Property2 { get; set; }

    //This sets order_ field to current line number
    [Order]
    public int Property1 { get; set; }
}

А потім використовуйте рефлексію:

var properties = from property in typeof(Test).GetProperties()
                 where Attribute.IsDefined(property, typeof(OrderAttribute))
                 orderby ((OrderAttribute)property
                           .GetCustomAttributes(typeof(OrderAttribute), false)
                           .Single()).Order
                 select property;

foreach (var property in properties)
{
   //
}

Якщо вам доводиться мати справу з частковими класами, ви можете додатково відсортувати властивості за допомогою [CallerFilePath].

Якщо ви йдете по шляху атрибутів, ось метод, який я використовував раніше;

public static IOrderedEnumerable<PropertyInfo> GetSortedProperties<T>()
{
  return typeof(T)
    .GetProperties()
    .OrderBy(p => ((Order)p.GetCustomAttributes(typeof(Order), false)[0]).Order);
}

Тоді використовуйте його так;

var test = new TestRecord { A = 1, B = 2, C = 3 };

foreach (var prop in GetSortedProperties<TestRecord>())
{
    Console.WriteLine(prop.GetValue(test, null));
}

Де;

class TestRecord
{
    [Order(1)]
    public int A { get; set; }

    [Order(2)]
    public int B { get; set; }

    [Order(3)]
    public int C { get; set; }
}

Метод буде барф, якщо ви запускаєте його на типі без порівнянних атрибутів для всіх ваших властивостей, очевидно, тому будьте обережні, як він використовується, і цього повинно бути достатньо для вимог.

Я залишив визначення замовлення: атрибут, оскільки в посиланні Yahia на пост Марка Гравелла є хороший зразок.

На думку MSDN, MetadataToken він унікальний всередині одного модуля - нічого не говорить про те, що він взагалі гарантує будь-яке замовлення.

НАВІТЬ якби він поводився так, як ти хочеш, це було б специфічним для реалізації та могло змінитися будь-коли без попередження.

Дивіться цей старий запис у блозі MSDN .

Я настійно рекомендую уникати будь-якої залежності від таких деталей реалізації - див. Цю відповідь від Марка Гравелла .

ЯКЩО вам потрібно щось під час компіляції, ви можете поглянути на Roslyn (хоча це на дуже ранній стадії).

Те, що я перевірив сортування за допомогою MetadataToken, працює.

Деякі користувачі тут стверджують, що це якось невдалий підхід / не надійний, але я ще не бачив жодних доказів цього - можливо, ви можете розмістити тут якийсь фрагмент коду, коли даний підхід не працює?

Про зворотну сумісність - поки ви зараз працюєте над .net 4 / .net 4.5 - Microsoft робить .net 5 або новішу версію, тому ви майже можете припустити, що цей метод сортування не буде порушено в майбутньому.

Звичайно, можливо, до 2017 року, коли ви перейдете на .net9, ви перервете сумісність, але до того часу хлопці Microsoft, ймовірно, зрозуміють "офіційний механізм сортування". Немає сенсу повертатися назад або ламати речі.

Гра з додатковими атрибутами для впорядкування властивостей також вимагає часу та реалізації - навіщо турбуватися, якщо сортування MetadataToken працює?

Ви можете використовувати DisplayAttribute у System.Component.DataAnnotations замість спеціального атрибута. Ваша вимога все одно має щось робити з дисплеєм.

Якщо вас влаштовує додаткова залежність, для цього можна використовувати протобуф -мережу Марка Гравелла, не турбуючись про найкращий спосіб відображення та кешування тощо. Просто прикрасьте свої поля за допомогою, [ProtoMember]а потім перейдіть до полів у цифровому порядку, використовуючи:

MetaType metaData = ProtoBuf.Meta.RuntimeTypeModel.Default[typeof(YourTypeName)];

metaData.GetFields();

Я зробив це так:

 internal static IEnumerable<Tuple<int,Type>> TypeHierarchy(this Type type)
    {
        var ct = type;
        var cl = 0;
        while (ct != null)
        {
            yield return new Tuple<int, Type>(cl,ct);
            ct = ct.BaseType;
            cl++;
        }
    }

    internal class PropertyInfoComparer : EqualityComparer<PropertyInfo>
    {
        public override bool Equals(PropertyInfo x, PropertyInfo y)
        {
            var equals= x.Name.Equals(y.Name);
            return equals;
        }

        public override int GetHashCode(PropertyInfo obj)
        {
            return obj.Name.GetHashCode();
        }
    }

    internal static IEnumerable<PropertyInfo> GetRLPMembers(this Type type)
    {

        return type
            .TypeHierarchy()
            .SelectMany(t =>
                t.Item2
                .GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
                .Where(prop => Attribute.IsDefined(prop, typeof(RLPAttribute)))
                .Select(
                    pi=>new Tuple<int,PropertyInfo>(t.Item1,pi)
                )
             )
            .OrderByDescending(t => t.Item1)
            .ThenBy(t => t.Item2.GetCustomAttribute<RLPAttribute>().Order)
            .Select(p=>p.Item2)
            .Distinct(new PropertyInfoComparer());




    }

із заявленим майном:

  [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class RLPAttribute : Attribute
{
    private readonly int order_;
    public RLPAttribute([CallerLineNumber]int order = 0)
    {
        order_ = order;
    }

    public int Order { get { return order_; } }

}

Спираючись на прийняте вище рішення, щоб отримати точний індекс, ви можете використовувати щось подібне

Дано

public class MyClass
{
   [Order] public string String1 { get; set; }
   [Order] public string String2 { get; set; }
   [Order] public string String3 { get; set; }
   [Order] public string String4 { get; set; }   
}

Розширення

public static class Extensions
{

   public static int GetOrder<T,TProp>(this T Class, Expression<Func<T,TProp>> propertySelector)
   {
      var body = (MemberExpression)propertySelector.Body;
      var propertyInfo = (PropertyInfo)body.Member;
      return propertyInfo.Order<T>();
   }

   public static int Order<T>(this PropertyInfo propertyInfo)
   {
      return typeof(T).GetProperties()
                      .Where(property => Attribute.IsDefined(property, typeof(OrderAttribute)))
                      .OrderBy(property => property.GetCustomAttributes<OrderAttribute>().Single().Order)
                      .ToList()
                      .IndexOf(propertyInfo);
   }
}

Використання

var myClass = new MyClass();
var index = myClass.GetOrder(c => c.String2);

Зверніть увагу , немає перевірки помилок або стійкості до несправностей, ви можете додати перець і сіль за смаком

Інша можливість полягає у використанні System.ComponentModel.DataAnnotations.DisplayAttribute Orderвласності. Оскільки він вбудований, немає необхідності створювати новий конкретний атрибут.

Потім виберіть такі впорядковані властивості

const int defaultOrder = 10000;
var properties = type.GetProperties().OrderBy(p => p.FirstAttribute<DisplayAttribute>()?.GetOrder() ?? defaultOrder).ToArray();

І клас можна представити так

public class Toto {
    [Display(Name = "Identifier", Order = 2)
    public int Id { get; set; }

    [Display(Name = "Description", Order = 1)
    public string Label {get; set; }
}