PropertyChangedCallback封装(PropertyChangedCallback encapsulation)

 这已经困扰了我一段时间，所以我问一个同事他是否能够理解它，现在我在这里;） 
 
 为什么你可以在依赖属性的PropertyChangedCallback中访问持有类的私有成员？ 
 让我通过这个例子进一步解释我的意思： 
 
 /// <summary>
    /// Interaction logic for ZeControl.xaml
    /// </summary>
    public partial class ZeControl : UserControl
    {
        public ZeControl()
        {
            InitializeComponent();
        }

        private bool m_Trololo; //Please note that this field is PRIVATE!

        #region Text
        public string Text
        {
            get { return (string)GetValue(TextProperty); }
            set { SetValue(TextProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Text.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty TextProperty =
            DependencyProperty.Register("Text", typeof(string), typeof(ZeControl), new UIPropertyMetadata(
                new PropertyChangedCallback((dpo, dpce) =>
                    {
                        ((ZeControl)dpo).m_Trololo = true; //How the hell?
                        //this.m_Trololo <-- would not compile, the callback is static.
                    })));
        #endregion
    }
 
 这不是打破封装吗？ 它甚至如何编译？ 
 
 我问这个主要是因为我在我的WPF应用程序中使用它：它允许我保持变量私有，同时仍然在回调中访问它。 
 但由于它确实感觉不对，我不希望这在WPF vNext中“修复”，使我的应用程序不兼容。 
 
 最好的祝福， 
 
 BAB。 

This has been bugging me for a while, so I asked a coworker if he could make any sense of it, and now I'm here ;)
 
How come you can access private members of the holding class in the PropertyChangedCallback of a dependency property?
 Let me explain further what i mean through this example:
 
 /// <summary>
    /// Interaction logic for ZeControl.xaml
    /// </summary>
    public partial class ZeControl : UserControl
    {
        public ZeControl()
        {
            InitializeComponent();
        }

        private bool m_Trololo; //Please note that this field is PRIVATE!

        #region Text
        public string Text
        {
            get { return (string)GetValue(TextProperty); }
            set { SetValue(TextProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Text.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty TextProperty =
            DependencyProperty.Register("Text", typeof(string), typeof(ZeControl), new UIPropertyMetadata(
                new PropertyChangedCallback((dpo, dpce) =>
                    {
                        ((ZeControl)dpo).m_Trololo = true; //How the hell?
                        //this.m_Trololo <-- would not compile, the callback is static.
                    })));
        #endregion
    }
 
Isn't this breaking encapsulation? how does it even compiles?
 
I'm asking this mainly because I make use of it in my WPF applications: it allows me to keep a variable private while still accessing it in callbacks.
 But since it really doesn't feel right at all, I wouldn't want this to be "fixed" in WPF vNext, making my apps incompatible.
 
Best regards,
 
bab.

原文：https://stackoverflow.com/questions/9228248