Wykrywanie trybu projektowania z konstruktora Control

Kontynuując to pytanie , czy możliwe jest wykrycie, czy jest się w trybie projektowania lub wykonywania z poziomu konstruktora obiektu?

Zdaję sobie sprawę, że może to nie być możliwe i że będę musiał zmienić to, co chcę, ale na razie interesuje mnie to konkretne pytanie.

Możesz użyć wyliczenia LicenceUsageMode w System.ComponentModelprzestrzeni nazw:

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

Szukasz czegoś takiego:

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

Możesz to również zrobić, sprawdzając nazwę procesu:

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

Komponent ... o ile wiem, nie ma właściwości DesignMode. Ta właściwość jest udostępniana przez Control. Ale problem polega na tym, że CustomControl znajduje się w formularzu w projektancie, to CustomControl działa w trybie środowiska uruchomieniowego.

Doświadczyłem, że właściwość DesignMode działa poprawnie tylko w Form.

Kontrolki (formularze, kontrolki użytkownika itp.) Dziedziczą, Component classco ma bool property DesignMode:

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

WAŻNY

Istnieje różnica w używaniu Windows Forms lub WPF !!

Mają różnych projektantów i wymagają różnych kontroli . Ponadto jest to trudne w przypadku mieszania formantów Forms i WPF. (np. kontrolki WPF w oknie formularzy)

Jeśli masz tylko Windows Forms , użyj tego:

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

Jeśli masz tylko WPF , użyj tego sprawdzenia:

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

Jeśli masz mieszane użycie formularzy i WPF, użyj takiego sprawdzenia:

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
}

Aby zobaczyć bieżący tryb, możesz wyświetlić MessageBox do debugowania:

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

Uwaga:

Musisz dodać przestrzenie nazw System.ComponentModel i System.Diagnostics .

Należy użyć właściwości Component.DesignMode. O ile wiem, nie powinno to być używane przez konstruktora.

Inna ciekawa metoda jest opisana na tym blogu: http://www.undermyhat.org/blog/2009/07/in-depth-a-definitive-guide-to-net-user-controls-usage-mode-designmode-or -tryb użytkownika/

Zasadniczo sprawdza, czy zestaw wykonawczy jest statycznie przywoływany z zestawu wejścia. Zapobiega to konieczności śledzenia nazw zestawów („devenv.exe”, „monodevelop.exe”…).

Jednak nie działa we wszystkich innych scenariuszach, w których zestaw jest ładowany dynamicznie (jednym z przykładów jest VSTO).

Przy współpracy projektanta ... Może być stosowany w Sterownikach, Komponenty, w każdym miejscu

    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(linie powinny zostać usunięte. To tylko upewnia mnie, że działa poprawnie.

Możesz tego użyć

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

Oto metoda, którą zastosowałem w swoim projekcie:

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

Uwaga !!!: Zwrócony kod bool oznacza NIE w trybie projektowania!

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

Rozwiązanie LicenseManager nie działa wewnątrz OnPaint, podobnie jak this.DesignMode. Sięgnąłem po to samo rozwiązanie co @Jarek.

Oto wersja z pamięci podręcznej:

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

        return isDesignMode.Value;
    }

Należy pamiętać, że to się nie powiedzie, jeśli używasz środowiska IDE innej firmy lub jeśli Microsoft (lub Twój użytkownik końcowy) zdecyduje się zmienić nazwę pliku wykonywalnego VS na inną niż „devenv”. Wskaźnik awaryjności będzie bardzo niski, po prostu upewnij się, że poradzisz sobie z wynikającymi z tego błędami, które mogą wystąpić w kodzie, który z tego powodu zawodzi, a wszystko będzie dobrze.

Jeśli chcesz uruchomić niektóre wiersze, gdy jest uruchomiony, ale nie w projektancie programu Visual Studio, należy zaimplementować właściwość DesignMode w następujący sposób:

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

Timery, które są domyślnie włączone, mogą powodować awarie podczas korzystania z elementów sterujących niestandardowych / użytkownika. Wyłącz je domyślnie i włącz dopiero po sprawdzeniu trybu projektowania

   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;