C # /. NET – WinForms – Istanzia un modulo senza mostrarlo

Sto cambiando la visibilità di un modulo su false durante l’evento load E il modulo si mostra ancora. Qual è l’evento giusto per bind questo.Visibile = falso; a? Mi piacerebbe istanziare il Form1 senza mostrarlo.

using System; using System.Windows.Forms; namespace TestClient { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { this.Visible = false; } } } 

Indipendentemente da quanto si tenta di impostare la proprietà Visible prima che il modulo sia stato mostrato, verrà visualizzato. A quanto ho capito, questo è perché è il MainForm dell’attuale ApplicationContext. Un modo per caricare automaticamente il modulo, ma non mostrare all’avvio dell’applicazione, è di modificare il metodo Main. Per impostazione predefinita, assomiglia a questo (.NET 2.0 VS2005):

 [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1()); } 

Se invece fai qualcosa di simile, l’applicazione inizierà, caricherà il modulo ed eseguirà, ma il modulo non mostrerà:

 [STAThread] static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Form1 f = new Form1(); Application.Run(); } 

Non sono del tutto sicuro di come sia utile, ma spero che tu lo sappia; o)

Aggiornamento: sembra che non sia necessario impostare la proprietà Visible su false o fornire un’istanza ApplicationContext (che verrà automaticamente creata per te “sotto il cofano”). Abbreviato il codice di conseguenza.

So che questa è una vecchia domanda, ma mi sono imbattuto in esso e sono abbastanza sorpreso che nessuno abbia menzionato SetVisibleCore :

 bool isVisibleCore = false; protected override void SetVisibleCore(bool value) { base.SetVisibleCore(isVisibleCore); } 

In questo frammento di codice, finché isVisibleCore rimane falso, il modulo rimarrà invisibile. Se è impostato su false quando il modulo viene istanziato, non otterrai quel breve flash di visibilità che otterresti se imposti Visible = false nell’evento Shown.

Mi ci è voluto del tempo per trovare una soluzione funzionante.

Imposta le proprietà denominate WindowState su Minimized e ShowInTaskbar su False nella finestra delle proprietà. Una volta che il modulo è stato completamente caricato, chiama sotto le righe di codice.

  this.ShowInTaskbar = true; this.WindowState = System.Windows.Forms.FormWindowState.Maximized; //this.WindowState = System.Windows.Forms.FormWindowState.Normal; 

PS: questa soluzione è testata su Visual C # 2008 Express Edition

Basta creare un’istanza di Form1 e non chiamare i metodi per visualizzarlo / visualizzarlo. Ma scommetto che stai facendo qualcosa di sbagliato.

Che ne dici di impostare la proprietà Opacity su 0 sul design e torna a 100 quando vuoi mostrare il modulo?

una soluzione con cui posso convivere in modo che il modulo venga creato e on_load venga richiamato alla creazione. imposta WindowState per minimizzare quindi sul set di carico visibile a false e windowstate alla normalità

 private void Form1_Load(object sender, EventArgs e) { this.Visible = false; this.WindowState = FormWindowState.Normal; } 

cosa non ha funzionato:

la soluzione di override di SetVisibleCore non ha creato il modulo

come anche il

 Application { Form1 f = new Form1(); Application.Run(); 

):

Prova l’evento VisibleChanged.

L’evento mostrato potrebbe dare la tua volontà. Sebbene il modulo “lampeggi” per un secondo prima di nascondersi.

 private void Form1_Shown(object sender, EventArgs e) { this.Visible = false; } 

Quello che suggerirei sarebbe di creare un’istanza del modulo in un evento precede l’evento _Show, come il costruttore, dopo la chiamata a IntializeComponent ().

Se questa è la tua forma principale, potrebbe non esserci un posto migliore dell’evento Mostrato. Ma in tal caso si otterrà uno sfarfallio.

