Einzelformular beim Start ausblenden

Ich habe eine Anwendung mit einem Formular darin, und bei der Lademethode muss ich das Formular ausblenden.

Das Formular wird von selbst angezeigt, wenn dies erforderlich ist (denken Sie an ein Popup im Outlook 2003-Stil), aber ich kann herausfinden, wie das Formular beim Laden ausgeblendet werden kann, ohne dass etwas Unordentliches auftritt.

Irgendwelche Vorschläge?

Ich komme dazu von C #, sollte aber in vb.net sehr ähnlich sein.

In Ihrer Hauptprogrammdatei haben Sie in der Main-Methode Folgendes:

Application.Run(new MainForm());

Dadurch wird ein neues Hauptformular erstellt und die Lebensdauer der Anwendung auf die Lebensdauer des Hauptformulars begrenzt.

Wenn Sie jedoch den Parameter in Application.Run () entfernen, wird die Anwendung ohne angezeigtes Formular gestartet und Sie können Formulare beliebig oft ein- und ausblenden.

Initialisieren Sie das Formular, bevor Sie Application.Run () aufrufen, anstatt das Formular in der Load-Methode auszublenden. Ich gehe davon aus, dass das Formular ein NotifyIcon enthält, um ein Symbol in der Taskleiste anzuzeigen. Dies kann auch dann angezeigt werden, wenn das Formular selbst noch nicht sichtbar ist. Durch Aufrufen Form.Show()oder Form.Hide()von Handlern von NotifyIcon-Ereignissen wird das Formular angezeigt bzw. ausgeblendet.

Normalerweise tun Sie dies nur, wenn Sie ein Taskleistensymbol oder eine andere Methode verwenden, um das Formular später anzuzeigen. Dies funktioniert jedoch auch dann gut, wenn Sie Ihr Hauptformular nie anzeigen.

Erstellen Sie in Ihrer Formularklasse einen Bool, der standardmäßig auf false gesetzt ist:

private bool allowshowdisplay = false;

Überschreiben Sie dann die SetVisibleCore-Methode

protected override void SetVisibleCore(bool value)
{            
    base.SetVisibleCore(allowshowdisplay ? value : allowshowdisplay);
}

Da Application.Run () die Formulare festlegt .Visible = true, nachdem das Formular geladen wurde, wird dies abgefangen und auf false gesetzt. Im obigen Fall wird es immer auf false gesetzt, bis Sie es aktivieren, indem Sie allowhowdisplay auf true setzen.

Damit das Formular beim Start nicht mehr angezeigt wird, müssen Sie SetVisibleCore erneut aktivieren, damit es ordnungsgemäß funktioniert, indem Sie allowhowdisplay = true festlegen. Sie sollten dies für jede Benutzeroberflächenfunktion tun, die das Formular anzeigt. In meinem Beispiel ist es das Linksklick-Ereignis in meinem Notiyicon-Objekt:

private void notifyIcon1_MouseClick(object sender, MouseEventArgs e)
{
    if (e.Button == System.Windows.Forms.MouseButtons.Left)
    {
        this.allowshowdisplay = true;
        this.Visible = !this.Visible;                
    }
}

Ich benutze das:

private void MainForm_Load(object sender, EventArgs e)
{
    if (Settings.Instance.HideAtStartup)
    {
        BeginInvoke(new MethodInvoker(delegate
        {
            Hide();
        }));
    }
}

Natürlich müssen Sie die if-Bedingung mit Ihrer ändern.

    protected override void OnLoad(EventArgs e)
    {
        Visible = false; // Hide form window.
        ShowInTaskbar = false; // Remove from taskbar.
        Opacity = 0;

        base.OnLoad(e);
    }

Zur Formularerstellungszeit (Designer, Programm Main oder Formularkonstruktor, abhängig von Ihren Zielen),

 this.WindowState = FormWindowState.Minimized;
 this.ShowInTaskbar = false;

Wenn Sie das Formular anzeigen müssen, vermutlich bei einem Ereignis von Ihrem NotifyIcon, kehren Sie es nach Bedarf um.

 if (!this.ShowInTaskbar)
    this.ShowInTaskbar = true;

 if (this.WindowState == FormWindowState.Minimized)
    this.WindowState = FormWindowState.Normal;

