Showing a hidden form

How do i show a from that have been hidden using

this.Hide();

I have tried

MainMenuForm.Show();

and this just says i need an object ref. I then tried:

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

W开发者_Go百科hich seems to show the appropriate form. But when you exit the app, it is still held in memory because it hasn't shown the form that was hidden, instead it has shown a new version of the form. In effect having 2 instances of the form (one hidden, one visible).

Just to clarify, the MainMenuForm is the startup form. When (for example) Option 1 is clicked, the MainMenuForm then hides itself while opening up the Option 1 form. What i would like to know is how to i make the Option 1 form that the MainMenuForm opens "unhide" the MainMenuForm and then close itself.

What's the correct procedure here?

Thanks in advance.

---

When you do the following:

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

You are creating and showing a new instance of the MainMenuForm.

In order to show and hide an instance of the MainMenuForm you'll need to hold a reference to it. I.e. when I do compact framework apps, I have a static classes using the singleton pattern to ensure I only ever have one instance of a form at run time:

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

Now you can just use FormProvider.MainMenu.Show() to show the form and FormProvider.MainMenu.Hide() to hide the form.

The Singleton Pattern (thanks to Lazarus for the link) is a good way of managing forms in WinForms applications because it means you only create the form instance once. The first time the form is accessed through its respective property, the form is instantiated and stored in a private variable.

For example, the first time you use FormProvider.MainMenu, the private variable _mainMenu is instantiated. Any subsequent times you call FormProvider.MainMenu, _mainMenu is returned straight away without being instantiated again.

However, you don't have to store all your form classes in a static instance. You can just have the form as a property on the form that's controlling the MainMenu.

public partial class YourMainForm : Form
{
   private MainMenuForm _mainMenu = new MainMenuForm();

   protected void ShowForm()
   {
      _mainMenu.Show();
   }

   protected void HideForm()
   {
      _mainMenu.Hide();
   }
}

UPDATE:

Just read that MainMenuForm is your startup form. Implement a class similar to my singleton example above, and then change your code to the following in the Program.cs file of your application:

Application.Run(FormProvider.MainMenu);

You can then access the MainMenuForm from anywhere in your application through the FormProvider class.

---

The simplest and easiest way is to use LINQ and look into the Application.OpenForms property. I'm assuming you have only 1 instance of the form (hopefully!), otherwise make sure to have to have some public property on the hidden form to be able to differentiate it.

The following code will un-hide the form for you:

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

---

You need to keep a reference to the first form when it's created and then the code that holds that reference can call Show on it.

If you don't open that form from somewhere but it's set as the startup form, then you either need to change it so that you have a Main method that opens that form or you can have that form store a reference to itself somewhere that can be accessed from other places.

For example, an quick and ugly way would be to, add a public static property to your mainform and then when you hide the form it also writes this to that property which can then be retrieved when needed by other parts of the code.

---

Practically This works for me....

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

calling it through a button click event.

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

---

Store a reference to the form and call .Hide() and .Show() on that.

For example:

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

    public void btnShowMenuForm_Click(...)
    {
        _mainMenuForm.Show();
    }

    public void btnHideMenuForm_Click(...)
    {
        _mainMenuForm.Hide();
    }

    //etc
}

This example assumes you have a form which is launching the MainMenuForm.

---

Call the referenced form.

Like:

Calling parent
----------
public MyForm f {get;set;}

void DoStuff()
{
f = new MyForm();
f.Show();
}

MyForm
----------
void DoOtherStuff()
{
this.hide();
}

Parent
----------
void UnHideForm()
{
f.show();
}

---

Another simpler method to achieve this is to loop through the open forms to see which are still running and open it...

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