c# - टाइप-सुरक्षित डाटाबेसिंग के लिए सी#में 'nameof' ऑपरेटर की कमी के लिए कामकाज?




.net data-binding (6)

Reshefm का जवाब बहुत अच्छा है, लेकिन यह थोड़ा आसान एपीआई आईएमओ है:

उपयोग उदाहरण: NameOf.Property(() => new Order().Status)

using System;
using System.Diagnostics.Contracts;
using System.Linq.Expressions;

namespace AgileDesign.Utilities
{
public static class NameOf
{
    ///<summary>
    ///  Returns name of any method expression with any number of parameters either void or with a return value
    ///</summary>
    ///<param name = "expression">
    ///  Any method expression with any number of parameters either void or with a return value
    ///</param>
    ///<returns>
    ///  Name of any method with any number of parameters either void or with a return value
    ///</returns>
    [Pure]
    public static string Method(Expression<Action> expression)
    {
        Contract.Requires<ArgumentNullException>(expression != null);

        return ( (MethodCallExpression)expression.Body ).Method.Name;
    }

    ///<summary>
    ///  Returns name of property, field or parameter expression (of anything but method)
    ///</summary>
    ///<param name = "expression">
    ///  Property, field or parameter expression
    ///</param>
    ///<returns>
    ///  Name of property, field, parameter
    ///</returns>
    [Pure]
    public static string Member(Expression<Func<object>> expression)
    {
        Contract.Requires<ArgumentNullException>(expression != null);

        if(expression.Body is UnaryExpression)
        {
            return ((MemberExpression)((UnaryExpression)expression.Body).Operand).Member.Name;
        }
        return ((MemberExpression)expression.Body).Member.Name;
    }
  }
}

पूर्ण कोड यहां है: http://agiledesignutilities.codeplex.com/SourceControl/changeset/view/b76cefa4234a#GeneralPurpose/NameOf.cs

सी # में ऑपरेटर का नाम शामिल करने के लिए बहुत सारी भावनाएं रही हैं। इस ऑपरेटर के काम के तरीके के उदाहरण के रूप में, nameof(Customer.Name) "Name" nameof(Customer.Name) स्ट्रिंग "Name" वापस कर देगा।

मेरे पास एक डोमेन ऑब्जेक्ट है। और मुझे इसे बांधना है। और मुझे स्ट्रिंग्स के रूप में गुणों के नामों की आवश्यकता है। और मैं उन्हें टाइप-सुरक्षित होना चाहता हूं।

मुझे याद है कि .NET 3.5 में एक वर्कअराउंड में आ रहा है जो nameof और कार्यक्षमता लैम्ब्डा अभिव्यक्तियों की कार्यक्षमता प्रदान करता है। हालांकि, मैं इस कामकाज का पता लगाने में सक्षम नहीं हूं। क्या कोई मुझे उस कामकाज प्रदान कर सकता है?

मुझे यह भी संभव है कि .NET 2.0 में नाम की कार्यक्षमता को लागू करने के तरीके में दिलचस्पी है।



यह कोड मूल रूप से करता है कि:

class Program
{
    static void Main()
    {
        var propName = Nameof<SampleClass>.Property(e => e.Name);

        Console.WriteLine(propName);
    }
}

public class Nameof<T>
{
    public static string Property<TProp>(Expression<Func<T, TProp>> expression)
    {
        var body = expression.Body as MemberExpression;
        if(body == null)
            throw new ArgumentException("'expression' should be a member expression");
        return body.Member.Name;
    }
}

(बेशक यह 3.5 कोड है ...)


यह सी # 6.0 में भाषा का हिस्सा है

nameof


वर्कअराउंड एक अभिव्यक्ति वृक्ष का उपयोग करना है, और उस अभिव्यक्ति पेड़ को प्रासंगिक MemberInfo खोजने के लिए अलग करना है। इस नोट में थोड़ी अधिक जानकारी और टिप्पणी है (हालांकि सदस्य को खींचने के लिए कोड नहीं है - यह कहीं और एसओ सवाल में है, मुझे विश्वास है)।

दुर्भाग्य से अभिव्यक्ति पेड़ .NET 2.0 में मौजूद नहीं हैं, वास्तव में कोई समकक्ष नहीं है।

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


स्वीकार्य समाधान अच्छा, सरल और सुरुचिपूर्ण है।

हालांकि, एक अभिव्यक्ति पेड़ का निर्माण महंगा है, और मुझे पूरे संपत्ति पथ की आवश्यकता है।

तो मैंने इसे थोड़ा बदल दिया। यह बिल्कुल सुरुचिपूर्ण नहीं है, लेकिन यह ज्यादातर मामलों में सरल है और अच्छी तरह से काम करता है:

public static string Property<TProp>(Expression<Func<T, TProp>> expression)
{
    var s = expression.Body.ToString();
    var p = s.Remove(0, s.IndexOf('.') + 1);
    return p;
}

उदाहरण:

? Nameof<DataGridViewCell>.Property(c => c.Style.BackColor.A);
"Style.BackColor.A"




.net-2.0