Détection du mode de conception depuis le constructeur d'un contrôle

À la suite de cette question , est-il possible de détecter si l'on est en mode conception ou en mode exécution depuis le constructeur d'un objet?

Je me rends compte que ce n'est peut-être pas possible et que je vais devoir changer ce que je veux, mais pour l'instant je m'intéresse à cette question précise.

Vous pouvez utiliser l' énumération LicenceUsageMode dans l' System.ComponentModelespace de noms:

bool designMode = (LicenseManager.UsageMode == LicenseUsageMode.Designtime);

Cherchez-vous quelque chose comme ça:

public static bool IsInDesignMode()
{
    if (Application.ExecutablePath.IndexOf("devenv.exe", StringComparison.OrdinalIgnoreCase) > -1)
    {
        return true;
    }
    return false;
}

Vous pouvez également le faire en vérifiant le nom du processus:

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

Component ... pour autant que je sache, n'a pas la propriété DesignMode. Cette propriété est fournie par Control. Mais le problème est que lorsque CustomControl se trouve dans un formulaire dans le concepteur, ce CustomControl s'exécute en mode d'exécution.

J'ai constaté que la propriété DesignMode ne fonctionne correctement que dans Form.

Les contrôles (Forms, UserControls, etc.) héritent de Component classce qui a bool property DesignMode:

if(DesignMode)
{
  //If in design mode
}

IMPORTANT

Il y a une différence entre l'utilisation de Windows Forms ou de WPF !!

Ils ont des concepteurs différents et ont besoin de différents contrôles . De plus, c'est délicat lorsque vous mélangez des formulaires et des contrôles WPF. (par exemple, les contrôles WPF à l'intérieur d'une fenêtre Forms)

Si vous disposez uniquement de Windows Forms , utilisez ceci:

Boolean isInWpfDesignerMode   = (LicenseManager.UsageMode == LicenseUsageMode.Designtime);

Si vous avez WPF uniquement , utilisez cette vérification:

Boolean isInFormsDesignerMode = (System.Diagnostics.Process.GetCurrentProcess().ProcessName == "devenv");

Si vous avez une utilisation mixte de Forms et WPF, utilisez une vérification comme celle-ci:

Boolean isInWpfDesignerMode   = (LicenseManager.UsageMode == LicenseUsageMode.Designtime);
Boolean isInFormsDesignerMode = (System.Diagnostics.Process.GetCurrentProcess().ProcessName == "devenv");

if (isInWpfDesignerMode || isInFormsDesignerMode)
{
    // is in any designer mode
}
else
{
    // not in designer mode
}

Pour voir le mode actuel, vous pouvez afficher une MessageBox pour le débogage:

// show current mode
MessageBox.Show(String.Format("DESIGNER CHECK:  WPF = {0}   Forms = {1}", isInWpfDesignerMode, isInFormsDesignerMode));

Remarque:

Vous devez ajouter les espaces de noms System.ComponentModel et System.Diagnostics .

Vous devez utiliser la propriété Component.DesignMode. Autant que je sache, cela ne devrait pas être utilisé à partir d'un constructeur.

Une autre méthode intéressante est décrite sur ce blog: http://www.undermyhat.org/blog/2009/07/in-depth-a-definitive-guide-to-net-user-controls-usage-mode-designmode-or -mode utilisateur/

Fondamentalement, il teste l'assembly en cours d'exécution référencé statiquement à partir de l'assembly d'entrée. Cela évite d'avoir à suivre les noms d'assemblages («devenv.exe», «monodevelop.exe» ..).

Cependant, cela ne fonctionne pas dans tous les autres scénarios, où l'assembly est chargé dynamiquement (VSTO en est un exemple).

Avec la coopération du concepteur ... Il peut être utilisé dans les contrôles, les composants, dans tous les endroits

    private bool getDesignMode()
    {
        IDesignerHost host;
        if (Site != null)
        {
            host = Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
            if (host != null)
            {
                if (host.RootComponent.Site.DesignMode) MessageBox.Show("Design Mode");
                else MessageBox.Show("Runtime Mode");
                return host.RootComponent.Site.DesignMode;
            }
        }
        MessageBox.Show("Runtime Mode");
        return false;
    }

