नेस्टेड नियंत्रण के साथ DesignMode

Question 1

क्या किसी ने नियंत्रण विकसित करते समय DesignMode समस्या का एक उपयोगी समाधान पाया है?

मुद्दा यह है कि यदि आप घोंसला नियंत्रित करते हैं तो DesignMode केवल पहले स्तर के लिए काम करता है। दूसरा और निचला स्तर DesignMode हमेशा FALSE लौटाएगा।

मानक हैक उस प्रक्रिया के नाम को देखने के लिए किया गया है जो चल रहा है और यदि यह "DevEnv.EXE" है तो इसे स्टूडियो होना चाहिए इसलिए DesignMode वास्तव में TRUE है।

उस समस्या के साथ जो ProcessName की तलाश कर रहा है वह रजिस्ट्री और अन्य अजीब भागों के माध्यम से अंतिम परिणाम के साथ अपने तरीके से काम करता है ताकि उपयोगकर्ता को प्रक्रिया का नाम देखने के लिए आवश्यक अधिकार न हो। इसके अलावा यह अजीब मार्ग बहुत धीमा है। इसलिए हमें एक सिंगलटन का उपयोग करने के लिए अतिरिक्त हैक करने के लिए ढेर करना पड़ा है और यदि प्रक्रिया का नाम पूछते समय कोई त्रुटि होती है, तो मान लें कि DesignMode FALSE है।

DesignMode को निर्धारित करने का एक अच्छा साफ तरीका क्रम में है। Microsoft को फ्रेमवर्क में आंतरिक रूप से इसे ठीक करने के लिए प्राप्त करना और भी बेहतर होगा!

Question 2

इस प्रश्न का उत्तर देते हुए, मैंने अब इसे करने के 5 अलग-अलग तरीकों की खोज की है, जो इस प्रकार हैं:

System.ComponentModel.DesignMode property

System.ComponentModel.LicenseManager.UsageMode property

private string ServiceString()
{
    if (GetService(typeof(System.ComponentModel.Design.IDesignerHost)) != null) 
        return "Present";
    else
        return "Not present";
}

public bool IsDesignerHosted
{
    get
    {
        Control ctrl = this;

        while(ctrl != null)
        {
            if((ctrl.Site != null) && ctrl.Site.DesignMode)
                return true;
            ctrl = ctrl.Parent;
        }
        return false;
    }
}
public static bool IsInDesignMode()
{
    return System.Reflection.Assembly.GetExecutingAssembly()
         .Location.Contains("VisualStudio"))
}

प्रस्तावित तीन समाधानों पर लटकने और लटकने के लिए, मैंने थोड़ा परीक्षण समाधान बनाया - तीन परियोजनाओं के साथ:

TestApp (विनफॉर्म एप्लिकेशन),
SubControl (dll)
SubSubControl (dll)

मैंने फिर SubControl में SubSubControl को एम्बेड किया, फिर TestApp.Form में प्रत्येक में से एक।

यह स्क्रीनशॉट रन करते समय परिणाम दिखाता है। रनिंग का स्क्रीनशॉट

यह स्क्रीनशॉट विजुअल स्टूडियो में खुले फॉर्म के साथ परिणाम दिखाता है:

न चलने का स्क्रीनशॉट

निष्कर्ष: ऐसा प्रतीत होता है कि केवल एक ही प्रतिबिंब के बिना जो निर्माणकर्ता के भीतर विश्वसनीय है, वह है लाइसेंसयूजेज, और केवल एक जो निर्माणकर्ता के बाहर विश्वसनीय है वह है 'IsDesignedHosted' ( नीचे BlueRaja द्वारा )

पुनश्च: नीचे टूलमेकरसैट की टिप्पणी देखें (जो मैंने परीक्षण नहीं किया है): "ध्यान दें कि IsDesignerHosted उत्तर को लाइसेंस यूजेज में शामिल करने के लिए अपडेट किया गया है ..., इसलिए अब परीक्षण बस हो सकता है अगर (IsDesignerHosted)। एक वैकल्पिक दृष्टिकोण है , निर्माता में परीक्षण लाइसेंस प्रबंधक। और परिणाम को कैश करें । "

Question 3

से यह पेज :

( [संपादित करें २०१३] निर्माणकर्ताओं में काम करने के लिए संपादित, @hopla द्वारा प्रदान की गई विधि का उपयोग करके)

/// <summary>
/// The DesignMode property does not correctly tell you if
/// you are in design mode.  IsDesignerHosted is a corrected
/// version of that property.
/// (see https://connect.microsoft.com/VisualStudio/feedback/details/553305
/// and http://stackoverflow.com/a/2693338/238419 )
/// </summary>
public bool IsDesignerHosted
{
    get
    {
        if (LicenseManager.UsageMode == LicenseUsageMode.Designtime)
            return true;

        Control ctrl = this;
        while (ctrl != null)
        {
            if ((ctrl.Site != null) && ctrl.Site.DesignMode)
                return true;
            ctrl = ctrl.Parent;
        }
        return false;
    }
}

