डब्ल्यूपीएफ: यदि यूआई तत्व दिखाई नहीं दे रहा है तो बाध्यकारी बंद करें

Question

यदि तत्व वर्तमान में दिखाई नहीं दे रहा है तो क्या मैं ui तत्व के बाध्यकारी में देरी कर सकता हूं। कभी-कभी मेरे पास एक ऐसा फॉर्म होता है जिसमें कुछ छिपे/न्यूनतम तत्व होते हैं, यदि वे स्क्रीन पर नहीं हैं तो मैं उन्हें अपडेट नहीं करना चाहूंगा। मुझे संदेह है कि जवाब नहीं है, लेकिन यह पूछने में कभी दर्द नहीं होता है?

Answer 1

ऐसा करने के लिए कोई रास्ता नहीं बनाया गया है - लेकिन आप इसे स्वयं लिख सकते हैं।

चाल अपनी खुद की मार्कअप विस्तार मूल बंधन का उपयोग करता है, लेकिन (उदाहरण के लिए इसके चारों ओर नए व्यवहार कहते हैं, स्पष्ट करने के लिए UpdateSourceTrigger निर्धारित करके कि में बाध्यकारी रैप करने के लिए जब आप काम करने के लिए बाध्यकारी नहीं करना चाहती है।

यहाँ एक उदाहरण (है कि बंधन का आंकड़ा अंतरण विलंब) है:

http://www.paulstovell.com/wpf-delaybinding

अब, वहाँ अदृश्य नियंत्रण के लिए बाइंडिंग अक्षम करने, विशेष रूप से दिखा और नियंत्रण छुपा चारों ओर के साथ संभव बढ़त की स्थिति के एक बहुत हैं, इसलिए मैं नहीं होगा इसके लिए एक सामान्य विस्तार लिखें - लेकिन हो सकता है अपने विशिष्ट आवेदन में रहें यह उपयोगी हो सकता है।

Answer 2

उत्तर इसलिए नहीं है क्योंकि बाध्यकारी तत्व को फिर से दिखाई देने का कारण हो सकता है। तो यदि बाध्यकारी छिपे हुए नियंत्रणों पर काम नहीं करता है तो यह बाध्यकारी को इसे फिर से दिखने की अनुमति नहीं देगा।

Answer 3

एक वर्कअराउंड के लिए ऑब्जेक्ट की दृश्यता के लिए बाध्यकारी है, जब ऑब्जेक्ट दृश्यमान होता है, तो संपत्ति उसके पीछे तत्व के निर्माण को ट्रिगर करती है जिसमें ContentPresenter के माध्यम से बाध्यकारी होता है।

Answer 4

मुझे पता है कि यह एक पुराना सवाल है, लेकिन जैसा कि मैं एक लागू वर्ग या कुछ खोजने में विफल रहा, मैंने इसे @Nir उत्तर के बाद किया।

यह एक मार्कअप एक्सटेंशन है कि केवल वास्तव में बाँध जब वस्तु IsVisible संपत्ति पहली बार के लिए सच हो जाता है करने के लिए सामान्य बाध्यकारी लपेटता है:

using System; 
using System.ComponentModel; 
using System.Globalization; 
using System.Windows; 
using System.Windows.Data; 
using System.Windows.Markup; 

namespace MakupExtensions { 
    [MarkupExtensionReturnType(typeof(object))] 
    public class LazyBindingExtension : MarkupExtension { 
     public LazyBindingExtension() { 
     } 
     public LazyBindingExtension(PropertyPath path) : this() { 
      Path = path; 
     } 

     public IValueConverter Converter { 
      get; 
      set; 
     } 
     [TypeConverter(typeof(CultureInfoIetfLanguageTagConverter))] 
     public CultureInfo ConverterCulture { 
      get; 
      set; 
     } 
     public object ConverterParamter { 
      get; 
      set; 
     } 
     public string ElementName { 
      get; 
      set; 
     } 
     [ConstructorArgument("path")] 
     public PropertyPath Path { 
      get; 
      set; 
     } 
     public RelativeSource RelativeSource { 
      get; 
      set; 
     } 
     public object Source { 
      get; 
      set; 
     } 
     public UpdateSourceTrigger UpdateSourceTrigger { 
      get; 
      set; 
     } 
     public bool ValidatesOnDataErrors { 
      get; 
      set; 
     } 
     public bool ValidatesOnExceptions { 
      get; 
      set; 
     } 
     public bool ValidatesOnNotifyDataErrors { 
      get; 
      set; 
     } 

     private Binding binding; 
     private DependencyObject bindingTarget; 
     private DependencyProperty bindingTargetProperty; 

     public override object ProvideValue(IServiceProvider serviceProvider) { 
      var valueProvider = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget; 
      if (valueProvider != null) { 
       bindingTarget = valueProvider.TargetObject as DependencyObject; 
       bindingTargetProperty = valueProvider.TargetProperty as DependencyProperty; 
       if (bindingTargetProperty == null || bindingTarget == null) { 
        throw new NotSupportedException($"The property '{valueProvider.TargetProperty}' on target '{valueProvider.TargetObject}' is not valid for a LazyBinding. The LazyBinding target must be a DependencyObject, and the target property must be a DependencyProperty."); 
       } 
       binding = new Binding { 
        Path = Path, 
        Converter = Converter, 
        ConverterCulture = ConverterCulture, 
        ConverterParameter = ConverterParamter 
       }; 
       if (ElementName != null) { 
        binding.ElementName = ElementName; 
       } 
       if (RelativeSource != null) { 
        binding.RelativeSource = RelativeSource; 
       } 
       if (Source != null) { 
        binding.Source = Source; 
       } 
       binding.UpdateSourceTrigger = UpdateSourceTrigger; 
       binding.ValidatesOnDataErrors = ValidatesOnDataErrors; 
       binding.ValidatesOnExceptions = ValidatesOnExceptions; 
       binding.ValidatesOnNotifyDataErrors = ValidatesOnNotifyDataErrors; 
       return SetBinding(); 
      } 
      return null; 
     } 
     public object SetBinding() { 
      var uiElement = bindingTarget as UIElement; 
      if (uiElement != null && !uiElement.IsVisible) { 
       uiElement.IsVisibleChanged += UiElement_IsVisibleChanged; 
      } 
      else { 
       ConsolidateBinding(); 
      } 
      return bindingTarget.GetValue(bindingTargetProperty); 
     } 
     private void ConsolidateBinding() => BindingOperations.SetBinding(bindingTarget, bindingTargetProperty, binding); 
     private void UiElement_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) { 
      var uiElement = sender as UIElement; 
      if (uiElement != null && uiElement.IsVisible) { 
       uiElement.IsVisibleChanged -= UiElement_IsVisibleChanged; 
       ConsolidateBinding(); 
      } 
     } 
    } 
} 

