Özelliğin adını dize olarak alma

(Kabul ettiğim yanıtı kullanarak oluşturduğum aşağıdaki çözüme bakın)

Yansıma içeren bazı kodların sürdürülebilirliğini artırmak için çalışıyorum. Uygulama, yayınlanan uzak arabiriminde bulunmayan uygulama bölümlerine erişmek için Execute adlı bir yöntemi (diğer şeylerin yanı sıra) ortaya çıkaran bir .NET Remoting arabirimine sahiptir.

Uygulamanın Execute aracılığıyla erişilebilir olması gereken özellikleri (bu örnekte statik olan) nasıl belirlediği aşağıda açıklanmıştır:

RemoteMgr.ExposeProperty("SomeSecret", typeof(SomeClass), "SomeProperty");

Böylece uzaktaki bir kullanıcı arayabilir:

string response = remoteObject.Execute("SomeSecret");

ve uygulama SomeClass.SomeProperty'yi bulmak ve değerini bir dize olarak döndürmek için yansımayı kullanır.

Ne yazık ki, birisi SomeProperty olarak yeniden adlandırır ve ExposeProperty () öğesinin 3. parm değerini değiştirmeyi unutursa, bu mekanizmayı bozar.

Ben eşdeğer gerekir:

SomeClass.SomeProperty.GetTheNameOfThisPropertyAsAString()

ExposeProperty'de 3. parm olarak kullanmak için yeniden düzenleme araçları yeniden adlandırmalarla ilgilenir.

Bunu yapmanın bir yolu var mı? Şimdiden teşekkürler.

Tamam, oluşturduğum şey (seçtiğim cevaba ve referans aldığı soruya dayanarak):

// <summary>
// Get the name of a static or instance property from a property access lambda.
// </summary>
// <typeparam name="T">Type of the property</typeparam>
// <param name="propertyLambda">lambda expression of the form: '() => Class.Property' or '() => object.Property'</param>
// <returns>The name of the property</returns>
public string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
{
    var me = propertyLambda.Body as MemberExpression;

    if (me == null)
    {
        throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
    }

    return me.Member.Name;
 }

Kullanımı:

// Static Property
string name = GetPropertyName(() => SomeClass.SomeProperty);

// Instance Property
string name = GetPropertyName(() => someObject.SomeProperty);

Şimdi bu harika özellik ile, ExposeProperty yöntemini basitleştirmenin zamanı geldi. Kapı tokmağını parlatmak tehlikeli bir iştir ...

Herkese teşekkürler.

Buradan GetMemberInfo'yu kullanarak: lambda ifadesinden Özellik adını almak gibi bir şey yapabilirsiniz:

RemoteMgr.ExposeProperty(() => SomeClass.SomeProperty)

public class SomeClass
{
    public static string SomeProperty
    {
        get { return "Foo"; }
    }
}

public class RemoteMgr
{
    public static void ExposeProperty<T>(Expression<Func<T>> property)
    {
        var expression = GetMemberInfo(property);
        string path = string.Concat(expression.Member.DeclaringType.FullName,
            ".", expression.Member.Name);
        // Do ExposeProperty work here...
    }
}

public class Program
{
    public static void Main()
    {
        RemoteMgr.ExposeProperty("SomeSecret", () => SomeClass.SomeProperty);
    }
}

C # 6.0 ile, bu artık yapabileceğiniz gibi bir sorun değil:

nameof(SomeProperty)

Bu ifade derleme zamanında şu şekilde çözülür: "SomeProperty" .

MSDN ad belgesi .

Lambda ifadesinden ayıklamak için iyi bilinen bir kesmek var (bu, MVVM temelindeki Josh Smith tarafından PropertyObserver sınıfından):

    private static string GetPropertyName<TPropertySource>
        (Expression<Func<TPropertySource, object>> expression)
    {
        var lambda = expression as LambdaExpression;
        MemberExpression memberExpression;
        if (lambda.Body is UnaryExpression)
        {
            var unaryExpression = lambda.Body as UnaryExpression;
            memberExpression = unaryExpression.Operand as MemberExpression;
        }
        else
        {
            memberExpression = lambda.Body as MemberExpression;
        }

        Debug.Assert(memberExpression != null, 
           "Please provide a lambda expression like 'n => n.PropertyName'");

        if (memberExpression != null)
        {
            var propertyInfo = memberExpression.Member as PropertyInfo;

            return propertyInfo.Name;
        }

        return null;
    }

