Would it be possible to put some logic into the form's themselves, to see if an instance is already running?



I.e. before the InitializeComponents is called in the constructor, check if the form is already instantiated. Maybe use a shared property to note if the form has been instantiated yet (and hold a reference to the instantiated form). Or maybe use a shared factory method to create the form instead of using New.



Not sure if this is feasible or if there is any way to cancel the instantiation of a form and instead return a reference to an existing instance, but I seem to recall reading about the Singleton pattern and doing it something like this.

You can do that, but you first need to have a centralized collection that can be referenced.  You are actually better off doing this outside of the instantiaion for one primary reason...speed and maintainability...OK, that is two reasons   We created a shared class called MenuSystem which houses all of our instantiation logic.  Security, form collections, multiple-instances, and whether the form will appear in the MDI window or on its own, all within one central location.  Ours had to be a bit more specialized since it can launch VFP forms or .NET forms.  But the logic is basically the same.

You could even create a class that is passed to the MenuSystem that has all of the logic that you need that you could pass over....or just create a bunch of overloads to do this for you.  It is just up to you, but the key is creating a class that launches all of your forms according to your environment and needs.

Public Notineritable Class MenuSystem

Private Shared _MenuMdiClient As MDIClient
Private Shared _Forms As New System.Collections.Generics.List(Of SYstem.Windows.Forms.Form)

'-- Reference to the MDI client to which all client forms will be added.  Be sure to set this in your
'    New of the parent that houses the MDI client.
Public SHared Property MenuMdiClient As MDIClient
    Get
        Return _MenuMdiClient
    End Get
    Set(Byval value as MdiClient)
        _MenuMdiClient = value
    End Set
End Property

'-- This collection contains all of the forms that are loaded
Public Shared Readonly Property Forms As System.Collections.Generics.List(Of System.Windows.Forms.Form)
    Get
         Return _Forms
    End Get
End Property

'-- Central method to load all of the
Public Shared Sub LaunchForm(ByVal FormType As System.Type, Byval SecurityKey As String, Byval SingleInstance As Boolean)
    '-- Establish Locals
    Dim loForm As System.WIndows.Forms.Form

    If SecurityBasics.CurrentUser.GetPermission(SecurityKey).Action = Grant Then
       '-- Check for a single instance
       If SingleInstance AndAlso FormIsRunning(FormType) Then
            Exit Sub
       End If

       '-- Create and launch the form
        loForm = CType(Activator.CreateInstance(FormType), System.WIndows.Forms.Form)
        loForm.MdiParent = _MenuMdiClient

        '-- Create a handler so it can remove itself from the collection
        AddHandler loForm.FormClosed, Addressof HandleFormClosed

        loForm.Show()
    End If

   Private Shared Function FormIsRunning(Byval FormType As System.Type) As Boolean
     Dim llReturn As Boolean = False

      For Each loForm As Form In _Forms
         If loForm.GetType() Is FormType Then
             llReturn = True
             Exit For
         End If
      Next

      Return llReturn
    End Function

    Private Shared Sub HandleFormClosed(Byval sender as Object, Byval e as System.EventArgs)
         _Forms.Remove(CType(sender, Form))
    End Sub

End Class

This is why StrataFrame ROCKS!



Thanks Trent! This really (finally) clears up what you've mentioned a bunch of times in different posts about how to handle opening forms in an Application. I really appreciate it.

No problem   I just typed this out in the post and did not bring it in from code, so if you have an issue with what I posted let me know.  But it should at least get you most of the way there.