Aufeinanderfolgende Ereignisse zum Ein- und Ausblenden können einfacher die Visible-Eigenschaft des Formulars oder die Show / Hide-Methoden verwenden.

Versuchen Sie, die App auch in der Taskleiste auszublenden.

Verwenden Sie dazu bitte diesen Code.

  protected override void OnLoad(EventArgs e)
  {
   Visible = false; // Hide form window.
   ShowInTaskbar = false; // Remove from taskbar.
   Opacity = 0;

   base.OnLoad(e);
   }

Vielen Dank. Ruhul

Erweitern Sie Ihr Hauptformular mit diesem:

using System.Windows.Forms;

namespace HideWindows
{
    public class HideForm : Form
    {
        public HideForm()
        {
            Opacity = 0;
            ShowInTaskbar = false;
        }

        public new void Show()
        {
            Opacity = 100;
            ShowInTaskbar = true;

            Show(this);
        }
    }
}

Zum Beispiel:

namespace HideWindows
{
    public partial class Form1 : HideForm
    {
        public Form1()
        {
            InitializeComponent();
        }
    }
}

Weitere Infos in diesem Artikel (Spanisch):

http://codelogik.net/2008/12/30/primer-form-oculto/

Ich habe viel mit diesem Problem zu kämpfen und die Lösung ist viel einfacher als ich. Ich habe zuerst alle Vorschläge hier ausprobiert, war dann aber mit dem Ergebnis nicht zufrieden und habe es etwas genauer untersucht. Ich fand das, wenn ich Folgendes hinzufüge:

 this.visible=false;
 /* to the InitializeComponent() code just before the */
 this.Load += new System.EventHandler(this.DebugOnOff_Load);

Es funktioniert gut. aber ich wollte eine einfachere Lösung und es stellt sich heraus, dass, wenn Sie Folgendes hinzufügen:

this.visible=false;
/* to the start of the load event, you get a
simple perfect working solution :) */ 
private void
DebugOnOff_Load(object sender, EventArgs e)
{
this.Visible = false;
}

Sie möchten den Fensterstatus auf minimiert setzen und in der Taskleiste auf false anzeigen. Laden Sie dann am Ende Ihres Formulars den Fensterstatus auf Maximieren und zeigen Sie ihn in der Taskleiste auf true an

    public frmMain()
    {
        Program.MainForm = this;
        InitializeComponent();

        this.WindowState = FormWindowState.Minimized;
        this.ShowInTaskbar = false;
    }

private void frmMain_Load(object sender, EventArgs e)
    {
        //Do heavy things here

        //At the end do this
        this.WindowState = FormWindowState.Maximized;
        this.ShowInTaskbar = true;
    }

Fügen Sie dies in Ihre Program.cs ein:

FormName FormName = new FormName ();

FormName.ShowInTaskbar = false;
FormName.Opacity = 0;
FormName.Show();
FormName.Hide();

Verwenden Sie diese Option, wenn Sie das Formular anzeigen möchten:

var principalForm = Application.OpenForms.OfType<FormName>().Single();
principalForm.ShowInTaskbar = true;
principalForm.Opacity = 100;
principalForm.Show();

OnVisibleChanged in Form überschreiben

protected override void OnVisibleChanged(EventArgs e)
{
    this.Visible = false;

    base.OnVisibleChanged(e);
}

Sie können einen Trigger hinzufügen, wenn Sie ihn irgendwann anzeigen müssen

public partial class MainForm : Form
{
public bool hideForm = true;
...
public MainForm (bool hideForm)
    {
        this.hideForm = hideForm;
        InitializeComponent();
    }
...
protected override void OnVisibleChanged(EventArgs e)
    {
        if (this.hideForm)
            this.Visible = false;

        base.OnVisibleChanged(e);
    }
...
}

Hier ist ein einfacher Ansatz:
Es ist in C # (ich habe momentan keinen VB-Compiler)

public Form1()
{
    InitializeComponent();
    Hide(); // Also Visible = false can be used
}