MessageBox.Show(les lignes doivent être supprimées. Cela me garantit seulement que cela fonctionne correctement.

Vous pouvez utiliser ceci

if (DesignerProperties.GetIsInDesignMode(this))
{
...
}

C'est la méthode que j'ai utilisée dans mon projet:

//use a Property or Field for keeping the info to avoid runtime computation
public static bool NotInDesignMode { get; } = IsNotInDesignMode();
private static bool IsNotInDesignMode()
{
    /*
    File.WriteAllLines(@"D:\1.log", new[]
    {
        LicenseManager.UsageMode.ToString(), //not always reliable, e.g. WPF app in Blend this will return RunTime
        Process.GetCurrentProcess().ProcessName, //filename without extension
        Process.GetCurrentProcess().MainModule.FileName, //full path
        Process.GetCurrentProcess().MainModule.ModuleName, //filename
        Assembly.GetEntryAssembly()?.Location, //null for WinForms app in VS IDE
        Assembly.GetEntryAssembly()?.ToString(), //null for WinForms app in VS IDE
        Assembly.GetExecutingAssembly().Location, //always return your project's output assembly info
        Assembly.GetExecutingAssembly().ToString(), //always return your project's output assembly info
    });
    //*/

    //LicenseManager.UsageMode will return RunTime if LicenseManager.context is not present.
    //So you can not return true by judging it's value is RunTime.
    if (LicenseUsageMode.Designtime == LicenseManager.UsageMode) return false;
    var procName = Process.GetCurrentProcess().ProcessName.ToLower();
    return "devenv" != procName //WinForms app in VS IDE
        && "xdesproc" != procName //WPF app in VS IDE/Blend
        && "blend" != procName //WinForms app in Blend
        //other IDE's process name if you detected by log from above
        ;
}

Attention !!!: Le code retourné booléen indique PAS en mode conception!

    private void CtrlSearcher_Load(object sender, EventArgs e)
    {
           if(!this.DesignMode) InitCombos();
    }

La solution LicenseManager ne fonctionne pas dans OnPaint, cela non plus. J'ai eu recours à la même solution que @Jarek.

Voici la version en cache:

    private static bool? isDesignMode;
    private static bool IsDesignMode()
    {
        if (isDesignMode == null)
            isDesignMode = (Process.GetCurrentProcess().ProcessName.ToLower().Contains("devenv"));

        return isDesignMode.Value;
    }

Sachez que cela échouera si vous utilisez un IDE tiers ou si Microsoft (ou votre utilisateur final) décide de changer le nom de l'exécutable VS en autre chose que «devenv». Le taux d'échec sera très faible, assurez-vous simplement de traiter toutes les erreurs qui pourraient survenir dans le code qui échoue à la suite de cela et tout ira bien.

Si vous souhaitez exécuter certaines lignes lorsqu'il est en cours d'exécution mais pas dans le concepteur Visual Studio, vous devez implémenter la propriété DesignMode comme suit:

// this code is in the Load of my UserControl
if (this.DesignMode == false)
{
    // This will only run in run time, not in the designer.
    this.getUserTypes();
    this.getWarehouses();
    this.getCompanies();
}

Les minuteries activées par défaut peuvent provoquer des plantages lors de l'utilisation de contrôles personnalisés / utilisateur. Désactivez-les par défaut et activez-les uniquement après la vérification du mode de conception

   public chartAdapter()
    {
        try
        {

            //Initialize components come here
            InitializeComponent();

            //Design mode check
            bool designMode = (LicenseManager.UsageMode == LicenseUsageMode.Designtime);
            if (designMode)
                return;

            //Enable timers ONLY after designmode check, or else crash
            timerAutoConnect.Enabled = timerDraw.Enabled = true;