closing all the window forms

This will close ALL of the forms, except the mainform (if it's already open). It also takes into account the possibility that the form that's currently running this code may NOT be the last form in the list.

int baseIndex = 0;
int thisFormIndex = -1;
// close all forms except the main one and this one
while (Application.OpenForms.Count > 1)
{
    if (Application.OpenForms[baseIndex] is MainForm || Application.OpenForms[baseIndex].Equals(this))
    {
        if (Application.OpenForms[baseIndex].Equals(this))
        {
            thisFormIndex = baseIndex;
        }
        baseIndex++;
    }
    else
    {
        Application.OpenForms[baseIndex].Close();
    }
    if (Application.OpenForms.Count == 2 && thisFormIndex >= 0)
    {
        break;
    }
}
if (thisFormIndex >= 0)
{
    Application.OpenForms[thisFormIndex].Close();
}

I typed this off the top of my head, so the code may need some tweaking, but you should have an idea of what I was going for.

In the end, this is a crap design, and the desired processing should actually be handled by a combination of semaphores and events so that each preceding form can determine on its own whether or not it should close based on how the child form it's monitoring closed.

EDIT ======================

You can open the main form by simply doing this:

mainForm form = new MainForm();
form.ShowDialog();

Your design still sucks. Read the last paragraph of my original answer. Read it as many times as it takes for you to understand it.

Check this out:

private void Button1_Click(System.Object sender, System.EventArgs e)
{
	for (int i = Application.OpenForms.Count - 1; i >= 0; i += -1)
		Application.OpenForms(i).Close();
}

If this is done by For...Each loop it raises InvalidoperationException that 'Collection was modified; enumeration operation may not execute.'

A little Linq anyone ?

1. if you know for a fact that all secondary forms are instances of the same base type ... we'll call this 'OtherForm' in this example:

List<OtherForm> otherFormList = Application.OpenForms.OfType<OtherForm>().ToList();

foreach(OtherForm othrFrm in otherFormList) othrFrm .Close();

The fact we projected the Application.OpenForms collection into a new List via Linq avoids the 'modifying collection' error.

2. Now, let's consider the case where there's many possible kinds of 'secondary forms' launched, and you want to close all but the form in whose code context you are currently running

List<Form> AllButThisForm = Application.OpenForms
    .OfType<Form>()
    .Where(frm => ! frm.Name.Contains(this.Name))
    .ToList<Form>();

foreach (Form othrFrm in AllButThisForm) othrFrm.Close();

Note that the test we apply in example #2 above assumes that the form we wish to remain open has a 'unique name,' and that the context in which we use the 'this' operator will return the name of the currently executing Form context.

In each case shown above, the "main form" is left open.