Les meilleures pratiques pour le multi-forme d'applications pour afficher et masquer les formes?

Je suis en répondant d'une manière générale ici.

Je ne pense pas que le pattern singleton irait bien avec la forme de gestion. En règle générale, vous souhaitez passer quelques paramètre de contexte pour la forme, et vous pouvez ouvrir plusieurs instances de la même forme. Donc un singleton n'est pas appropriée OMI.

Je pense que la gestion des formulaires devrait être simple.

Par exemple, si vous souhaitez afficher un formulaire modal à partir d'un autre formulaire, je voudrais écrire quelque chose de vraiment simple:

private void button1_Click(object sender, EventArgs e)
{
    using (ModalForm1 frm = new ModalForm1(myParam))
    {
        frm.ShowDialog();

        if (frm.MyResultProperty == ...)
        {
            //Do some job here
        }
    }
}

Bien sûr, vous pourriez écrire une partie de l'interface/les génériques de syntaxe pour éviter un peu de la duplication de code dans le cas où vous souhaitez afficher un grand nombre de formulaires modaux:

public interface IFormResult<T>
{
    T Result { get; set; }
}

public class ModalForm1 : Form, IFormResult<string>
{
    public ModalForm1()
    {
        InitializeComponent();

        this.Result = "My result";
    }

    public string Result { get; set; }
}

private void button1_Click(object sender, EventArgs e)
{
    string res = ShowModalForm<ModalForm1, string>();
}

private static T2 ShowModalForm<T1, T2>()
    where T1 : Form, IFormResult<T2>, new()
{
    using (T1 form = new T1())
    {
        form.ShowDialog();

        return form.Result;
    }
}

Mais honnêtement, j'ai l'impression que c'est un peu overingeneered.

Deuxième point: si votre formulaire n'est pas exactement suit ce comportement spécifique (ShowDialog() puis un Result propriété est définie), alors vous devez écrire une autre Interface...etc.

Si ce type de syntaxe (génériques, interfaces, etc...) ne pas réduire le nombre de lignes de code écrites OU de la complexité OU de la maintenabilité (et évidemment nous ne pouvons pas dire que c'est vraiment le cas ici), alors il est assez inutile de l'OMI.

---

Edit:

Forme de gestion dépend vraiment de votre cas d'utilisation.

• Si vous avez disons 20 formes qui peuvent être affichés en même temps, alors vous devriez penser à un FormManager concept (ou mieux: réfléchir sur la façon d'améliorer l'expérience de l'utilisateur en réduisant le nombre de possible ouvert formes)
• Si vous avez quelque chose de relativement simple (2-3 non modale des formes en même temps, + 3-4 possible formulaires modaux), je ne voudrais pas écrire de code complexe à gérer ces formes.

Généralement, la forme qui est utilisée pour démarrer l'application (c'est à dire la forme que s'arrête le programme lors de la fermeture, qui est la forme qui est un paramètre de Application.Run()) est responsable d'autres formes. Vous avez un formulaire principal, et des multiples formes d'enfants. Si votre cas est très différent, il n'y a probablement quelque chose de plus intelligent à écrire, mais ça dépend de votre cas. Je ne pense pas que l'on peut fournir une bonne réponse à la problématique générale de la gestion des formulaires.

Honnêtement, si vous voulez quelque chose de vraiment facile à gérer, essayez de les réduire (autant que possible) le nombre de formulaires qui peuvent être affichées en même temps. Plusieurs affiché non modale des formes en même temps ne pas offrir une bonne expérience de l'utilisateur dans la plupart des cas, et de la forme de gestion du cycle de vie peut être problématique si les formes sont dépendantes les unes des autres.

OriginalL'auteur ken2k

- Je utiliser cette astuce. Disons form1 est la principale forme:

private void button1_Click(object sender, EventArgs e)
{
     LoadForm(new Form2());
}

private void LoadForm(Form frm)
{
    frm.FormClosed += new FormClosedEventHandler(frm_FormClosed);
    this.Hide();
    //Here you can set a bunch of properties, apply skins, save logs...
    //before you show any form
    frm.Show();
}

void frm_FormClosed(object sender, FormClosedEventArgs e)
{
    this.Show();
}

Donc; lorsque vous ouvrez un formulaire fermée (à l'exception de form1), form1 réapparaîtra à nouveau.

Mise à jour

using (Form2 frm = new Form2())
{
    if (frm.ShowDialog() = DialogResult.ok)
    {
        //Do some things...
    }
}

Dans ce cas, il n'est pas besoin de cacher forme précédente.

OriginalL'auteur Amen Ayach

public partial class Form1 : Form
{
    private static Form1 inst;
    public static Form1 GetForm
    {
        get
        {
            if (inst == null || inst.IsDisposed)
            {
                inst = new Form1();
            }
            return inst;
        }
    }
    public Form1()
    {
        InitializeComponent();
        inst = this;
    }

    private void button1_Click(object sender, EventArgs e)
    {
        Form2.GetForm.Show();
        this.Hide();
    }
}

---

public partial class Form2 : Form
{
    private static Form2 inst;
    public static Form2 GetForm
    {
        get
        {
            if (inst == null || inst.IsDisposed)
                inst = new Form2();
            return inst;
        }
    }
    public Form2()
    {
        InitializeComponent();
    }
    private void button1_Click(object sender, EventArgs e)
    {
        Form1.GetForm.Show();
        this.Hide();
    }
    private void Form2_FormClosed(object sender, FormClosedEventArgs e)
    {
        Form1.GetForm.Show();
    }
}

si vous avez plus de deux formulaire, puis créer un autre formulaire comme From2

OriginalL'auteur Jagdish