private void Form1_Load(object sender, EventArgs e)
{
    Thread.Sleep(10000);
    Show(); // Or visible = true;
}

Wenn Sie eine App ohne Formular starten, müssen Sie den Start / Herunterfahren der Anwendung selbst verwalten.

Das unsichtbare Starten des Formulars ist eine bessere Option.

Dieses Beispiel unterstützt die vollständige Unsichtbarkeit sowie nur NotifyIcon in der Taskleiste und keine Klicks und vieles mehr.

Mehr hier: http://code.msdn.microsoft.com/TheNotifyIconExample

Als Ergänzung zu Grokys Antwort (die aus meiner Sicht bei weitem die beste Antwort ist) könnten wir auch die ApplicationContext- Klasse erwähnen , die auch (wie im Beispiel des Artikels gezeigt) die Möglichkeit bietet, zwei (oder sogar mehr) Formulare zu öffnen beim Steuern der Anwendung und steuern Sie mit allen die Lebensdauer der Anwendung.

static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    MainUIForm mainUiForm = new MainUIForm();
    mainUiForm.Visible = false;
    Application.Run();
}

Das funktioniert perfekt für mich:

[STAThread]
    static void Main()
    {
        try
        {
            frmBase frm = new frmBase();               
            Application.Run();
        }

Beim Starten des Projekts wurde alles ausgeblendet, auch in der Taskleiste, es sei denn, ich muss es anzeigen.

Ich hatte ein Problem ähnlich dem des Posters, bei dem der Code zum Ausblenden des Formulars im Ereignis form_Load ausgelöst wurde, bevor das Formular vollständig geladen wurde, wodurch die Hide () -Methode fehlschlug (nicht abstürzte, nur nicht wie erwartet funktionierte).

Die anderen Antworten sind großartig und funktionieren, aber ich habe festgestellt, dass das form_Load-Ereignis im Allgemeinen häufig solche Probleme aufweist und das, was Sie dort einfügen möchten, problemlos in den Konstruktor oder das form_Shown-Ereignis übernommen werden kann.

Wie auch immer, wenn ich denselben Code verschoben habe, der einige Dinge überprüft, und dann das Formular versteckt, wenn es nicht benötigt wird (ein Anmeldeformular, wenn die einmalige Anmeldung fehlschlägt), hat es wie erwartet funktioniert.

    static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Form1 form1 = new Form1();
            form1.Visible = false;
            Application.Run();

        }
 private void ExitToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
            Application.Exit();
        }

Setzen Sie im Designer die Visible-Eigenschaft des Formulars auf false. Vermeiden Sie es dann, Show () aufzurufen, bis Sie es brauchen.

Ein besseres Paradigma besteht darin, eine Instanz des Formulars erst zu erstellen, wenn Sie es benötigen.

Warum ist das überhaupt so?

Warum nicht einfach wie eine Konsolen-App starten und das Formular bei Bedarf anzeigen? Es gibt nur ein paar Referenzen, die eine Konsolen-App von einer Formular-App trennen.

Sie müssen nicht gierig sein und den für das Formular erforderlichen Speicher nehmen, wenn Sie ihn möglicherweise nicht einmal benötigen.

Aufgrund verschiedener Vorschläge musste ich nur Folgendes tun:

So verstecken Sie das Formular:

Me.Opacity = 0
Me.ShowInTaskbar = false

So zeigen Sie das Formular an:

Me.Opacity = 100
Me.ShowInTaskbar = true

Ich mache es so - aus meiner Sicht der einfachste Weg:

Setzen Sie die 'StartPosition' des Formulars auf 'Manuell' und fügen Sie diese dem Designer des Formulars hinzu:

Private Sub InitializeComponent()
.
.
.
Me.Location=New Point(-2000,-2000)
.
.
.
End Sub

Stellen Sie sicher, dass der Speicherort auf einen Wert eingestellt ist, der über oder unter den Bildschirmabmessungen liegt. Wenn Sie das Formular später anzeigen möchten, legen Sie den Speicherort auf einen Wert innerhalb der Bildschirmabmessungen fest.