का उपयोग करें:

<ItemsControl ItemsSource="{mx:LazyBinding Documents}"/> 

इस उदाहरण में, यह केवल बाध्य होगा जब आइटम्स कंट्रोल IsVisible पहली बार सच हो जाता है।

IsVisible फिर से झूठा हो जाता है, लेकिन मुझे लगता है कि कोई इसे आवश्यकतानुसार बदल सकता है।

Answer 5

बेहतर मार्कअप एक्सटेंशन जो दिखाई देने पर ऑटो बाइंड/अनबिंड डेटा मॉडल के लिए सामान्य बाध्यकारी लपेटता है।
पिछले संस्करण here देखें।

using System; 
using System.ComponentModel; 
using System.Globalization; 
using System.Windows; 
using System.Windows.Data; 
using System.Windows.Markup; 

namespace UtilsWPF 
{ 
    [MarkupExtensionReturnType(typeof(object))] 
    public class LazyBindingExtension : MarkupExtension 
    { 
     public LazyBindingExtension() 
     { } 

     public LazyBindingExtension(PropertyPath path) : this() 
     { 
      Path = path; 
     } 

     #region Properties 

     public IValueConverter Converter { get; set; } 
     [TypeConverter(typeof(CultureInfoIetfLanguageTagConverter))] 
     public CultureInfo ConverterCulture { get; set; } 
     public object ConverterParamter { get; set; } 
     public string ElementName { get; set; } 
     [ConstructorArgument("path")] 
     public PropertyPath Path { get; set; } 
     public RelativeSource RelativeSource { get; set; } 
     public object Source { get; set; } 
     public UpdateSourceTrigger UpdateSourceTrigger { get; set; } 
     public bool ValidatesOnDataErrors { get; set; } 
     public bool ValidatesOnExceptions { get; set; } 
     public bool ValidatesOnNotifyDataErrors { get; set; } 

