it-swarm.it

Nascondi modulo singolo all'avvio

Ho un'applicazione con un modulo al suo interno e sul metodo Load devo nascondere il modulo.

Il modulo si visualizzerà quando è necessario (pensare sulla falsariga di un popup in stile Outlook 2003), ma posso 'capire come nascondere il modulo in caricamento senza qualcosa di disordinato.

Eventuali suggerimenti?

72
Pondidum

Sto arrivando a questo da C #, ma dovrebbe essere molto simile in vb.net.

Nel tuo file di programma principale, nel metodo Main, avrai qualcosa del tipo:

Application.Run(new MainForm());

Ciò crea un nuovo modulo principale e limita la durata dell'applicazione alla durata del modulo principale.

Tuttavia, se rimuovi il parametro in Application.Run (), l'applicazione verrà avviata senza alcun modulo mostrato e sarai libero di mostrare e nascondere i moduli come preferisci.

Anziché nascondere il modulo nel metodo Load, inizializzare il modulo prima di chiamare Application.Run (). Suppongo che il modulo avrà un NotifyIcon su di esso per visualizzare un'icona nella barra delle attività - questo può essere visualizzato anche se il modulo stesso non è ancora visibile. Chiamare Form.Show() o Form.Hide() dai gestori degli eventi NotifyIcon mostrerà e nasconderà il modulo rispettivamente.

108
Grokys

Di solito lo faresti solo quando usi un'icona nella barra delle applicazioni o qualche altro metodo per visualizzare il modulo in un secondo momento, ma funzionerà bene anche se non visualizzi mai il modulo principale.

Crea un bool nella tua classe Form che è impostato come predefinito su false:

private bool allowshowdisplay = false;

Quindi sovrascrivere il metodo SetVisibleCore

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

Poiché Application.Run () imposta i moduli .Visible = true dopo aver caricato il modulo, questo lo intercetta e lo imposta su false. Nel caso sopra, lo imposterà sempre su false fino a quando non lo abiliti impostando allowshowdisplay su true.

Ora che impedirà la visualizzazione del modulo all'avvio, ora è necessario riattivare SetVisibleCore per funzionare correttamente impostando allowshowdisplay = true. Ti consigliamo di farlo su qualsiasi funzione dell'interfaccia utente che visualizza il modulo. Nel mio esempio è l'evento click sinistro nel mio oggetto notiyicon:

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

Io uso questo:

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

Ovviamente devi cambiare la condizione if con la tua.

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

        base.OnLoad(e);
    }
19
Chriz

Al momento della costruzione del modulo (Designer, programma principale o costruttore del modulo, a seconda dei tuoi obiettivi),

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

Quando è necessario mostrare il modulo, presumibilmente in caso di evento da NotifyIcon, invertire se necessario,

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

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

Gli eventi successivi mostra/nascondi possono semplicemente utilizzare la proprietà Visibile del modulo o i metodi Mostra/Nascondi.

14
Jeff

Prova a nascondere l'app anche dalla barra delle applicazioni.

Per farlo, utilizza questo codice.

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

   base.OnLoad(e);
   }

Grazie. Ruhul

5

Ho lottato molto con questo problema e la soluzione è molto più semplice di quanto pensassi. Prima ho provato tutti i suggerimenti qui, ma poi non ero soddisfatto del risultato e l'ho studiato un po 'di più. Ho scoperto che se aggiungo:

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

Funziona bene. ma volevo una soluzione più semplice e si scopre che se aggiungi il:

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

Si desidera impostare lo stato della finestra su ridotto a icona e mostrare nella barra delle applicazioni su falso. Quindi alla fine dei moduli Carica lo stato della finestra impostato su ingrandito e mostra nella barra delle applicazioni su vero

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

Inserisci questo nel tuo Program.cs:

FormName FormName = new FormName ();

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

Utilizzare questo quando si desidera visualizzare il modulo:

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

Sostituisci OnVisibleChanged nel modulo

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

    base.OnVisibleChanged(e);
}

È possibile aggiungere trigger se potrebbe essere necessario mostrarlo a un certo punto

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);
    }
...
}
1
LKane

Questo funziona perfettamente per me:

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

Quando avvio il progetto, tutto è stato nascosto, incluso nella barra delle applicazioni, a meno che non sia necessario mostrarlo.

0
Willy David Jr

Avviare un'app senza un modulo significa che dovrai gestire tu stesso l'avvio/arresto dell'applicazione.

L'avvio del modulo da invisibile è un'opzione migliore.

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

Ecco un approccio semplice:
È in C # (non ho VB al momento)

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

Ho avuto un problema simile a quello del poster in cui il codice per nascondere il modulo nell'evento form_Load veniva generato prima che il modulo fosse completamente caricato, facendo fallire il metodo Hide () (non si bloccava, ma non funzionava come previsto).

Le altre risposte sono fantastiche e funzionano, ma ho scoperto che in generale, l'evento form_Load ha spesso problemi del genere e ciò che vuoi inserire può facilmente andare nel costruttore o nell'evento form_Shown.

Ad ogni modo, quando ho spostato lo stesso codice che controlla alcune cose, nasconde il modulo quando non è necessario (un modulo di accesso in caso di errore di accesso singolo), ha funzionato come previsto.

0
blind Skwirl

Questo esempio supporta l'invisibilità totale, nonché solo NotifyIcon nella barra delle applicazioni e nessun clic e molto altro.

Altro qui: http://code.msdn.Microsoft.com/TheNotifyIconExample

0
TheUberOverLord

Come complemento a risposta di Groky (che in realtà è la migliore risposta di gran lunga nella mia prospettiva) potremmo anche menzionare la classe ApplicationContext , che consente anche (come mostrato nella esempio dell'articolo) la possibilità di aprire due (o anche più) moduli all'avvio dell'applicazione e controllare la durata dell'applicazione con tutti loro.

0
Eugenio Miró