提高窗体载入速度(转载)

Improving Microsoft .NET Compact Framework-based Application Form Load Performance

Neil Cowburn
Content Master Ltd

March 2002

Applies to:
    Microsoft® .NET Compact Framework 1.0
    Microsoft Visual Studio® .NET 2003

Summary: Learn how to reduce the time it takes for your .NET Compact Framework Windows Forms applications to load by following some simple optimization techniques. (4 printed pages)

Contents

Introduction
Measuring Performance
Reduce the Number of Method Calls
Create the Controls Top-down
More Information

Introduction

The default Forms Designer generated code does not always create the most optimized code for creating Microsoft® Windows® Forms. However, there are a number of things you can do to optimize the generated code. By writing your own form initialization code, you can improve form load performance.

Also, by re-arranging and/or rewriting the code generated by the Forms Designer in Microsoft Visual Studio® .NET, the overall form load performance of your applications can be greatly improved.

CAUTION   Do not use the Designer after modifying InitializeComponent.

The InitializeComponent method has a comment preceding it, warning you not to modify the code. By modifying the code in the InitializeComponent method, you can no longer use the Forms Designer. If you do, your modifications will be lost. You should only perform these optimizations as the final stage of development, after all the design work has been done.

This article assumes you have a working knowledge of the Microsoft .NET Compact Framework and Microsoft Visual C#® .NET, and that you have installed Visual Studio .NET 2003.

Measuring Performance

To measure the performance of your form initialization code, you can use a simple test to measure how long it takes to initialize the controls in a form. By recording the system timer's tick count before and after making the call to the InitializeComponent method, you can record how long it takes to initialize the controls on the form. For this, you can use the Environment.TickCount property:

// Form constructor
public Form1()
{
    uint startTickCount, endTickCount, timeTaken;
    // Call GetTickCount to get the starting tick count
    startTickCount = Environment.TickCount;
    // Initialize the controls on the form
    InitializeComponent();
    // Call GetTickCount again to get the end tick count
    endTickCount = Environment.TickCount;
    // Calculate the time taken (in ms) to initialize the controls
    timeTaken = startTickCount – endTickCount;
    // Display the time taken in a message box
    MessageBox.Show("Load Time: " + timeTaken.ToString() + "ms");
}

Reduce the Number of Method Calls

One of the ways in which you can improve the performance of loading a form is by reducing the number of method calls made during form initialization. For example, the code generated by the Forms Designer for setting the location and size of a control uses two method calls for setting these properties, like this:

    this.textBox1.Location = new Point(10,20);
    this.textBox1.Size = new Size(72,23);

This can be consolidated into a single method call by using the Bounds property:

    this.textBox1.Bounds = new Rectangle(10,20,72,23);

To show the performance gains that are possible, consider a form which contains 1 MenuBar, 1 TabControl control, 5 TabPages each containing 7 Labels, 7 Buttons and 7 TextBoxes. That's a total of 112 controls. This application was built using the Release profile and deployed to the Pocket PC 2002 emulator, where it was run 5 times. When the method call optimization described above is applied, a performance improvement of nearly 9% over the Forms Designer generated code is achieved.

Create the Controls Top-down

Another method for improving performance is to initialize the controls in the control tree top-down. For example, if you have a panel control with many controls in it, create the panel first, and then add the controls to the panel. Also, setting the parent property of the control instead of adding to the Controls collection can improve performance. For example, consider adding a textbox to a panel's control collection:

// Before optimization
// Create a new panel and textbox control
Panel panel1 = new Panel();
TextBox textBox1 = new TextBox();
// Set the Text property of the TextBox control
textBox1.Text = "My Text";
// Add the TextBox to the Panel's control collection
panel1.Controls.Add(this.textBox1);
// Add the Panel to the Form's control collection
this.Controls.Add(panel1);
... // Add subsequent controls here

Optimizing this code snippet using the top-down and parenting techniques results in the following snippet:

// After optimization
// Create a new panel and textbox control
Panel panel1 = new Panel();
TextBox textBox1 = new TextBox();
// Parent the Panel to the current Form
this.panel1.Parent = this;
// Parent the TextBox to the Panel
this.textBox1.Parent(this.panel1);
// Set the Text property of the TextBox control
textBox1.Text = "My Text";
... // Add subsequent controls here

Together these can make a big difference with a deeply nested control hierarchy.

Optimizing the code in the InitializeComponent method by creating the controls top-down and re-parenting them resulted in a performance improvement of over 49% over the default Forms Designer generated code.

Combining method call optimization with the top-down control initialization technique gave an overall performance boost of approximately 55% over the Forms Designer generated code. This is an incredible improvement and if you want to boost the form loading performance of your application, it is worthwhile making these optimizations to your code.