प्रतिबिंब का उपयोग करके घोषणा के क्रम में गुण प्राप्त करें

Question 1

मुझे कक्षा में जिस क्रम में घोषित किया गया है, उसमें प्रतिबिंब का उपयोग करके सभी गुण प्राप्त करने की आवश्यकता है। MSDN के अनुसार उपयोग करते समय आदेश की गारंटी नहीं दी जा सकती हैGetProperties()

GetProperties विधि एक विशेष क्रम में गुण नहीं लौटाती है, जैसे कि वर्णमाला या घोषणा क्रम।

लेकिन मैंने पढ़ा है कि गुणों को क्रम में रखकर वर्कअराउंड है MetadataToken। तो मेरा सवाल यह है कि क्या यह सुरक्षित है? मुझे लगता है कि इसके बारे में MSDN पर कोई जानकारी नहीं मिल सकती। या इस समस्या को सुलझाने का कोई और तरीका है?

मेरा वर्तमान कार्यान्वयन निम्नानुसार है:

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

Question 2

.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]।

Question 3

यदि आप विशेषता मार्ग पर जा रहे हैं, तो यहां एक विधि है जिसका मैंने अतीत में उपयोग किया है;

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; }
}

यदि आप इसे स्पष्ट रूप से अपने सभी गुणों पर तुलनीय विशेषताओं के बिना एक प्रकार पर चलाते हैं, तो विधि बारफ होगी, इसलिए सावधान रहें कि इसका उपयोग कैसे किया जाता है और यह आवश्यकता के लिए पर्याप्त होना चाहिए।

मैंने ऑर्डर की परिभाषा को छोड़ दिया है: मार्क ग्रेवेल के पद के साथ याहिया की कड़ी में एक अच्छा नमूना होने के कारण इसे स्वीकार करें।

Question 4

MSDN के अनुसार MetadataTokenएक मॉड्यूल के अंदर अद्वितीय है - ऐसा कुछ भी नहीं कहा गया है कि यह किसी भी क्रम की गारंटी देता है।

EVEN अगर यह व्यवहार करता है जिस तरह से आप चाहते हैं कि यह कार्यान्वयन-विशिष्ट होगा और बिना सूचना के कभी भी बदल सकता है।

इस पुराने MSDN ब्लॉग प्रविष्टि को देखें ।

मैं इस तरह के कार्यान्वयन विवरण पर किसी भी निर्भरता से दूर रहने की जोरदार सिफारिश करूंगा - मार्क ग्रेवेल का यह उत्तर देखें ।

यदि आपको संकलन के समय कुछ चाहिए तो आप रोजलिन पर एक नज़र डाल सकते हैं (हालाँकि यह बहुत शुरुआती चरण में है)।

Question 5

मेटाडेटाटोकन कार्यों द्वारा मैंने जो छँटाई का परीक्षण किया है।

यहाँ कुछ उपयोगकर्ता दावा करते हैं कि यह किसी भी तरह से अच्छा दृष्टिकोण नहीं है / विश्वसनीय नहीं है, लेकिन मैंने अभी तक उस एक का कोई सबूत नहीं देखा है - शायद आप कुछ कोड स्निपेट यहाँ पोस्ट कर सकते हैं जब दिए गए दृष्टिकोण काम नहीं करते हैं?

बैकवर्ड संगतता के बारे में - जब आप अब अपने .net 4 / .net 4.5 पर काम कर रहे हैं - Microsoft .net 5 या इससे अधिक बना रहा है, तो आप बहुत मान सकते हैं कि यह छँटाई विधि भविष्य में नहीं तोड़ी जाएगी।

निश्चित रूप से 2017 तक जब आप .net9 में अपग्रेड होंगे, तो आप संगतता ब्रेक मारेंगे, लेकिन उस समय तक Microsoft लोग संभवतः "आधिकारिक सॉर्ट तंत्र" का पता लगा लेंगे। वापस जाने या चीजों को तोड़ने का कोई मतलब नहीं है।

प्रॉपर्टी ऑर्डरिंग के लिए अतिरिक्त विशेषताओं के साथ खेलने में भी समय और कार्यान्वयन लगता है - अगर मेटाडेटाटोकन सॉर्टिंग काम करता है तो परेशान क्यों करें?

Question 6

आप कस्टम विशेषता के बजाय System.Component.DataAnnotations में DisplayAttribute का उपयोग कर सकते हैं। आपकी आवश्यकता वैसे भी प्रदर्शन के साथ कुछ करने की है।

Question 7

यदि आप अतिरिक्त निर्भरता से खुश हैं, तो मार्क ग्रेवेल के प्रोटोबॉफ-नेट का उपयोग प्रतिबिंब और कैशिंग आदि को लागू करने के सर्वोत्तम तरीके के बारे में चिंता किए बिना किया जा सकता है। बस अपने खेतों का उपयोग करके सजाने [ProtoMember]और फिर उपयोग करके संख्यात्मक क्रम में खेतों तक पहुंचें।

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

metaData.GetFields();

Question 8

मैंने इसे इस तरह किया:

 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_; } }

}

Question 9

उपरोक्त स्वीकृत समाधान पर निर्माण, सटीक सूचकांक प्राप्त करने के लिए आप कुछ इस तरह का उपयोग कर सकते हैं

दिया हुआ

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);

ध्यान दें , कोई त्रुटि जाँच या दोष सहिष्णुता नहीं है, आप स्वाद के लिए काली मिर्च और नमक जोड़ सकते हैं

Question 10

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; }
}