C# Xaml.DependencyProperty類代碼示例

 public StarRateControl()
 {
     this.InitializeComponent();
     
     valueProperty = DependencyProperty.Register("Value", typeof(int), typeof(StarRateControl), new PropertyMetadata(3));
     
 }

        void SetValueDp(DependencyProperty property, object value, [System.Runtime.CompilerServices.CallerMemberName] String p = null)
        {
            SetValue(property, value);

            if (PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(p));
        }

 static FrameworkElementAttachedProperties()
 {
     ObserveProperty = DependencyProperty.RegisterAttached("Observe", typeof(bool), typeof(FrameworkElementAttachedProperties), new PropertyMetadata(null, new PropertyChangedCallback(OnObserveChanged)));
     ObservedWidthProperty = DependencyProperty.RegisterAttached("ObservedWidth", typeof(double), typeof(FrameworkElementAttachedProperties), new PropertyMetadata(null, null));
     ObservedHeightProperty = DependencyProperty.RegisterAttached("ObservedHeight", typeof(double), typeof(FrameworkElementAttachedProperties), new PropertyMetadata(null, null));
     LoadedCommandProperty = DependencyProperty.RegisterAttached("LoadedCommand", typeof(ICommand), typeof(FrameworkElementAttachedProperties), new PropertyMetadata(null, OnLoadedCommandChanged));
 }

 private void OnHeaderPresenterContentChanged(DependencyObject sender, DependencyProperty dp)
 {
     if (headerPresenter.Content != Header)
     {
         headerPresenter.Content = Header;
     }
 }

        /// <summary>
        /// Inherited code: Requires comment.
        /// </summary>
        /// <param name="obj">Inherited code: Requires comment 1.</param>
        /// <param name="dependencyProperty">Inherited code: Requires comment 2.</param>
        /// <param name="suspend">Inherited code: Requires comment 3.</param>
        private static void SuspendHandler(this DependencyObject obj, DependencyProperty dependencyProperty, bool suspend)
        {
            if (_suspendedHandlers.ContainsKey(obj))
            {
                Dictionary<DependencyProperty, bool> suspensions = _suspendedHandlers[obj];

                if (suspend)
                {
                    Debug.Assert(!suspensions.ContainsKey(dependencyProperty), "Suspensions should not contain the property!");

                    // true = dummy value
                    suspensions[dependencyProperty] = true;
                }
                else
                {
                    Debug.Assert(suspensions.ContainsKey(dependencyProperty), "Suspensions should contain the property!");
                    suspensions.Remove(dependencyProperty);
                    if (suspensions.Count == 0)
                    {
                        _suspendedHandlers.Remove(obj);
                    }
                }
            }
            else
            {
                Debug.Assert(suspend, "suspend should be true!");
                _suspendedHandlers[obj] = new Dictionary<DependencyProperty, bool>();
                _suspendedHandlers[obj][dependencyProperty] = true;
            }
        }

        static SettingsEditor()
        {
            YScaleWidthProperty = DependencyProperty.Register("YScaleWidth", typeof(int), typeof(SettingsEditor), new PropertyMetadata(60));
            XScaleHeightProperty = DependencyProperty.Register("XScaleHeight", typeof(int), typeof(SettingsEditor), new PropertyMetadata(15));
            BorderThickness1Property = DependencyProperty.Register("BorderThickness1", typeof(int), typeof(SettingsEditor), new PropertyMetadata(1));
            BorderProperty = DependencyProperty.Register("Border", typeof(string), typeof(SettingsEditor), new PropertyMetadata("Black"));
            YScaleDockProperty = DependencyProperty.Register("YScaleDock", typeof(YScaleDock), typeof(SettingsEditor), new PropertyMetadata(YScaleDock.Right));
            ControlBackgroundProperty = DependencyProperty.Register("ControlBackground", typeof(string), typeof(SettingsEditor), new PropertyMetadata("White"));
            XScaleDockProperty = DependencyProperty.Register("XScaleDock", typeof(XScaleDock), typeof(SettingsEditor), new PropertyMetadata(XScaleDock.Bottom));
            CoordinateTypeProperty = DependencyProperty.Register("CoordinateType", typeof(CoordinateType), typeof(SettingsEditor), new PropertyMetadata(CoordinateType.Linear));
            CursorLinesProperty = DependencyProperty.Register("CursorLines", typeof(string), typeof(SettingsEditor), new PropertyMetadata("Gray"));
            CursorLinesThicknessProperty = DependencyProperty.Register("CursorLinesThickness", typeof(int), typeof(SettingsEditor), new PropertyMetadata(1));
            CursorLinesDashesProperty = DependencyProperty.Register("CursorLinesDashes", typeof(string), typeof(SettingsEditor), new PropertyMetadata(null));

            ScaleLineColorProperty = DependencyProperty.Register("ScaleLineColor", typeof(string), typeof(SettingsEditor), new PropertyMetadata("Gray"));
            ScaleLineThicknessProperty = DependencyProperty.Register("ScaleLineThickness", typeof(int), typeof(SettingsEditor), new PropertyMetadata(1));
            ScaleLineDashesProperty = DependencyProperty.Register("ScaleLineDashes", typeof(string), typeof(SettingsEditor), new PropertyMetadata(null));

            FontFamilyProperty = DependencyProperty.Register("FontFamily", typeof(string), typeof(SettingsEditor), new PropertyMetadata("Arial"));
            FontSizeProperty = DependencyProperty.Register("FontSize", typeof(int), typeof(SettingsEditor), new PropertyMetadata(10));

            widthArrayProperty = DependencyProperty.Register("widthArray", typeof(int[]), typeof(SettingsEditor), new PropertyMetadata(null));
            brushesProperty = DependencyProperty.Register("brushes", typeof(string[]), typeof(SettingsEditor), new PropertyMetadata(null));
            yScaleDocksProperty = DependencyProperty.Register("yScaleDocks", typeof(YScaleDock[]), typeof(SettingsEditor), new PropertyMetadata(null));
            xScaleDocksProperty = DependencyProperty.Register("xScaleDocks", typeof(XScaleDock[]), typeof(SettingsEditor), new PropertyMetadata(null));
            bgBrushesProperty = DependencyProperty.Register("bgBrushes", typeof(string[]), typeof(SettingsEditor), new PropertyMetadata(null));
            dockWidthArrayProperty = DependencyProperty.Register("dockWidthArray", typeof(int[]), typeof(SettingsEditor), new PropertyMetadata(null));
            coordinateTypesProperty = DependencyProperty.Register("coordinateTypes", typeof(CoordinateType[]), typeof(SettingsEditor), new PropertyMetadata(null));
            dashArrayProperty = DependencyProperty.Register("dashArray", typeof(string[]), typeof(SettingsEditor), new PropertyMetadata(null));
            fontNamesProperty = DependencyProperty.Register("fontNames", typeof(string[]), typeof(SettingsEditor), new PropertyMetadata(null));
            fontSizesProperty = DependencyProperty.Register("fontSizes", typeof(int[]), typeof(SettingsEditor), new PropertyMetadata(null));
        }

        /// <summary>
        /// Starts animating a dependency property of a framework element to a 
        /// target value.
        /// </summary>
        /// <param name="target">The element to animate.</param>
        /// <param name="animatingDependencyProperty">The dependency property to
        /// animate.</param>
        /// <param name="propertyPath">The path of the dependency property to 
        /// animate.</param>
        /// <param name="targetValue">The value to animate the dependency
        /// property to.</param>
        /// <param name="timeSpan">The duration of the animation.</param>
        /// <param name="easingFunction">The easing function to uses to
        /// transition the data points.</param>
        public static void BeginAnimation(
            this FrameworkElement target,
            DependencyProperty animatingDependencyProperty,
            string propertyPath,
            object targetValue,
            TimeSpan timeSpan,
            EasingFunctionBase easingFunction)
        {
            Storyboard storyBoard = target.Resources[GetStoryboardKey(propertyPath)] as Storyboard;

            if (storyBoard != null)
            {
                // Save current value
                object currentValue = target.GetValue(animatingDependencyProperty);
                storyBoard.Stop();
                // RestoreAsync that value so it doesn't snap back to its starting value
                target.SetValue(animatingDependencyProperty, currentValue);
                target.Resources.Remove(GetStoryboardKey(propertyPath));
            }

            storyBoard = CreateStoryboard(target, animatingDependencyProperty, propertyPath, ref targetValue, timeSpan, easingFunction);

            storyBoard.Completed += 
                (source, args) =>
                    {
                        storyBoard.Stop();
                        target.SetValue(animatingDependencyProperty, targetValue);
                        target.Resources.Remove(GetStoryboardKey(propertyPath));
                    };

            target.Resources.Add(GetStoryboardKey(propertyPath), storyBoard);
            storyBoard.Begin();
        }

        private void OnItemsSourceChanged(DependencyObject sender, DependencyProperty dp)
        {
            if (this.ItemsSource != null && ItemsSource is IGroupCollection)
            {
                groupCollection = (ItemsSource as IGroupCollection);
            }

            if (groupHeadersGrid != null)
            {
                groupHeadersGrid.Children.Clear();
            }

            groupDic.Clear();

            if (currentTopGroupHeader != null)
            {
                currentTopGroupHeader.DataContext = null;
                currentTopGroupHeader.Visibility = Visibility.Collapsed;
                if (groupHeadersGrid != null)
                {
                    groupHeadersGrid.Children.Add(currentTopGroupHeader);
                }
            }
            else
            {
                if (groupHeadersGrid != null)
                {
                    currentTopGroupHeader = CreateGroupHeader(null);
                    currentTopGroupHeader.Visibility = Visibility.Collapsed;
                    groupHeadersGrid.Children.Add(currentTopGroupHeader);
                }
            }
        }

 private void VisibilityChangedCallback(DependencyObject sender, DependencyProperty dp)
 {
     if (Visibility == Visibility.Visible)
     {
         EntryBox.Text = FilterSting;
     }
 }

 static TextBlockFontSize()
 {
     FontSizeProperty = DependencyProperty.Register("FontSize",
         typeof(int),
         typeof(TextBlockFontSize),
         new PropertyMetadata(TextBlock.FontSizeProperty, null));
 }

 private static void RefreshBinding(DependencyObject target, DependencyProperty property)
 {
     BindingExpression binding = target.ReadLocalValue(property) as BindingExpression;
     if (binding != null && binding.ParentBinding != null)
     {
         BindingOperations.SetBinding(target, property, binding.ParentBinding);
     }
 }

 /// <summary>
 /// Sets a binding from code
 /// </summary>
 /// <param name="element"></param>
 /// <param name="property"></param>
 /// <param name="source"></param>
 /// <param name="path"></param>
 /// <param name="converter"></param>
 public static void SetBinding(FrameworkElement element, DependencyProperty property, object source, string path, IValueConverter converter = null)
 {
     Binding binding = new Binding();
     binding.Source = source;
     binding.Path = new PropertyPath(path);
     binding.Converter = converter;
     element.SetBinding(property, binding);
 }

 private void SetValueDp(DependencyProperty property, object value, [CallerMemberName] string propertyName = null)
 {
     SetValue(property, value);
     if (PropertyChanged != null)
     {
         PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
     }
 }

 private void OnMinWindowWidthPropertyChanged(DependencyObject sender, DependencyProperty dp)
 {
     var window = CoreApplication.GetCurrentView()?.CoreWindow;
     if (window != null)
     {
         IsActive = window.Bounds.Width >= MinWindowWidth;
     }
 }

 void HeaderChanged(DependencyObject sender, DependencyProperty prop)
 {
     string header = (string)sender.GetValue(prop);
     //Double check to make sure that we don't needlessly realize the header presenter
     if (!string.IsNullOrEmpty(Header) && _header == null)
     {
         _header = (ContentPresenter)GetTemplateChild("HeaderPresenter"); //This will realize the element
     }
 }