DoEvents Public Static Methods Exit in Visual C#

Paint Data Matrix in Visual C# DoEvents Public Static Methods Exit

Program execution Before we leave this section, let s review what we ve learned about how our program executes within the operating system. Run the MyForm.exe program again to see this in action. When you execute this program, the Windows operating system creates and initializes a process that: 1 Uses the Main method as the entry point for execution, which: a Instantiates an instance of the class MyForm using the new keyword, which b Invokes the instance constructor for MyForm, which c Assigns the string Hello Form to the title bar. 2 Back in our Main method, the Application.Run method is called with the newly created MyForm object as a parameter, and: a Displays MyForm as the application window, and b Waits for and processes any messages or user interactions that occur. 3 When the application window closes: a The Application.Run method returns, and b The Main method returns, and c The program exits. And that is how it is done in the world of .NET.

Let s make our program a little more interesting by adding some controls. Throughout the course of the book, we will be building a photo viewing application, so let s add a button for loading an image file, and a box where the image can be displayed. When we are done, our form will look like figure 1.3.

Revise your code as shown in listing 1.2. Changes from our previous code listing are shown in bold. Note that we have changed the version number of our program to 1.2 ADDING CONTROLS 13

to distinguish it from our original code and to match the current section. This new version number is also displayed on the title bar. In chapter 2 we will see how to obtain the application s version number programmatically. For now, changing it by hand will do just fine.

[assembly: System.Reflection.AssemblyVersion("1.2")] namespace MyNamespace { using System; using System.Windows.Forms; public class MyForm : Form { private Button btnLoad; private PictureBox pboxPhoto; public MyForm() { this.Text = "Hello Form 1.2"; // Create and configure the Button btnLoad = new Button(); btnLoad.Text = "&Load"; btnLoad.Left = 10; btnLoad.Top = 10; // Create and configure the PictureBox pboxPhoto = new PictureBox(); pboxPhoto.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D; pboxPhoto.Width = this.Width / 2; pboxPhoto.Height = this.Height / 2; pboxPhoto.Left = (this.Width - pboxPhoto.Width) / 2; pboxPhoto.Top = (this.Height - pboxPhoto.Height) / 2; // Add our new controls to the Form this.Controls.Add(btnLoad); this.Controls.Add(pboxPhoto); } public static void Main() { Application.Run(new MyForm()); } } }

Compile this program as before and run it to see our changes. We will walk through these changes one at a time.

Shortcuts and fully qualified names The first change you may notice in our new code is the using keyword at the beginning of the program.

using System; using System.Windows.Forms;

Programmers are always looking for shortcuts; and older programmers, some would say more experienced programmers, often worry that their lines may be too long for the compiler or printer to handle. The programmers at Microsoft are no exception, so while one team probably agreed that fully-qualified names are a good idea, another team probably sought a way to avoid typing them. The result is the using keyword. The using keyword actually plays two roles in C#. The first is as a directive for specifying a shortcut, as we are about to discuss. The second is as a statement for ensuring that non-memory resources are properly disposed of. We will discuss the using keyword as a statement in chapter 6. As a directive, using declares a namespace or alias that will be used in the current file. Do not confuse this with include files found in C and C++. Include files are not needed in C# since the assembly incorporates all of this information, making the /reference switch to the compiler sufficient in this regard. This really is just a shortcut mechanism. In our original program in section 1.1, the Main function called the method System.Windows.Forms.Application.Run. In our new listing the using directive allows us to shorten this call to Application.Run. The long form is called the fully qualified name since the entire namespace is specified. Imagine if you had to use the fully qualified name throughout your code. Aside from tired fingers, you would have long, cluttered lines of code. As a result, our new code is a bit easier to read:

public static void Main() { Application.Run(new MyForm()); }

Since Application is not a C# keyword or a globally available class, the compiler searches the System and System.Windows.Forms namespaces specified by the using directive in order to locate the System.Windows.Forms.Application class. You can also specify an alias with the using keyword to create a more convenient representation of a namespace or class. For example,