Any repercussions to shorthand dialog display?

Question

Hi all,

Anyone who's done any UI work in .Net is very familiar with this type of code:

TestForm frm = new TestForm();
frm.ShowDialog();

Earlier today i found myself wishing that a call to show a modal dialog was a little less verbose, more like a static call, and figured out that all i really need, in a simple case, is something like this:

new TestForm().ShowDialog();

Am i missing anything? Could there be any repercussions from this kind of shorthand? E.g. windows messages not handled/routed correctly etc.?

Was working on this when i saw Ray's feedback:

i suppose an even shorter way would be to create a static member withing TestForm that creates an instance of itself and calls ShowDialog internally. So, this code:

public static DialogResult DoModal()
{
    return new TestForm().ShowDialog();
}

could be invoked thusly:

TestForm.DoModal();

Is this what you're talking about Ray? It's static, but does it fit the factory paradigm?

Answer 1

If you don't want to reuse the form object anywhere in your code you can just use the short form

new TestForm().ShowDialog();

If you want to do something later with that object then you must assign it to a variable.

Answer 2

Pretty simple. Hide form constructor (make it private), then add static factory method that would initialize new instance of the form and show it straight away.

For example see MessageBox source codes (Mono, if I'm not mistaken) link

Answer 3

Typical use of ShowDialog should look like this:

using (Form form = new Form())
{
    // here setup your form instance

    if (DialogResult.OK == form.ShowDialog())
    {
        // here read data from form instance
    }
}

Please be aware that ShowDialog() causes form instance to not dispose itself. You should dispose it manually once you are done with it - hence using clause See http://msdn.microsoft.com/en-us/library/w61zzfwe.aspx for details. In your scenario this should look like below:

public static DialogResult DoModal()
{
    using (Form form = new TestForm())
        return form.ShowDialog();
}

But this is useful only when you don't need to read any data back from your form instance. So the only scenario that fits here is message box. MessageBox.Show(...) methods utilize pattern you want to implement in your post.

in other scenarios forms are supposed to return data other than DialogResult back to application after they are closed. And that's why standard Form does not have static ShowDialog() or DoModal() methods. Static method should dispose temporal form instance. Such disposal would make impossible to read data back from form. What is more, in static method scenario there is no form instance to read data back from.

Putting all together, your method, to be compliant with guidelines, should look more like:

public static YourResultClass DoModal()
{
    using (TestForm form = new TestForm())
    if (DislogResult.OK == form.ShowDialog())
    {
        YourResultClass result = new YourResultClass();
        // Here initialize YourResultClass instance with data from form instance
        return result;
    }
}

But that is very use case specific and quite far from your one-liner utility method.