Microsoft & .NET.NETNew Windows Forms Capabilities in Visual Basic.Net

New Windows Forms Capabilities in Visual Basic.Net content and product recommendations are editorially independent. We may make money when you click on links to our partners. Learn More.

Tech Ed ended last Thursday, June 21st. Microsoft heralded its new implementation of Visual Studio.NET, the new C# (C-Sharp) programming language, and its continued commitment to the Visual Basic language.

On Tuesday, Bill Gates and Air Bixhorn demonstrated the revised donkey.bas game, originally written by Chairman Bill, in its new incarnation as ( will be available for download from Microsoft at, purportedly sometime the week of June 25th.) There was stark contrast between the two games. Donkey.bas, implemented in QBasic used ANSI characters for simple shape drawing, and demonstrated 3D graphics rendering, forced feedback game controls, shaped Windows Forms, and Web Services that implemented new characters, including Evil Bunny and Peg-leg Pirate.

In addition to the hysterical peg-leg pirate hopping up and down on a twenty foot screen and being run over by Chairman Bill, is the fact that all of the capabilities on display in the simple game were implemented with Visual Basic.NET. In this article, we will look at a couple of the new features supported by Windows Forms, including the new stay-on-top and Opacity capabilities implemented as properties.

Making a Form Stay On Top

Sometimes you want a modeless form to stay on top. An obvious means of bringing a form into the foreground is to show the form as a modal form, accomplished with the Form.ShowDialog method in VB.NET. But what if you want a form to stay on top in a modeless state? For example, you may have contrived a status that is tracking your application’s progress in the background and keeping the displayed status in the foreground.

To make something stay on top in VB.NET, all you have to do is set the TopMost property to True and the form will stay in the zero z-order position, even if the TopMost form does not have the focus. Because using the property is so simple, the code listing demonstrates a context in which you might actually use a TopMost form.

When I am building software, I like to use a Debug tool that allows me to write a log file and have a view of what’s going on while the program is running, a tracing mechanism if you will. This is convenient as you can run the program outside of the IDE and still have a practical log of what the application is doing; the technique described approximates using the EventLog, which is another good solution.

To demonstrate the TopMost property, we will assume that we have a requirement to have a debug view of our application, to be able to track what is happening behind the scenes. The sample application uses one form with a StatusBar. The StatusBar is used to track application status. The second form is the trace view, a form named DebugWindow. The DebugWindow is always in the foreground, so its TopMost property is set to True in the Properties window. (Figure 1 shows the application. Figure 2 shows the DebugWindow.)

Figure 1. An application.

Figure 2. A TopMost DebugWindow.

To simulate processing, each time the Broadcast Button is pressed the StatusBar is updated with the current date and time – simulating the deployed behavior of the application – and the right window (Figure 2) shows the Debug Window. Perhaps the Debug Window is only available during black-box testing to provide testers with a trace file. No matter what is happening on the main form (Form1), the DebugWindow form remains in the foreground.

To implement the trace view behavior, I defined an interface. The interface defines one method named OnListen. Every class that implements the interface must implement on listen. The second class is Broadcaster. Broadcaster is a Singleton, which means there is only one instance of the class. The Broadcaster keeps track of the listeners. Every class that implements the listener interface can be registered with the broadcaster. To send a message to all listeners, all any client needs to do is use the Broadcaster Singleton object and call the Broadcast method. To become a listener, all any client needs to do is implement the Listener interface and register with the Broadcaster as a Listener using the AddListener method. The complete code listing follows. Each portion of the listing is followed by a brief synopsis of the code.

Listing 1 demonstrates using an interface and the new TopMost property in VB.NET to implement a trace window.

Public Class Form1  Inherits System.Windows.Forms.Form  Implements IListener[ Windows Form Designer generated code ]  Private Sub OnListen(ByVal Text As String) Implements IListener.OnListen    StatusBar1.Text = Text  End Sub    Private Sub Button1_Click(ByVal sender As System.Object, _                            ByVal e As System.EventArgs) _                            Handles Button1.Click    Broadcaster.Broadcast(Now)  End Sub    Private Sub Form1_Load(ByVal sender As System.Object, _                         ByVal e As System.EventArgs) _                         Handles MyBase.Load    Broadcaster.AddListener(Me)    DebugWindow.ShowWindow()  End SubEnd Class

Form1 is a subclass from System.Windows.Forms.Form and implements the IListener interface. The Sub OnListen demonstrates how to implement interface methods in VB.NET. The line [ Windows Form Designer generated code ] represents the code outlining capability of Visual Studio.Net.

Public Class DebugWindow  Inherits System.Windows.Forms.Form  Implements IListener[ Windows Form Designer generated code ]  Shared Sub ShowWindow()     Dim Form As New DebugWindow()    Form.Show()  End Sub    Private Sub Add(ByVal Text As String)   TextBox1.Text = Text & vbCrLf & TextBox1.Text  End Sub  Private Sub OnListen(ByVal Text As String) _                           Implements IListener.OnListen     Add(Text)  End Sub      Private Sub DebugWindow_Load(ByVal sender As System.Object, _                                 ByVal e As System.EventArgs) _                                 Handles MyBase.Load    TextBox1.Text = vbNullString    Broadcaster.AddListener(Me)  End Sub    Protected Overrides Sub Finalize()    Broadcaster.RemoveListener(Me)    MyBase.Finalize()  End SubEnd Class