Maalesef, bunun bir bağlamı eksikti. Bu, TPropertySourceözelliği içeren sınıfın bulunduğu daha büyük bir sınıfın parçasıydı . Sınıftan ayıklamak için işlevi TPropertySource içinde genel yapabilirsiniz. MVVM Foundation'dan tam koda bir göz atmanızı öneririm .

Tamam, oluşturduğum şey (seçtiğim cevaba ve referans aldığı soruya dayanarak):

// <summary>
// Get the name of a static or instance property from a property access lambda.
// </summary>
// <typeparam name="T">Type of the property</typeparam>
// <param name="propertyLambda">lambda expression of the form: '() => Class.Property' or '() => object.Property'</param>
// <returns>The name of the property</returns>

public string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
{
    var me = propertyLambda.Body as MemberExpression;

    if (me == null)
    {
        throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
    }

    return me.Member.Name;
 }

Kullanımı:

// Static Property
string name = GetPropertyName(() => SomeClass.SomeProperty);

// Instance Property
string name = GetPropertyName(() => someObject.SomeProperty);

PropertyInfo sınıf doğru anlamak eğer, bunu başarmak yardımcı olmalıdır.

1. Type.GetProperties () yöntemi

   PropertyInfo[] propInfos = typeof(ReflectedType).GetProperties();
   propInfos.ToList().ForEach(p => 
       Console.WriteLine(string.Format("Property name: {0}", p.Name));

Senin ihtiyacın olan şey bu mu?

Özelliklerin gerçek adlarını elde etmek için Yansıma özelliğini kullanabilirsiniz.

http://www.csharp-examples.net/reflection-property-names/

Bir özelliğe "Dize Adı" atamanın bir yoluna ihtiyacınız varsa, dize adını almak için neden üzerinde düşünebileceğiniz bir özellik yazmıyorsunuz?

[StringName("MyStringName")]
private string MyProperty
{
    get { ... }
}

Çözümünüzü birden fazla mülk üzerinde zincir oluşturacak şekilde değiştirdim:

public static string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
{
    MemberExpression me = propertyLambda.Body as MemberExpression;
    if (me == null)
    {
        throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
    }

    string result = string.Empty;
    do
    {
        result = me.Member.Name + "." + result;
        me = me.Expression as MemberExpression;
    } while (me != null);

    result = result.Remove(result.Length - 1); // remove the trailing "."
    return result;
}

Kullanımı:

string name = GetPropertyName(() => someObject.SomeProperty.SomeOtherProperty);
// returns "SomeProperty.SomeOtherProperty"

Zaten soruda yer alan cevaba ve bu makaleye dayanarak: https://handcraftsman.wordpress.com/2008/11/11/how-to-get-c-property-names-without-magic-strings/ I bu soruna çözümümü sunuyorum:

public static class PropertyNameHelper
{
    /// <summary>
    /// A static method to get the Propertyname String of a Property
    /// It eliminates the need for "Magic Strings" and assures type safety when renaming properties.
    /// See: http://stackoverflow.com/questions/2820660/get-name-of-property-as-a-string
    /// </summary>
    /// <example>
    /// // Static Property
    /// string name = PropertyNameHelper.GetPropertyName(() => SomeClass.SomeProperty);
    /// // Instance Property
    /// string name = PropertyNameHelper.GetPropertyName(() => someObject.SomeProperty);
    /// </example>
    /// <typeparam name="T"></typeparam>
    /// <param name="propertyLambda"></param>
    /// <returns></returns>
    public static string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
    {
        var me = propertyLambda.Body as MemberExpression;

        if (me == null)
        {
            throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
        }

        return me.Member.Name;
    }
    /// <summary>
    /// Another way to get Instance Property names as strings.
    /// With this method you don't need to create a instance first.
    /// See the example.
    /// See: https://handcraftsman.wordpress.com/2008/11/11/how-to-get-c-property-names-without-magic-strings/
    /// </summary>
    /// <example>
    /// string name = PropertyNameHelper((Firma f) => f.Firmenumsatz_Waehrung);
    /// </example>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TReturn"></typeparam>
    /// <param name="expression"></param>
    /// <returns></returns>
    public static string GetPropertyName<T, TReturn>(Expression<Func<T, TReturn>> expression)
    {
        MemberExpression body = (MemberExpression)expression.Body;
        return body.Member.Name;
    }
}

Örnek ve statik özelliklerin kullanımını da gösteren bir Test:

[TestClass]
public class PropertyNameHelperTest
{
    private class TestClass
    {
        public static string StaticString { get; set; }
        public string InstanceString { get; set; }
    }

    [TestMethod]
    public void TestGetPropertyName()
    {
        Assert.AreEqual("StaticString", PropertyNameHelper.GetPropertyName(() => TestClass.StaticString));

        Assert.AreEqual("InstanceString", PropertyNameHelper.GetPropertyName((TestClass t) => t.InstanceString));
    }
}

Eski soru, ancak bu sorunun başka bir yanıtı CallerMemberNameAttribute kullanan bir yardımcı sınıfta statik bir işlev oluşturmaktır.

public static string GetPropertyName([CallerMemberName] String propertyName = null) {
  return propertyName;
}

Ve sonra şöyle kullanın:

public string MyProperty {
  get { Console.WriteLine("{0} was called", GetPropertyName()); return _myProperty; }
}

Geçerli işlevin adını almak için StackTrace sınıfını kullanabilirsiniz (veya kodu bir işleve koyarsanız, bir düzey aşağı inip arama işlevini alabilirsiniz).

Bkz. Http://msdn.microsoft.com/en-us/library/system.diagnostics.stacktrace(VS.71).aspx

Ben büyük bir etki için bu cevabı kullanıyorum: bir ifade olarak özelliği alın bir İfade <Func <TModel, TProperty >>

Bu soruyu bir süre önce yanıtladığımı fark ettim. Diğer cevabımın tek avantajı, statik özellikler için çalışması. Bu cevaptaki sözdizimini çok daha yararlı buluyorum çünkü yansıtmak istediğiniz türde bir değişken oluşturmak zorunda değilsiniz.

Özel kullanım durumum için önerilen çözümleri kullanmakta zorlandım, ancak sonunda anladım. Özel durumumun yeni bir soruya layık olduğunu düşünmüyorum, bu yüzden çözümümü buraya referans olarak gönderiyorum. (Bu soru ile çok yakından ilgilidir ve benimkine benzer bir vakası olan herkes için bir çözüm sağlar).

Ben sona erdi kodu şöyle görünüyor:

public class HideableControl<T>: Control where T: class
{
    private string _propertyName;
    private PropertyInfo _propertyInfo;

    public string PropertyName
    {
        get { return _propertyName; }
        set
        {
            _propertyName = value;
            _propertyInfo = typeof(T).GetProperty(value);
        }
    }

    protected override bool GetIsVisible(IRenderContext context)
    {
        if (_propertyInfo == null)
            return false;

        var model = context.Get<T>();

        if (model == null)
            return false;

        return (bool)_propertyInfo.GetValue(model, null);
    }

    protected void SetIsVisibleProperty(Expression<Func<T, bool>> propertyLambda)
    {
        var expression = propertyLambda.Body as MemberExpression;
        if (expression == null)
            throw new ArgumentException("You must pass a lambda of the form: 'vm => vm.Property'");

        PropertyName = expression.Member.Name;
    }
}

public interface ICompanyViewModel
{
    string CompanyName { get; }
    bool IsVisible { get; }
}

public class CompanyControl: HideableControl<ICompanyViewModel>
{
    public CompanyControl()
    {
        SetIsVisibleProperty(vm => vm.IsVisible);
    }
}

Benim için önemli olan CompanyControl, derleyicinin derste sadece bir boolean özelliği seçmeme izin vermesidir.ICompanyViewModel bu da diğer geliştiricilerin doğru yapmasını kolaylaştırıyor.

Benim çözüm ve kabul edilen cevap arasındaki ana fark benim sınıf genel ve sadece boolean genel tür özellikleri eşleştirmek istiyorum.

Ben bunu nasıl uyguladım, arkasındaki nedeni üyeden adını almak istediğiniz sınıf statik değilse o zaman bunun bir instanse oluşturmak ve sonra üyenin adını almak gerekir. bu yüzden jenerik burada yardıma geliyor

public static string GetName<TClass>(Expression<Func<TClass, object>> exp)
{
    MemberExpression body = exp.Body as MemberExpression;

    if (body == null)
    {
         UnaryExpression ubody = (UnaryExpression)exp.Body;
         body = ubody.Operand as MemberExpression;
    }

     return body.Member.Name;
}

kullanım böyle

var label = ClassExtension.GetName<SomeClass>(x => x.Label); //x is refering to 'SomeClass'