     private Binding binding; 
     private UIElement bindingTarget; 
     private DependencyProperty bindingTargetProperty; 

     #endregion 

     #region Init 

     public override object ProvideValue(IServiceProvider serviceProvider) 
     { 
      var valueProvider = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget; 
      if (valueProvider != null) 
      { 
       bindingTarget = valueProvider.TargetObject as UIElement; 

       if (bindingTarget == null) 
       { 
        throw new NotSupportedException($"Target '{valueProvider.TargetObject}' is not valid for a LazyBinding. The LazyBinding target must be a UIElement."); 
       } 

       bindingTargetProperty = valueProvider.TargetProperty as DependencyProperty; 

       if (bindingTargetProperty == null) 
       { 
        throw new NotSupportedException($"The property '{valueProvider.TargetProperty}' is not valid for a LazyBinding. The LazyBinding target property must be a DependencyProperty."); 
       } 

       binding = new Binding 
       { 
        Path = Path, 
        Converter = Converter, 
        ConverterCulture = ConverterCulture, 
        ConverterParameter = ConverterParamter 
       }; 

       if (ElementName != null) 
       { 
        binding.ElementName = ElementName; 
       } 

       if (RelativeSource != null) 
       { 
        binding.RelativeSource = RelativeSource; 
       } 

       if (Source != null) 
       { 
        binding.Source = Source; 
       } 

       binding.UpdateSourceTrigger = UpdateSourceTrigger; 
       binding.ValidatesOnDataErrors = ValidatesOnDataErrors; 
       binding.ValidatesOnExceptions = ValidatesOnExceptions; 
       binding.ValidatesOnNotifyDataErrors = ValidatesOnNotifyDataErrors; 

       return SetBinding(); 
      } 

      return null; 
     } 

     public object SetBinding() 
     { 
      bindingTarget.IsVisibleChanged += UiElement_IsVisibleChanged; 

      updateBinding(); 

      return bindingTarget.GetValue(bindingTargetProperty); 
     } 

     #endregion 

     #region Event Handlers 

     private void UiElement_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) 
     { 
      updateBinding(); 
     } 

     #endregion 

     #region Update Binding 

     private void updateBinding() 
     { 
      if (bindingTarget.IsVisible) 
      { 
       ConsolidateBinding(); 
      } 
      else 
      { 
       ClearBinding(); 
      } 
     } 

     private bool _isBind; 

     private void ConsolidateBinding() 
     { 
      if (_isBind) 
      { 
       return; 
      } 

      _isBind = true; 

      BindingOperations.SetBinding(bindingTarget, bindingTargetProperty, binding); 
     } 

     private void ClearBinding() 
     { 
      if (!_isBind) 
      { 
       return; 
      } 

      BindingOperations.ClearBinding(bindingTarget, bindingTargetProperty); 

      _isBind = false; 
     } 

     #endregion 
    } 
} 

का उपयोग करें:

<ItemsControl ItemsSource="{utils:LazyBinding Documents}"/>