Detectando o modo de design de um construtor de controle

Seguindo com esta pergunta , é possível detectar se alguém está no modo de design ou tempo de execução de dentro do construtor de um objeto?

Sei que isso pode não ser possível e que terei que mudar o que desejo, mas por enquanto estou interessado nesta questão específica.

Você pode usar a enumeração LicenceUsageMode no System.ComponentModelnamespace:

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

Você está procurando algo parecido com isto:

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

Você também pode fazer isso verificando o nome do processo:

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

Componente ... até onde eu sei, não tem a propriedade DesignMode. Esta propriedade é fornecida por Control. Mas o problema é que quando CustomControl está localizado em um Form no designer, esse CustomControl está rodando em modo runtime.

Eu percebi que a propriedade DesignMode funciona corretamente apenas no Form.

Os controles (formulários, controles do usuário etc.) herdam o Component classque tem bool property DesignMode:

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

IMPORTANTE

Existe uma diferença de usar Windows Forms ou WPF !!

Eles têm designers diferentes e precisam de verificações diferentes . Além disso, é complicado quando você mistura controles de formulários e WPF. (por exemplo, controles WPF dentro de uma janela do Formulários)

Se você tiver apenas Windows Forms , use este:

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

Se você tiver apenas WPF , use esta verificação:

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

Se você misturou o uso de formulários e WPF, use uma verificação como esta:

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
}

Para ver o modo atual, você pode mostrar uma MessageBox para depuração:

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

Observação:

Você precisa adicionar os namespaces System.ComponentModel e System.Diagnostics .

Você deve usar a propriedade Component.DesignMode. Pelo que eu sei, isso não deve ser usado por um construtor.

Outro método interessante é descrito nesse blog: http://www.undermyhat.org/blog/2009/07/in-depth-a-definitive-guide-to-net-user-controls-usage-mode-designmode-or -modo de usuário/

Basicamente, ele testa o assembly em execução sendo referenciado estaticamente no assembly de entrada. Ele contorna a necessidade de rastrear nomes de assemblies ('devenv.exe', 'monodevelop.exe' ..).

No entanto, ele não funciona em todos os outros cenários, nos quais o assembly é carregado dinamicamente (o VSTO é um exemplo).

Com a cooperação do designer ... Pode ser usado em Controles, Componentes, em todos os lugares

    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(linhas devem ser removidas. Isso só me garante que funciona corretamente.

Você pode usar isso

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

Este é o método que usei em meu projeto:

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

Atenção !!!: O código retornado bool está indicando NÃO no modo de design!

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

A solução LicenseManager não funciona dentro do OnPaint, nem this.DesignMode. Recorri à mesma solução de @Jarek.

Esta é a versão em cache:

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

        return isDesignMode.Value;
    }

Esteja ciente de que isso irá falhar se você estiver usando qualquer IDE de terceiros ou se a Microsoft (ou seu usuário final) decidir alterar o nome do executável do VS para algo diferente de 'devenv'. A taxa de falha será muito baixa, apenas certifique-se de lidar com quaisquer erros resultantes que possam ocorrer no código que falha como resultado disso e você ficará bem.

Se você deseja executar algumas linhas enquanto está sendo executado, mas não no designer do Visual Studio, você deve implementar a propriedade DesignMode da seguinte maneira:

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

Os temporizadores ativados por padrão podem causar travamento ao usar controles personalizados / do usuário. Desative-os por padrão e ative somente após a verificação do modo de design

   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;