Montrer une forme cachée

Lorsque vous procédez comme suit:

 MainMenuForm frmMainMenu = new MainMenuForm(); frmMainMenu.Show(); 

Vous créez et affichez une nouvelle instance de MainMenuForm.

Afin d’afficher et de masquer une instance de MainMenuForm, vous devez y faire référence. C’est-à-dire que lorsque je crée des applications-cadre compactes, j’ai des classes statiques utilisant le modèle singleton pour m’assurer de n’avoir qu’une seule instance d’un formulaire au moment de l’exécution:

 public class FormProvider { public static MainMenuForm MainMenu { get { if (_mainMenu == null) { _mainMenu = new MainMenuForm(); } return _mainMenu; } } private static MainMenuForm _mainMenu; } 

Maintenant, vous pouvez simplement utiliser FormProvider.MainMenu.Show() pour afficher le formulaire et FormProvider.MainMenu.Hide() pour masquer le formulaire.

Le modèle Singleton (merci à Lazarus pour le lien) est un bon moyen de gérer les formulaires dans les applications WinForms, car cela signifie que vous ne créez l’instance de formulaire qu’une seule fois. Lors du premier access au formulaire via sa propriété respective, il est instancié et stocké dans une variable privée.

Par exemple, la première fois que vous utilisez FormProvider.MainMenu , la variable privée _mainMenu est instanciée. Toutes les fois que vous appelez FormProvider.MainMenu , _mainMenu est renvoyé immédiatement sans être instancié à nouveau.

Cependant, vous n’avez pas besoin de stocker toutes vos classes de formulaire dans une instance statique. Vous pouvez simplement avoir le formulaire en tant que propriété sur le formulaire qui contrôle le MainMenu.

 public partial class YourMainForm : Form { private MainMenuForm _mainMenu = new MainMenuForm(); protected void ShowForm() { _mainMenu.Show(); } protected void HideForm() { _mainMenu.Hide(); } } 

METTRE À JOUR:

Il suffit de lire que MainMenuForm est votre formulaire de démarrage. Implémentez une classe similaire à mon exemple singleton ci-dessus, puis modifiez votre code comme suit dans le fichier Program.cs de votre application:

 Application.Run(FormProvider.MainMenu); 

Vous pouvez ensuite accéder à MainMenuForm partir de n’importe où dans votre application via la classe FormProvider .

Le moyen le plus simple et le plus simple consiste à utiliser LINQ et à examiner la propriété Application.OpenForms . Je suppose que vous n’avez qu’une seule instance du formulaire (j’espère!), Sinon assurez-vous d’avoir une propriété publique sur le formulaire masqué pour pouvoir le différencier.

Le code suivant débloquera le formulaire pour vous:

 var formToShow = Application.OpenForms.Cast
() .FirstOrDefault(c => c is MainMenuForm); if (formToShow != null) { formToShow.Show(); } 

Vous devez conserver une référence au premier formulaire lors de sa création pour que le code contenant cette référence puisse appeler Show .

Si vous n’ouvrez pas ce formulaire quelque part mais qu’il est défini comme formulaire de démarrage, vous devez le modifier afin d’avoir une méthode Main qui ouvre ce formulaire ou vous pouvez demander à ce formulaire de stocker une référence à lui-même qui peut être accessible depuis d’autres endroits.

Par exemple, une façon rapide et laide serait d’append une propriété statique publique à votre mainform puis, lorsque vous masquez le formulaire, il écrit également this propriété dans cette propriété, qui peut ensuite être récupérée si d’autres parties du code le nécessitent.

Pratiquement cela fonctionne pour moi ….

 public class MainWindow : Form { Form _mainMenuForm = new MainMenuForm(); } 

en l’appelant via un événement de clic de bouton.

 private void buttonclick() { if (_mainMenuForm.Visible) { _mainMenuForm.Visible = false; } else { _mainMenuForm.Visible = true; } } 

Stockez une référence au formulaire et appelez .Hide () et .Show () à ce sujet.

Par exemple:

 public class MainWindow : Form { private Form _mainMenuForm = new MainMenuForm(); public void btnShowMenuForm_Click(...) { _mainMenuForm.Show(); } public void btnHideMenuForm_Click(...) { _mainMenuForm.Hide(); } //etc } 

Cet exemple suppose que vous avez un formulaire qui lance MainMenuForm.

Appelez le formulaire référencé.

Comme:

 Calling parent ---------- public MyForm f {get;set;} void DoStuff() { f = new MyForm(); f.Show(); } MyForm ---------- void DoOtherStuff() { this.hide(); } Parent ---------- void UnHideForm() { f.show(); } 

Une autre méthode plus simple consiste à parcourir les formulaires ouverts pour voir ceux qui sont toujours en cours d’exécution et à les ouvrir …

 foreach (Form oForm in Application.OpenForms) { if (oForm is MainMenuForm) { oForm.Show(); break; } }