Non sono riuscito a trovare un buon posto in cui interrompere la visualizzazione di un modulo principale in esecuzione almeno rapidamente. Anche un timer triggersto nell’evento di caricamento non lo farà.

Se è un modulo secondario, crealo ma non mostrarlo.

Per una soluzione di visualizzazione senza sfarfallio, imposta anche la posizione del modulo fuori campo durante il caricamento:

 private Point startuplocation; private void Form1_Load(object sender, EventArgs e) { this.startuplocation = this.Location; this.Location = new Point(-1000, -1000); } private void Form1_Shown(object sender, EventArgs e) //fires first time shown { this.Visible = false; this.Location = this.startuplocation; } 

Hai provato

 this.Hide(); 

negli eventi form_load o form_activated

Imposta la visibilità sul costruttore, dopo init e poi this.Show () in seguito

InitializeComponent () sta impostando this.Visible = true, dal momento che hai specificato che il modulo dovrebbe essere visibile nel designer (o che è stato impostato in modo predefinito). È necessario impostare Visible su false nella finestra di progettazione e non verrà chiamato da InitializeComponent (). Puoi quindi renderlo visibile in qualsiasi momento.

Avere .Visible = false o Hide() nell’evento Load causerà la visualizzazione breve del modulo, in quanto vi è tempo tra quando diventa fisicamente visibile e quando viene Load evento Load , nonostante il fatto che la documentazione affermi il contrario .

Stai chiamando Show() o ShowDialog() da qualche parte? Non sono sicuro che questo comportamento sia ancora presente, ma almeno nelle versioni precedenti del framework una chiamata a ShowDialog() non ha triggersto l’evento Load , quindi forse questo è il tuo problema (anche se penso che chiamare ShowDialog() quindi nasconderlo una forma modale sarebbe una ctriggers pratica!)

Se è necessario creare l’handle (e gli handle per i controlli) per qualsiasi cosa si stia tentando di fare, un’idea migliore sarebbe quella di impostare StartLocation su Manual , quindi impostare la proprietà Position su una posizione offscreen. Questo creerà e mostrerà il modulo, rendendolo invisibile all’utente.

Sì, l’unico modo elegante in prospettiva per il tuo codice rispetto a quello visivo delle applicazioni è quello di sfarfallare il modulo nascondendosi nell’evento costruttore / caricamento.

Sono d’accordo che questo può essere davvero esasperante, perché le Winform di solito non sembrano belle mentre stanno inizializzando un gruppo di controlli o popolando un grande DataGridView o altro. Tuttavia è necessario che l’handle della finestra esista prima di poterlo fare, creando tutti i problemi che sono stati menzionati.

Ecco qualcosa che ha funzionato per me e hai due possibilità: puoi hide il tuo modulo principale fino a quando non è pronto, oppure puoi mostrare una sorta di splash screen per far sapere al tuo utente che ci stai lavorando. Godere.

 public partial class MainForm : Form { public MainForm() { InitializeComponent(); } Size mDeferredSize; protected override void OnHandleCreated(EventArgs e) { // Capture the "real" size... mDeferredSize = Size; // and set it to nothing... Size = new Size(0, 0); DoSomeUglyInitialization(showOptionalSplash: true); Size = mDeferredSize; // ...and now put it back to the original size base.OnHandleCreated(e); } private void DoSomeUglyInitialization(bool showOptionalSplash) { MySplash splash = null; if (showOptionalSplash) { // We have made some borderless form class with a logo or something... splash = new MySplash(); splash.Show(); } // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv // Initialization that REQUIRES A HANDLE, e,g, // we might be creating a bunch of controls, or // populating a big DataGridView. Whatever it is, // we don't want everyone looking at our biz. System.Threading.Thread.Sleep(2500); // (Here simulated...) // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ splash?.Dispose(); } } 

Ho impostato queste tre impostazioni di proprietà per il modulo:

 ShowInTaskbar = false ShowIcon = false WindowState = Minimized