DesignMode với các Điều khiển lồng nhau

Có ai đã tìm ra giải pháp hữu ích cho vấn đề DesignMode khi phát triển các điều khiển không?

Vấn đề là nếu bạn lồng các điều khiển thì DesignMode chỉ hoạt động ở cấp độ đầu tiên. DesignMode cấp thứ hai trở xuống sẽ luôn trả về FALSE.

Bản hack tiêu chuẩn là xem xét tên của quá trình đang chạy và nếu nó là "DevEnv.EXE" thì nó phải là studio, do đó DesignMode thực sự là TRUE.

Vấn đề là tìm kiếm ProcessName hoạt động theo cách của nó thông qua sổ đăng ký và các phần kỳ lạ khác với kết quả cuối cùng là người dùng có thể không có quyền cần thiết để xem tên quy trình. Ngoài ra tuyến đường kỳ lạ này rất chậm. Vì vậy, chúng tôi đã phải bổ sung thêm các bản hack để sử dụng một singleton và nếu lỗi được đưa ra khi yêu cầu tên tiến trình thì hãy giả sử rằng DesignMode là FALSE.

Một cách tốt để xác định DesignMode là theo thứ tự. Việc được Microsoft sửa chữa nội bộ cho khuôn khổ sẽ còn tốt hơn!

Xem lại câu hỏi này, bây giờ tôi đã 'phát hiện ra' 5 cách khác nhau để thực hiện việc này, như sau:

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"))
}

Để thử và nắm bắt được ba giải pháp được đề xuất, tôi đã tạo một giải pháp thử nghiệm nhỏ - với ba dự án:

• TestApp (ứng dụng winforms),
• SubControl (dll)
• SubSubControl (dll)

Sau đó, tôi đã nhúng SubSubControl vào SubControl, sau đó nhúng một SubSubControl vào trong TestApp.Form.

Ảnh chụp màn hình này hiển thị kết quả khi chạy.

Ảnh chụp màn hình này hiển thị kết quả với biểu mẫu mở trong Visual Studio:

Kết luận: Có vẻ như nếu không có sự phản ánh thì duy nhất đáng tin cậy bên trong hàm tạo là LicenseUsage và duy nhất đáng tin cậy bên ngoài hàm tạo là 'IsDesignedHosted' (bởi BlueRaja bên dưới)

Tái bút: Xem nhận xét của ToolmakerSteve bên dưới (mà tôi chưa thử nghiệm): "Lưu ý rằng câu trả lời IsDesignerHosted đã được cập nhật để bao gồm LicenseUsage ..., vì vậy bây giờ kiểm tra có thể chỉ đơn giản là nếu (IsDesignerHosted). Một cách tiếp cận thay thế là kiểm tra LicenseManager trong hàm tạo và lưu kết quả vào bộ nhớ cache . "

Từ trang này :

( [Chỉnh sửa 2013] Đã chỉnh sửa để hoạt động trong trình tạo, sử dụng phương pháp được cung cấp bởi @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;
    }
}

Tôi đã gửi báo cáo lỗi với Microsoft; Tôi nghi ngờ nó sẽ đi đến đâu, nhưng dù sao hãy bình chọn nó, vì đây rõ ràng là một lỗi (cho dù đó có phải là "do thiết kế" hay không ).

Tại sao bạn không kiểm tra LicenseManager.UsageMode. Thuộc tính này có thể có các giá trị LicenseUsageMode.Runtime hoặc LicenseUsageMode.Designtime.

Bạn muốn mã chỉ chạy trong thời gian chạy, hãy sử dụng mã sau:

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

Đây là phương pháp tôi sử dụng bên trong các biểu mẫu:

    /// <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; }
    }

Bằng cách này, kết quả sẽ chính xác, ngay cả khi một trong hai thuộc tính DesignMode hoặc LicenseManager không thành công.

Tôi sử dụng phương thức LicenseManager, nhưng lưu giá trị từ phương thức khởi tạo để sử dụng trong suốt thời gian tồn tại của phiên bản.

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

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

Phiên bản 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

Chúng tôi sử dụng mã này thành công:

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";
  }
}

Đề xuất của tôi là tối ưu hóa câu trả lời @ blueraja-danny-pflughoeft . Giải pháp này không tính toán kết quả mọi lúc mà chỉ tính toán ở lần đầu tiên (một đối tượng không thể thay đổi Chế độ sử dụng từ thiết kế sang thời gian chạy)

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;
        }
    }
}

Bản thân tôi chưa bao giờ gặp phải vấn đề này, nhưng bạn không thể sao lưu chuỗi Parent từ điều khiển để xem liệu DesignMode có được đặt ở bất kỳ đâu phía trên bạn không?

Vì không có phương pháp nào đáng tin cậy (DesignMode, LicenseManager) hoặc hiệu quả (Quy trình, kiểm tra đệ quy) nên tôi đang sử dụng một public static bool Runtime { get; private set }cấp độ chương trình và thiết lập rõ ràng nó bên trong phương thức Main ().

DesignMode là một tài sản riêng (theo những gì tôi có thể nói). Câu trả lời là cung cấp một thuộc tính công khai hiển thị đề xuất DesignMode. Sau đó, bạn có thể sao lưu chuỗi điều khiển của người dùng cho đến khi bạn gặp phải điều khiển không phải người dùng hoặc điều khiển đang ở chế độ thiết kế. Chuyện như thế này….

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

     return DesignMode;
  }

Nơi tất cả UserControl của bạn kế thừa từ MyBaseUserControl. Ngoài ra, bạn có thể triển khai một giao diện hiển thị "RealDeisgnMode".

Xin lưu ý rằng mã này không phải là mã trực tiếp, chỉ là suy nghĩ ngoài vòng bít. :)

Tôi đã không nhận ra rằng bạn không thể gọi Parent.DesignMode (và tôi cũng đã học được điều gì đó về 'protected' trong C # ...)

Đây là một phiên bản phản chiếu: (Tôi nghi ngờ có thể có một lợi thế về hiệu suất khi biến designModeProperty thành một trường tĩnh)

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;
}

Tôi đã phải giải quyết vấn đề này gần đây trong Visual Studio 2017 khi sử dụng UserControls lồng nhau. Tôi kết hợp một số cách tiếp cận được đề cập ở trên và các nơi khác, sau đó chỉnh sửa mã cho đến khi tôi có một phương pháp mở rộng phù hợp hoạt động được chấp nhận cho đến nay. Nó thực hiện một chuỗi kiểm tra, lưu trữ kết quả trong các biến boolean tĩnh, vì vậy mỗi lần kiểm tra chỉ được thực hiện nhiều nhất một lần duy nhất tại thời điểm chạy. Quá trình này có thể quá mức cần thiết, nhưng nó đang giữ cho mã không thực thi trong studio. Hy vọng điều này sẽ giúp ai đó.

  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;
  }