Benim nesne özelliği için denetimi bağlamak istiyorum, bir dize olarak özellik adını vermek zorunda. Bu çok iyi çünkü

1. Eğer bu özellik kaldırıldı ya. yeniden, bir derleyici anlamıyorum uyarı.
2. Bir yeniden adlandırma özelliği ise yeniden düzenleme aracı ile, olası veri bağlayıcı olmayacaktır güncellendi.
3. Bir hata kadar anlamadım çalışma zamanı özelliği yazarsanız yanlış, örneğin bir tam sayı bağlayıcıdır bir tarih seçici.

Bu turda alır, ama yine de veri bağlayıcı kullanım kolaylığı var tasarım desen var mı?

(Bu, Asp.net ve WPF ve büyük olasılıkla Diğer sistemler çok) WinForm bir sorundur

Şimdi "workarounds for nameof() operator in C#: typesafe databinding" bu da çözüm için iyi bir başlangıç noktası vardır. bulduk

Eğer derleme sonra yazılan bir işlemci kullanmak isteyen varsa kodu notifypropertyweaver bakmaya değer.

Herkes bağlamaları XML ziyade bittiğinde WPF için iyi bir çözüm biliyor C#?

Beni almak için Oliver için teşekkürler ben şimdi yeniden düzenleme destekler ve türü güvenli bir çözüm var başladı. O da benimle ilgili özellikleri yeniden ile baş edebiliyor çok INotifyPropertyChanged uygulamak.

Kullanımı gibi görünüyor

checkBoxCanEdit.Bind(c => c.Checked, person, p => p.UserCanEdit);
textBoxName.BindEnabled(person, p => p.UserCanEdit);
checkBoxEmployed.BindEnabled(person, p => p.UserCanEdit);
trackBarAge.BindEnabled(person, p => p.UserCanEdit);

textBoxName.Bind(c => c.Text, person, d => d.Name);
checkBoxEmployed.Bind(c => c.Checked, person, d => d.Employed);
trackBarAge.Bind(c => c.Value, person, d => d.Age);

labelName.BindLabelText(person, p => p.Name);
labelEmployed.BindLabelText(person, p => p.Employed);
labelAge.BindLabelText(person, p => p.Age);

Kişi sınıfı nasıl INotifyPropertyChanged türü güvenli bir şekilde uygulanan (veya INotifyPropertyChanged uygulanması daha güzel başka bir yol, ActiveSharp - Automatic INotifyPropertyChanged see this answer de iyi görünüyor ) gösterir:

public class Person : INotifyPropertyChanged
{
   private bool _employed;
   public bool Employed
   {
      get { return _employed; }
      set
      {
         _employed = value;
         OnPropertyChanged(() => c.Employed);
      }
   }

   // etc

   private void OnPropertyChanged(Expression<Func<object>> property)
   {
      if (PropertyChanged != null)
      {
         PropertyChanged(this, 
             new PropertyChangedEventArgs(BindingHelper.Name(property)));
      }
   }

   public event PropertyChangedEventHandler PropertyChanged;
}

Bu Win Yardımcısı sınıf öğrencisi bütün işimi görür içinde et var:

namespace TypeSafeBinding
{
    public static class BindingHelper
    {
        private static string GetMemberName(Expression expression)
        {
            switch (expression.NodeType)
            {
                case ExpressionType.MemberAccess:
                    var memberExpression = (MemberExpression) expression;
                    var supername = GetMemberName(memberExpression.Expression);
                    if (String.IsNullOrEmpty(supername)) return memberExpression.Member.Name;
                    return String.Concat(supername, '.', memberExpression.Member.Name);
                case ExpressionType.Call:
                    var callExpression = (MethodCallExpression) expression;
                    return callExpression.Method.Name;
                case ExpressionType.Convert:
                    var unaryExpression = (UnaryExpression) expression;
                    return GetMemberName(unaryExpression.Operand);
                case ExpressionType.Parameter:
                case ExpressionType.Constant: //Change
                    return String.Empty;
                default:
                    throw new ArgumentException("The expression is not a member access or method call expression");
            }
        }

        public static string Name<T, T2>(Expression<Func<T, T2>> expression)
        {
            return GetMemberName(expression.Body);
        }

        //NEW
        public static string Name<T>(Expression<Func<T>> expression)
        {
           return GetMemberName(expression.Body);
        }

        public static void Bind<TC, TD, TP>(this TC control, Expression<Func<TC, TP>> controlProperty, TD dataSource, Expression<Func<TD, TP>> dataMember) where TC : Control
        {
            control.DataBindings.Add(Name(controlProperty), dataSource, Name(dataMember));
        }

        public static void BindLabelText<T>(this Label control, T dataObject, Expression<Func<T, object>> dataMember)
        {
            // as this is way one any type of property is ok
            control.DataBindings.Add("Text", dataObject, Name(dataMember));
        }

        public static void BindEnabled<T>(this Control control, T dataObject, Expression<Func<T, bool>> dataMember)
        {       
           control.Bind(c => c.Enabled, dataObject, dataMember);
        }
    }
}

Bu C# 3.5 ve mümkün olduğunu gösterir yeni şeyler kullanır. hygienic macros lisp programcısı bizi ikinci sınıf vatandaş demeyi olabilir) bizde olsaydı şimdi