The DebugWindow form represents the trace window. If you were to expand the collapsed generated code you would find Me.TopMost = True in the InitializeComponent method. DebugWindow.vb also inherits from Form and implements IListener. The Shared method creates an instance of the Debug Window and shows the form. (This is a convenient technique to avoid writing the same code to create and show the form.) Form1 calls the DebugWindow.ShowWindow method in Form1’s OnLoad event, but you could easily turn this feature on and off. When the OnListen method of DebugWindow is called by the Broadcaster, the text is added to the top of the Multiline textbox. When DebugWindow is Finalized, the form is removed from the list of Broadcast recipients.

Public Interface IListener  Sub OnListen(ByVal Text As String)End Interface  Public Class BroadcasterClass  Private FListeners As New Collection()  Sub Broadcast(ByVal Text As String)    Dim Listener As IListener    For Each Listener In FListeners      Listener.OnListen(Text)    Next  End Sub  Sub AddListener(ByVal Listener As IListener)    FListeners.Add(Listener)  End Sub    Sub RemoveListener(ByVal Listener As IListener)    Dim I As Integer    For I = 1 To FListeners.Count      If (FListeners(I).Equals(Listener)) Then        FListeners.Remove(I)        Exit For      End If    Next  End SubEnd ClassPublic Module Factory  Public Function Broadcaster() As BroadcasterClass    Static FBroadcaster As BroadcasterClass    If (FBroadcaster Is Nothing) Then      FBroadcaster = New BroadcasterClass()    End If    Return FBroadcaster  End FunctionEnd Module

The Listener.vb file actually contains three elements: the IListener interface, the BroadcasterClass class, and the Factory module that creates only one instance of a Broadcaster on demand. IListener declares only one method, OnListen. All IListeners must implement OnListen. The Factory module declares a Static BroadcasterClass. The first time the Broadcaster function is called, FBroadcaster is Nothing and the object is created; on each subsequent call, the local, Static object is returned. The BroadcasterClass defines three methods: AddListener, RemoveListener, and Broadcast, as well as a Collection of Listeners. When an object implements IListener, all it has to do to receive messages is to call Broadcaster.AddListener(Me), passing a reference to self to the AddListener method. To stop listening, the Listener simply calls Broadcaster.RemoveListener(Me). Each time any code calls Broadcaster.Broadcast(string), every Listener is notified of the broadcast message.

Using an interface to define a broadcaster and listeners allows you to write more loosely coupled code. Notice that none of the listeners is referring to a specific object, neither are any of the listeners referring to any of the controls on those objects. You could devise a listener that updated a database, or use some new control to display status on the main form. In both cases, you would not have to change any of the existing code between the forms and broadcaster.

An alternate scenario for using TopMost is to create a Splash screen. If you show a Splash screen as a modal dialog, then your splash screen has to perform initialization of your application. But such a use for a splash screen is counterintuitive. With the TopMost property, you can display the splash form as a modeless form and initialize your application using some other, more appropriate object.

Using Opacity to Create Form Affects

The Opacity property of a Form works very simply. If Opacity is 0, then the object, usually a form, is transparent. If the Opacity is 1, representing 100% or Opaque, then the form is not transparent. You might use the Opacity property to fade in a splash form. Each tick of a timer control will increase the Opacity of the splash form until it is 100%. (Unfortunately, I cannot show you the form fading in. Using Alt+Print Screen shows the form as 100% opaque and Collage Complete was unable to capture the form until it was Opaque.)

The code sample is quite straightforward. Add an enabled timer to the Splash form and have the timer increase the Opacity until it is greater than or equal to 100%

Private Sub Timer1_Tick(ByVal sender As System.Object, _  ByVal e As System.EventArgs) Handles Timer1.Tick    Opacity += 0.02    If (Opacity >= 1) Then Close()  End Sub

Alternatively you could use a Thread and have the thread increase the Opacity a little and sleep a little until the Opacity is 100%. The Threaded version follows.

Public Sub FadeIn()  While (Opacity < 1)    Opacity += 0.02    Sleep(175)    Text = “Thread: ” & Opacity  End WhileEnd Sub

To create and use the Threaded version, create an instance of a Thread and pass it the Address of the FadeIn method as follows.

Dim Splash As New FormSplash()Splash.Opacity = 0Dim Thread As New Threading.Thread(AddressOf Splash.FadeIn)Splash.Show()Thread.Start()

The listing creates a Thread passing the AddressOf SplashForm.FadeIn. The form is shown, and the thread is started.

Finally, at Tech Ed, Microsoft presenters stated that Windows Forms are not Thread-safe. I am still experimenting with Threads and forms. The multithreaded version of the fade-in form seems to work okay, but further experimentation and information might be necessary to determine how reliable code like the preceding will work in VB.NET. In the meantime, the Timer version seems to work reasonably well.

About the Author

Paul Kimmel is a freelance writer for and He is the founder of Software Conceptions, Inc, founded in 1990. Kimmel performs contract software development services in North America and can be contacted at

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

Related Stories