DesignMode mit verschachtelten Steuerelementen

Hat jemand eine nützliche Lösung für das DesignMode-Problem bei der Entwicklung von Steuerelementen gefunden?

Das Problem ist, dass DesignMode nur für die erste Ebene funktioniert, wenn Sie Steuerelemente verschachteln. Die zweite und untere Ebene von DesignMode gibt immer FALSE zurück.

Der Standard-Hack bestand darin, den Namen des laufenden Prozesses zu überprüfen. Wenn es sich um "DevEnv.EXE" handelt, muss es sich um Studio handeln, damit DesignMode wirklich WAHR ist.

Das Problem dabei ist, dass der Prozessname nach der Registrierung und anderen seltsamen Teilen durchsucht wird. Das Endergebnis ist, dass der Benutzer möglicherweise nicht über die erforderlichen Rechte verfügt, um den Prozessnamen anzuzeigen. Außerdem ist diese seltsame Route sehr langsam. Wir mussten also zusätzliche Hacks stapeln, um einen Singleton zu verwenden. Wenn bei der Abfrage des Prozessnamens ein Fehler auftritt, wird davon ausgegangen, dass DesignMode FALSE ist.

Ein guter, sauberer Weg, um DesignMode zu bestimmen, ist in Ordnung. Es wäre sogar noch besser, Microsoft dazu zu bringen, das Problem intern im Framework zu beheben!

Bei erneuter Betrachtung dieser Frage habe ich nun 5 verschiedene Möglichkeiten entdeckt, dies zu tun:

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

Um die drei vorgeschlagenen Lösungen in den Griff zu bekommen, habe ich eine kleine Testlösung erstellt - mit drei Projekten:

• TestApp (Winforms-Anwendung),
• SubControl (dll)
• SubSubControl (dll)

Ich habe dann das SubSubControl in das SubControl eingebettet, dann jeweils eines in die TestApp.Form.

Dieser Screenshot zeigt das Ergebnis beim Ausführen.

Dieser Screenshot zeigt das Ergebnis mit dem in Visual Studio geöffneten Formular:

Schlussfolgerung: Es scheint, dass ohne Reflexion LicenseUsage die einzige ist, die innerhalb des Konstruktors zuverlässig ist, und die einzige, die außerhalb des Konstruktors zuverlässig ist, ist 'IsDesignedHosted' (von BlueRaja unten).

PS: Siehe den folgenden Kommentar von ToolmakerSteve (den ich nicht getestet habe): "Beachten Sie, dass die Antwort von IsDesignerHosted aktualisiert wurde, um LicenseUsage ... einzuschließen. Der Test kann nun einfach if (IsDesignerHosted) sein. Ein alternativer Ansatz ist das Testen von LicenseManager im Konstruktor und das Ergebnis zwischenspeichern . "

Von dieser Seite :

( [Edit 2013] Bearbeitet, um in Konstruktoren mit der von @hopla bereitgestellten Methode zu arbeiten.)

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

Ich habe einen Fehlerbericht bei Microsoft eingereicht . Ich bezweifle, dass es irgendwohin gehen wird, aber stimmen Sie es trotzdem ab, da dies offensichtlich ein Fehler ist (unabhängig davon, ob es " beabsichtigt" ist oder nicht ).

Warum überprüfen Sie nicht LicenseManager.UsageMode? Diese Eigenschaft kann die Werte LicenseUsageMode.Runtime oder LicenseUsageMode.Designtime haben.

Wenn Code nur zur Laufzeit ausgeführt werden soll, verwenden Sie den folgenden Code:

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

Dies ist die Methode, die ich in Formularen verwende:

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

Auf diese Weise ist das Ergebnis auch dann korrekt, wenn eine der DesignMode- oder LicenseManager-Eigenschaften fehlschlägt.

Ich verwende die LicenseManager-Methode, speichere aber den Wert des Konstruktors für die Verwendung während der gesamten Lebensdauer der Instanz zwischen.

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

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

VB-Version:

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

Wir verwenden diesen Code mit Erfolg:

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

Mein Vorschlag ist eine Optimierung der Antwort @ blueraja-danny-pflughoeft . Diese Lösung berechnet das Ergebnis nicht jedes Mal, sondern nur beim ersten Mal (ein Objekt kann den UsageMode nicht vom Entwurf zur Laufzeit ändern).

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

Ich bin selbst noch nie davon überrascht worden, aber können Sie nicht einfach die übergeordnete Kette von der Steuerung zurückgehen, um zu sehen, ob DesignMode irgendwo über Ihnen eingestellt ist?

Da keine der Methoden zuverlässig (DesignMode, LicenseManager) oder effizient (Prozess, rekursive Prüfungen) ist, verwende ich eine public static bool Runtime { get; private set }auf Programmebene und setze sie explizit in die Main () -Methode.

DesignMode ist eine private Immobilie (soweit ich das beurteilen kann). Die Antwort besteht darin, eine öffentliche Eigenschaft bereitzustellen, die die DesignMode-Requisite verfügbar macht. Anschließend können Sie die Kette der Benutzersteuerelemente kaskadieren, bis Sie auf ein Nichtbenutzersteuerelement oder ein Steuerelement stoßen, das sich im Entwurfsmodus befindet. Etwas wie das....

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

     return DesignMode;
  }

Wo alle Ihre UserControls von MyBaseUserControl erben. Alternativ können Sie eine Schnittstelle implementieren, die den "RealDeisgnMode" verfügbar macht.

Bitte beachten Sie, dass es sich bei diesem Code nicht um Live-Code handelt. :) :)

Ich hatte nicht bemerkt, dass Sie Parent.DesignMode nicht aufrufen können (und ich habe auch in C # etwas über "geschützt" gelernt ...)

Hier ist eine reflektierende Version: (Ich vermute, dass es einen Leistungsvorteil gibt, designModeProperty zu einem statischen Feld zu machen.)

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

Ich musste dieses Problem kürzlich in Visual Studio 2017 bekämpfen, wenn ich verschachtelte UserControls verwendete. Ich kombiniere mehrere der oben und anderswo erwähnten Ansätze und optimiere dann den Code, bis ich eine anständige Erweiterungsmethode habe, die bisher akzeptabel funktioniert. Es führt eine Folge von Überprüfungen durch und speichert das Ergebnis in statischen booleschen Variablen, sodass jede Überprüfung zur Laufzeit höchstens einmal durchgeführt wird. Der Prozess mag übertrieben sein, verhindert jedoch, dass der Code im Studio ausgeführt wird. Hoffe das hilft jemandem.

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