मैंने Microsoft के साथ बग-रिपोर्ट प्रस्तुत की है ; मुझे संदेह है कि यह कहीं भी जाएगा, लेकिन इसे वैसे भी वोट दें, क्योंकि यह स्पष्ट रूप से एक बग है (चाहे "डिजाइन द्वारा" हो या नहीं )।

Question 4

आप लाइसेंस प्रबंधक की जाँच क्यों नहीं करते हैं। UMageMode इस गुण के मान हो सकते हैं लाइसेंसUsageMode.Runtime या लाइसेंसUsageMode.Designtime।

क्या आप कोड केवल रनटाइम में चलाना चाहते हैं, निम्न कोड का उपयोग करें:

if (LicenseManager.UsageMode == LicenseUsageMode.Runtime)
{
  bla bla bla...
}

Question 5

यह वह विधि है जिसका मैं अंदर के रूपों में उपयोग करता हूं:

    /// <summary>
    /// Gets a value indicating whether this instance is in design mode.
    /// </summary>
    /// <value>
    ///     <c>true</c> if this instance is in design mode; otherwise, <c>false</c>.
    /// </value>
    protected bool IsDesignMode
    {
        get { return DesignMode || LicenseManager.UsageMode == LicenseUsageMode.Designtime; }
    }

इस तरह, परिणाम सही होगा, भले ही DesignMode या लाइसेंस प्रबंधक गुण विफल हो।

Question 6

मैं लाइसेंस प्रबंधक विधि का उपयोग करता हूं, लेकिन जीवन भर के उपयोग के लिए निर्माणकर्ता से मूल्य को कैश करता हूं।

public MyUserControl()
{
    InitializeComponent();
    m_IsInDesignMode = (LicenseManager.UsageMode == LicenseUsageMode.Designtime);
}

private bool m_IsInDesignMode = true;
public bool IsInDesignMode { get { return m_IsInDesignMode; } }

VB संस्करण:

Sub New()
    InitializeComponent()

    m_IsInDesignMode = (LicenseManager.UsageMode = LicenseUsageMode.Designtime)
End Sub

Private ReadOnly m_IsInDesignMode As Boolean = True
Public ReadOnly Property IsInDesignMode As Boolean
    Get
        Return m_IsInDesignMode
    End Get
End Property

Question 7

हम इस कोड का उपयोग सफलता के साथ करते हैं:

public static bool IsRealDesignerMode(this Control c)
{
  if (System.ComponentModel.LicenseManager.UsageMode == System.ComponentModel.LicenseUsageMode.Designtime)
    return true;
  else
  {
    Control ctrl = c;

    while (ctrl != null)
    {
      if (ctrl.Site != null && ctrl.Site.DesignMode)
        return true;
      ctrl = ctrl.Parent;
    }

    return System.Diagnostics.Process.GetCurrentProcess().ProcessName == "devenv";
  }
}

Question 8

मेरा सुझाव @ blueraja-danny-pflughoeft उत्तर का अनुकूलन है । यह समाधान हर बार परिणाम की गणना नहीं करता है, लेकिन केवल पहली बार में (कोई वस्तु उपयोग नहीं बदल सकती है। डिजाइन से रनटाइम तक)

private bool? m_IsDesignerHosted = null; //contains information about design mode state
/// <summary>
/// The DesignMode property does not correctly tell you if
/// you are in design mode.  IsDesignerHosted is a corrected
/// version of that property.
/// (see https://connect.microsoft.com/VisualStudio/feedback/details/553305
/// and https://stackoverflow.com/a/2693338/238419 )
/// </summary>
[Browsable(false)]
public bool IsDesignerHosted
{
    get
    {
        if (m_IsDesignerHosted.HasValue)
            return m_IsDesignerHosted.Value;
        else
        {
            if (LicenseManager.UsageMode == LicenseUsageMode.Designtime)
            {
                m_IsDesignerHosted = true;
                return true;
            }
            Control ctrl = this;
            while (ctrl != null)
            {
                if ((ctrl.Site != null) && ctrl.Site.DesignMode)
                {
                    m_IsDesignerHosted = true;
                    return true;
                }
                ctrl = ctrl.Parent;
            }
            m_IsDesignerHosted = false;
            return false;
        }
    }
}

Question 9

मैं कभी भी खुद से पकड़ा नहीं गया है, लेकिन क्या आप नियंत्रण श्रृंखला से मूल श्रृंखला को वापस चलने के लिए नहीं देख सकते हैं कि क्या DesignMode आपके ऊपर कहीं सेट है?

Question 10

चूंकि कोई भी विधि विश्वसनीय नहीं है (DesignMode, लाइसेंस प्रबंधक) या कुशल (प्रक्रिया, पुनरावर्ती चेक) मैं public static bool Runtime { get; private set }प्रोग्राम स्तर पर उपयोग कर रहा हूं और स्पष्ट रूप से इसे मुख्य () विधि के अंदर सेट कर रहा हूं ।

