C# DependencyObject.SetCurrentValue方法代码示例

        protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
        {
            if (element != item)
                element.SetCurrentValue(DataContextProperty, item); //dont want to set the datacontext to itself. taken from MetroTabControl.cs

            base.PrepareContainerForItemOverride(element, item);
        }

 private static void TintPropertyChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
 {
     var value = obj?.GetValue(TintProperty);
     if (!(value is Color)) return;
     var tint = (Color) value;
     obj.SetCurrentValue(LightTintProperty, tint.Lighten(0.1f));
     obj.SetCurrentValue(DarkTintProperty, tint.Darken(0.1f));
 }

        protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
        {
            if (!Equals(element, item))
                element.SetCurrentValue(DataContextProperty, item); //dont want to set the datacontext to itself.

            base.PrepareContainerForItemOverride(element, item);
        }

 internal static void InternalSetIsValid(DependencyObject obj, bool value)
 {
     if (GetIsValid(obj) != value)
     {
         // Only change the value when it is different; otherwise unnecessary binding updates are raised.
         obj.SetCurrentValue(IsValidProperty, value);
     }
 }

        private static void Clone(DependencyObject from, DependencyObject to)
        {
            var localValueEnumerator = from.GetLocalValueEnumerator();
            while (localValueEnumerator.MoveNext())
            {
                if (localValueEnumerator.Current.Property.ReadOnly ||
                    localValueEnumerator.Current.Value is FrameworkElement) continue;

                if (!(localValueEnumerator.Current.Value is BindingExpressionBase))
                    to.SetCurrentValue(localValueEnumerator.Current.Property, localValueEnumerator.Current.Value);
            }
        }

		static void EnsureHidden(DependencyObject d)
		{
			if (Visibility.Visible.Equals(d.GetValue(UIElement.VisibilityProperty))) {
				d.SetCurrentValue(UIElement.VisibilityProperty, Visibility.Hidden);
			}
		}

        private static void OnCellItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (Equals(d.GetValue(IsUpdatingProperty), BooleanBoxes.True))
            {
                return;
            }

            d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.True);
            try
            {
                var dataGrid = (DataGrid)d;
                dataGrid.UnselectAllCells();
                if (e.NewValue == null)
                {
                    dataGrid.SetIndex(null);
                    return;
                }

                for (var r = 0; r < dataGrid.Items.Count; r++)
                {
                    for (var c = 0; c < dataGrid.Columns.Count; c++)
                    {
                        var column = dataGrid.Columns[c];
                        var cellItem = GetCellItem(column, dataGrid.Items[r]);
                        if (Equals(cellItem, e.NewValue))
                        {
                            var index = new RowColumnIndex(r, c);
                            dataGrid.SetIndex(index);
                            var cell = dataGrid.GetCell(index);
                            cell.SetCurrentValue(DataGridCell.IsSelectedProperty, true);
                            return;
                        }
                    }
                }

                dataGrid.SetIndex(null);
            }
            finally
            {
                d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.False);
            }
        }

 /// <summary>
 /// Sets the IsThreeState property.  This dependency property 
 /// indicates whether the control supports two or three states. 
 /// IsChecked can be set to null as a third state when IsThreeState is true.
 /// </summary>
 public static void SetIsThreeState(DependencyObject d, bool value)
 {
     d.SetCurrentValue(IsThreeStateProperty, value);
 }

        private static void OnIndexChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (Equals(d.GetValue(IsUpdatingProperty), BooleanBoxes.True))
            {
                return;
            }

            d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.True);
            try
            {
                var dataGrid = (DataGrid)d;
                dataGrid.UnselectAllCells();
                var rowColumnIndex = (RowColumnIndex?)e.NewValue;
                if (rowColumnIndex == null)
                {
                    return;
                }

                var cell = dataGrid.GetCell(rowColumnIndex.Value);
                cell?.SetCurrentValue(DataGridCell.IsSelectedProperty, true);

                UpdateSelectedCellItemFromView(dataGrid);
            }
            finally
            {
                d.SetCurrentValue(IsUpdatingProperty, BooleanBoxes.False);
            }
        }

 /// <summary>
 /// Sets the IsVirtualToggleButton property.  This dependency property 
 /// indicates whether the object to which the property is attached is treated as a VirtualToggleButton.  
 /// If true, the object will respond to keyboard and mouse input the same way a ToggleButton would.
 /// </summary>
 public static void SetIsVirtualToggleButton(DependencyObject d, bool value)
 {
     d.SetCurrentValue(IsVirtualToggleButtonProperty, value);
 }

 /// <summary>
 /// Sets the IsChecked property.  This dependency property 
 /// indicates whether the toggle button is checked.
 /// </summary>
 public static void SetIsChecked(DependencyObject d, bool? value)
 {
     d.SetCurrentValue(IsCheckedProperty, value);
 }

		public static void SetTargetVisual(DependencyObject obj, UIElement value)
		{
            obj.SetCurrentValue(TargetVisualProperty, value);
		}

		public static void SetDimmerOpacity(DependencyObject obj, double value)
		{
            obj.SetCurrentValue(DimmerOpacityProperty, value);
		}

		public static void SetDimBackground(DependencyObject obj, bool value)
		{
            obj.SetCurrentValue(DimBackgroundProperty, value);
		}

 private static void OnSourceProxyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     d.SetCurrentValue(TargetProxyProperty, e.NewValue);
 }