Question 11

DesignMode एक निजी संपत्ति है (जो मैं बता सकता हूं) से। इसका जवाब सार्वजनिक संपत्ति प्रदान करना है जो DesignMode प्रोप को उजागर करता है। तब तक आप उपयोगकर्ता नियंत्रण की श्रृंखला का समर्थन कर सकते हैं जब तक कि आप एक गैर-उपयोगकर्ता नियंत्रण या एक नियंत्रण जो कि डिज़ाइन मोड में है, तब तक चलाएं। कुछ इस तरह....

  public bool RealDesignMode()
  {
     if (Parent is MyBaseUserControl)
     {
        return (DesignMode ? true : (MyBaseUserControl) Parent.RealDesignMode;
     }

     return DesignMode;
  }

जहाँ आपके सभी UserControls को MyBaseUserControl से विरासत में मिला है। वैकल्पिक रूप से आप एक इंटरफ़ेस लागू कर सकते हैं जो "RealDeisgnMode" को उजागर करता है।

कृपया ध्यान दें कि यह कोड लाइव कोड नहीं है। :)

Question 12

मुझे एहसास नहीं था कि आप Parent.DesignMode को कॉल नहीं कर सकते हैं (और मैंने C # में 'संरक्षित' के बारे में कुछ सीखा है ...)

यहाँ एक चिंतनशील संस्करण है: (मुझे संदेह है कि डिजाइन बनाने के लिए एक प्रदर्शन लाभ हो सकता है।

static bool IsDesignMode(Control control)
{
    PropertyInfo designModeProperty = typeof(Component).
      GetProperty("DesignMode", BindingFlags.Instance | BindingFlags.NonPublic);

    while (designModeProperty != null && control != null)
    {
        if((bool)designModeProperty.GetValue(control, null))
        {
            return true;
        }
        control = control.Parent;
    }
    return false;
}

Question 13

नेस्टेड यूज़रकंट्रोल का उपयोग करते समय मुझे हाल ही में विजुअल स्टूडियो 2017 में इस समस्या से जूझना पड़ा। मैं ऊपर और अन्य जगहों पर वर्णित दृष्टिकोणों में से कई को संयोजित करता हूं, फिर कोड को तब तक टाल दिया जाता है जब तक मेरे पास एक सभ्य विस्तार विधि नहीं थी जो अब तक स्वीकार्य रूप से काम करता है। यह चेक का एक क्रम करता है, जिसके परिणामस्वरूप स्टूल बूलियन वेरिएबल्स में परिणाम होता है इसलिए प्रत्येक चेक केवल रन टाइम के दौरान केवल एक बार ही किया जाता है। प्रक्रिया ओवरकिल हो सकती है, लेकिन यह कोड को स्टूडियो में निष्पादित करने से रोक रही है। आशा है कि यह किसी की मदद करता है।

  public static class DesignTimeHelper
  {
    private static bool? _isAssemblyVisualStudio;
    private static bool? _isLicenseDesignTime;
    private static bool? _isProcessDevEnv;
    private static bool? _mIsDesignerHosted; 

    /// <summary>
    ///   Property <see cref="Form.DesignMode"/> does not correctly report if a nested <see cref="UserControl"/>
    ///   is in design mode.  InDesignMode is a corrected that property which .
    ///   (see https://connect.microsoft.com/VisualStudio/feedback/details/553305
    ///   and https://stackoverflow.com/a/2693338/238419 )
    /// </summary>
    public static bool InDesignMode(
      this Control userControl,
      string source = null)
      => IsLicenseDesignTime
         || IsProcessDevEnv
         || IsExecutingAssemblyVisualStudio
         || IsDesignerHosted(userControl);

    private static bool IsExecutingAssemblyVisualStudio
      => _isAssemblyVisualStudio
         ?? (_isAssemblyVisualStudio = Assembly
           .GetExecutingAssembly()
           .Location.Contains(value: "VisualStudio"))
         .Value;

    private static bool IsLicenseDesignTime
      => _isLicenseDesignTime
         ?? (_isLicenseDesignTime = LicenseManager.UsageMode == LicenseUsageMode.Designtime)
         .Value;

    private static bool IsDesignerHosted(
      Control control)
    {
      if (_mIsDesignerHosted.HasValue)
        return _mIsDesignerHosted.Value;

      while (control != null)
      {
        if (control.Site?.DesignMode == true)
        {
          _mIsDesignerHosted = true;
          return true;
        }

        control = control.Parent;
      }

      _mIsDesignerHosted = false;
      return false;
    }

    private static bool IsProcessDevEnv
      => _isProcessDevEnv
         ?? (_isProcessDevEnv = Process.GetCurrentProcess()
                                  .ProcessName == "devenv")
         .Value;
  }