Windows forms c tutorial

Windows Forms (or simply forms) are the windows you see in a Windows Application. You can create multiple forms in a single application. Each form inherits the properties and methods of the System.Windows.Forms.Form class. The namespace System.Windows.Forms contains components you will need for creating forms and controls.

The following are the parts of a typical windows form.

Картинка с сайта: compitionpoint.com

At the top, you will find the Caption Bar. The Caption Bar is composed of the icon, the caption, and the control box. The control box contains buttons such as   minimizing, maximizing, closing, or a help button. The Client Area is where we   add the controls. The border or frame, which includes the caption bar,encloses   the client area and allows you to resize the form.

The following are some of the useful properties of the Form base class.

Figure 1

Figure 2 shows some useful methods of the Form class.

Figure 2

Figure 3 shows the available events for the form.

Figure 3

The Form class is a child of the System.Windows.Forms.Control base class so the methods and properties from the Control class are also available in the Form class.

Modifying the Control Box

We use the ControlBox property to hide or show the Control Box. This is useful when you are planning to disable minimizing or   maximizing of control or you want to only close the form through the code. The image   below shows you how the form will look when you set  ControlBox property to false.

If you want to disable only the minimize or the maximize button, then you can use the MinimizeBox and  MaximizeBox and set them to false.

The form above has its minimize and maximize box hidden. Unfortunately, you cannot hide only the close button.

Changing Form’s Border Style

We can change the border style of the form. For example, let’s say you don’t want   the user to be able to resize the form The default border of the form allow a   user to do that. We can set the FormBorderStyle   property to different values of the  System.Windows.Forms.FormBorderStyle Enumeration.

The following are screenshots of forms using different FormBorderStyle.

None

FixedSingle

Fixed3D

FixedDialog

Sizable

FixedToolWindow

SizableToolWindow

Form Icons

We use the Icon property to change the icon displayed at the upper left side of the form. Click the browse button next the   Icon property in the Properties Window and find the .ico file which is the file extension for an icon image. The ShowIcon property   allows you to hide or show the icon in the caption bar.

Accept and Cancel Buttons

You can add a button control to the form and set them as either an Accept or a   Cancel button. You do that using the AcceptButton and CancelButton properties. If a button is an accept button, whenever the user hits Enter while the form is active, that   button’s Clickevent will be executed. The Cancel   button is activated whenever the Escape key is pressed. Just go to the   Properties Window, find the desired property and click the drop down button. You   will be presented with the names of all the button control in the form. Choose   the desired button. For example, suppose you are creating a login form. You can   set the button used for logging in as the Accept button. This way, the user can simply press Enter when he is finished typing the password.

There are many more to discover on windows forms and they will be discussed in   later lessons.

Windows Forms is a framework available in Visual Studio that allows you to build desktop applications with the assistance of a graphical user interface. This allows you to click and drag widgets such as buttons or labels directly onto a canvas, and manipulate the properties of each widget such as its font-size, color or border.

In this article, a simple Celsius to Fahrenheit Converter will be used as an example to go through the basics of how to set up a Windows Form Application. Visual Studio 2019 Community Edition is the edition used for this tutorial.

How to Create the Windows Forms Project in Visual Studio

First, create the project in Visual Studio.

1. Open Visual Studio and select Create a New Project.
2. Visual Studio will provide you with a list of project templates you can choose from.
3. To create a Windows Forms Application, search for Windows Form App and select it from the list of templates. Once this is selected, click on Next.
   

   Картинка с сайта: www.makeuseof.com

   If the Windows Form App option is not available on the list, modify your installed version of Visual Studio. In Visual Studio Installer, add the .NET desktop development workload for Desktop and Mobile, and re-launch Visual Studio.

4. Add a name and location for the project, and click on Next. The location is the directory where the code files will be stored.
   

   Картинка с сайта: www.makeuseof.com

5. On the next screen, keep the default selection of .NET Core 3.1.
6. Click Create.
   

   Картинка с сайта: www.makeuseof.com

7. Once Visual Studio has finished creating the project, the project will open.
   

   Картинка с сайта: www.makeuseof.com

How to Add Elements to the Project Canvas

The canvas is the white area located at the top-left of the screen. Click and drag the points on the bottom, right, or bottom-right of the canvas to resize it if needed.

To create the UI of the application, add widgets such as buttons or text boxes onto the canvas.

1. Open the View Tab at the top of the window, and select Toolbox.
   

   Картинка с сайта: www.makeuseof.com

2. This will add a toolbox to the left side of the application. Select the pin icon in the top-right of the toolbox to pin it there permanently.
3. This is where you can drag any widget from the toolbox onto the canvas. Highlight a button from the toolbox, and drag it onto the canvas.
   

   Картинка с сайта: www.makeuseof.com

4. Drag two more text boxes onto the canvas, along with three labels (two labels for each text box, and one label for the title at the top of the application).
   

   Картинка с сайта: www.makeuseof.com

5. Every widget on the canvas has properties associated with them. Highlight a widget to display the Properties window in the bottom-right of Visual Studio, which lists all the properties that widget has. These properties can include the text, name, font size, border, or alignment of the highlighted widget.
6. At the moment, the text on these widgets still say label1, label2, or button1. Select the label1 widget and edit the Text property in the properties window to say «Celsius to Fahrenheit». Change the font size to be 22pt.
   

   Картинка с сайта: www.makeuseof.com

7. Similarly, edit the properties of the other widgets on the canvas to be the following:

   Widget	Property	New Value
   label2	Text	Celsius
   label3	Text	Fahrenheit
   button	Text	Calculate
   Fahrenheit text box	ReadOnly	True

How to Handle Events and Write Code in the Code-Behind

Widgets on the canvas can be tied to events. Events can include things like clicking on a button, changing the text inside a text box, or selecting a particular radio button. When these events happen, it can cause a section of code in the Code-Behind to trigger.

C# is the language used when creating Windows Forms. If you haven’t already used C#, there are many practical reasons to learn C# programming.

For this particular application, add an event to the Calculate button, to trigger a section of code to run when this button is pressed.

1. Double-click the Calculate button to automatically open Form1.cs with a new Event method:

           private void calculateButton_Click(object sender, EventArgs e)
       

2. This is where you will add the code that will perform the Celsius to Fahrenheit calculation, and display the result in the Fahrenheit text box. To do this, you need to be able to read the value from the Celsius text box, and modify the Fahrenheit text box to display the result.
3. Go back to the canvas, and re-edit the properties as shown before. This time, edit the Name property for both the Celsius and Fahrenheit text boxes. These names can be used to reference the text boxes in the code.

   Widget	Property	New Value
   Celsius Text Box	Name	celsiusTextBox
   Fahrenheit Text Box	Name	fahrenheitTextBox

4. Go back to the calculateButton_Click function in Form1.cs.
5. Now, the Celsius text box can be referred to in the code using the name «celsiusTextBox». The Celsius value the user entered is stored in its Text property. However, since it’s a string, parse this into a double in order to include it in the future Fahrenheit calculations.

           private void calculateButton_Click(object sender, EventArgs e)
   {
       // Get the value that the user entered in the Celsius Text Box
      double celsiusValue = Double.Parse(celsiusTextBox.Text);
   }
       

6. The celsiusValue variable now stores the value that the user entered in the Celsius Text Box. The formula for converting Celsius to Fahrenheit is (celsiusValue * 9 / 5) + 32. Therefore, the result can now be calculated and stored in the Fahrenheit Text Box.

           private void calculateButton_Click(object sender, EventArgs e)
   {
       // Get the value that the user entered in the Celsius Text Box
       double celsiusValue = Double.Parse(celsiusTextBox.Text);
      // Apply the calculation
      double result = (celsiusValue * 9 / 5) + 32;
      // Store the result in the Fahrenheit Textbox
      fahrenheitTextBox.Text = result.ToString();
   }
       

How to Run and Debug the Windows Forms Program

Running the Windows Forms Program in Visual Studio

Now that the UI and code logic is set up, run the program to see it working.

1. To run the program, select the green arrow at the top of the toolbar in Visual Studio.
   

   Картинка с сайта: www.makeuseof.com

2. Once the project has loaded, add a value into the Celsius text box and press the Calculate button. This will add the result into the Fahrenheit text box.
   

   Картинка с сайта: www.makeuseof.com

3. If the program is blurry at runtime, it is likely your application is not DPI aware. This can cause scaling and resolution issues, so this will need to be enabled. You can also read more about configuring display scaling on Windows 10 for High-DPI monitors.
4. Right-click on the TemperatureConverter Project in the Solutions Explorer. Select Add, then select New Item.
5. Search for the Application Manifest File, and click Add.
   

   Картинка с сайта: www.makeuseof.com

6. Copy the following code into the new app.manifest file, as a child of the assembly tag (if the code is already generated, just un-comment it).

           <application xmlns="urn:schemas-microsoft-com:asm.v3">
    <windowsSettings>
      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
      <longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
    </windowsSettings>
   </application>
       

7. For this change to take effect, re-run the program. Select the red stop button at the top of the toolbar, then select the green play button again.

Debugging the Windows Forms Program

You may want to debug the program if the logic of your Windows Forms application is not working as expected.

1. Navigate back to the calculateButton_Click function in Form1.cs and click anywhere on the gray bar in the far-left of the screen. This will add a breakpoint, which is indicated by a red circle.
2. Press the «Calculate» button again to trigger this method to execute. The program will pause when it hits the breakpoint to show all the values stored in the variables at that point.
3. To continue the program, click the green Continue arrow at the top of the toolbar.
   

   Картинка с сайта: www.makeuseof.com

Running the Program Using an Executable File

If you don’t want to run your program through Visual Studio, use the standalone executable file for the program. This is automatically generated.

1. Navigate to the executable file, which can be found here:

           <your-project-folder>/bin/Debug/netcoreapp3.1/TemperatureConverter.exe
       

2. Click on the executable file to directly run the program.

Adding More to Your Windows Form

Hopefully you now have a basic understanding of the basic structure of a Windows Form Application. You can continue exploring additional Windows Forms features by experimenting with new widgets, and taking a deeper dive into the other various events that can be handled.

Once you are more familiar with Windows Forms, you can start creating more complex applications. You can also explore many of the other ways you can create applications on Windows desktop.

Creating a Simple WinForms Application using Visual Studio

This example will show you how to create a Windows Forms Application project in Visual Studio.

Create Windows Forms Project

1. Start Visual Studio.

2. On the File menu, point to New, and then select Project. The New Project dialog box appears.

3. In the Installed Templates pane, select «Visual C#» or «Visual Basic».

4. Above the middle pane, you can select the target framework from the drop-down list.

5. In the middle pane, select the Windows Forms Application template.

6. In the Name text box, type a name for the project.

7. In the Location text box, choose a folder to save the project.

8. Click OK.

9. The Windows Forms Designer opens and displays Form1 of the project.

Add Controls to the Form

1. From the Toolbox palette, drag a Button control onto the form.

2. Click the button to select it. In the Properties window, set the Text property to Say Hello.

   

   Картинка с сайта: riptutorial.com

Write Code

1. Double-click the button to add an event handler for the Click event. The Code Editor will open with the insertion point placed within the event handler function.

2. Type the following code:

   C#

   MessageBox.Show("Hello, World!");
    

   VB.NET

   MessageBox.Show("Hello, World!")
    

Run and Test

1. Press F5 to run the application.

2. When your application is running, click the button to see the «Hello, World!» message.

3. Close the form to return to Visual Studio.

Creating a Simple C# WinForms Application using a Text Editor

1. Open a text editor (like Notepad), and type the code below:

    using System;
    using System.ComponentModel;
    using System.Drawing;
    using System.Windows.Forms;
   
    namespace SampleApp
    {
        public class MainForm : Form
        {
            private Button btnHello;
   
            // The form's constructor: this initializes the form and its controls.
            public MainForm()
            {
                // Set the form's caption, which will appear in the title bar.
                this.Text = "MainForm";
   
                // Create a button control and set its properties.
                btnHello = new Button();
                btnHello.Location = new Point(89, 12);
                btnHello.Name = "btnHello";
                btnHello.Size = new Size(105, 30);
                btnHello.Text = "Say Hello";
   
                // Wire up an event handler to the button's "Click" event
                // (see the code in the btnHello_Click function below).
                btnHello.Click += new EventHandler(btnHello_Click);
   
                // Add the button to the form's control collection,
                // so that it will appear on the form.
                this.Controls.Add(btnHello);
            }
   
            // When the button is clicked, display a message.
            private void btnHello_Click(object sender, EventArgs e)
            {
                MessageBox.Show("Hello, World!");
            }
   
            // This is the main entry point for the application.
            // All C# applications have one and only one of these methods.
            [STAThread]
            static void Main()
            {
                Application.EnableVisualStyles();
                Application.Run(new MainForm());
            }
        }
    }
    

1. Save the file to a path you have read/write access to. It is conventional to name the file after the class that it contains—for example, X:\MainForm.cs .

1. Run the C# compiler from the command line, passing the path to the code file as an argument:

    %WINDIR%\Microsoft.NET\Framework64\v4.0.30319\csc.exe /target:winexe "X:\MainForm.cs"
    

   Note: To use a version of the C# compiler for other .NET framework versions, take a look in the path, %WINDIR%\Microsoft.NET and modify the example above accordingly. For more information on compiling C# applications, see Compile and run your first C# program.

1. After compilation has completed, an application called MainForm.exe will be created in the same directory as your code file. You can run this application either from the command line or by double-clicking on it in Explorer.

Creating a Simple VB.NET WinForms Application using a Text Editor

1. Open a text editor (like Notepad), and type the code below:

    Imports System.ComponentModel
    Imports System.Drawing
    Imports System.Windows.Forms
   
    Namespace SampleApp
        Public Class MainForm : Inherits Form
            Private btnHello As Button
    
            ' The form's constructor: this initializes the form and its controls.
            Public Sub New()
                ' Set the form's caption, which will appear in the title bar.
                Me.Text = "MainForm"
    
                ' Create a button control and set its properties.
                btnHello = New Button()
                btnHello.Location = New Point(89, 12)
                btnHello.Name = "btnHello"
                btnHello.Size = New Size(105, 30)
                btnHello.Text = "Say Hello"
    
                ' Wire up an event handler to the button's "Click" event
                ' (see the code in the btnHello_Click function below).
                AddHandler btnHello.Click, New EventHandler(AddressOf btnHello_Click)
    
                ' Add the button to the form's control collection,
                ' so that it will appear on the form.
                Me.Controls.Add(btnHello)
            End Sub
    
            ' When the button is clicked, display a message.
            Private Sub btnHello_Click(sender As Object, e As EventArgs)
                MessageBox.Show("Hello, World!")
            End Sub
    
            ' This is the main entry point for the application.
            ' All VB.NET applications have one and only one of these methods.
            <STAThread> _
            Public Shared Sub Main()
                Application.EnableVisualStyles()
                Application.Run(New MainForm())
            End Sub
        End Class
    End Namespace
    

1. Save the file to a path you have read/write access to. It is conventional to name the file after the class that it contains—for example, X:\MainForm.vb .

1. Run the VB.NET compiler from the command line, passing the path to the code file as an argument:

    %WINDIR%\Microsoft.NET\Framework64\v4.0.30319\vbc.exe /target:winexe "X:\MainForm.vb"
    

   Note: To use a version of the VB.NET compiler for other .NET framework versions, take a look in the path %WINDIR%\Microsoft.NET and modify the example above accordingly. For more information on compiling VB.NET applications, see Hello World.

1. After compilation has completed, an application called MainForm.exe will be created in the same directory as your code file. You can run this application either from the command line or by double-clicking on it in Explorer.

Last Updated :
25 Mar, 2025

Windows Forms (WinForms) is a GUI class library for building Windows desktop applications. Originally part of the .NET Framework, it is now supported in .NET Core, .NET 5+, .NET 8 (LTS), and .NET 9. Its main purpose is to provide an easier interface to develop applications for desktops, tablets, and PCs. It is also termed as the WinForms.

The applications developed using Windows Forms or WinForms are known as the Windows Forms Applications that run on the desktop computer. WinForms can be used only to develop Windows Forms Applications.

Creating First Windows Form

Let’s create the first Windows form here we are using Visual Studio Community 2022. Refer to this article which has a complete process on how to download Visual Studio.
Firstly we create a simple form that has a button and when we click on that button it shows a message let’s create it. These are the important steps to create a Windows form follow these steps as mentioned below:

Note: At the time of writing, Visual Studio Community 2022 is the latest stable version. However, check for newer versions like Visual Studio 2025 for updated features.

Step 1: Now open Visual Studio and different options are available there as of now.

Картинка с сайта: www.geeksforgeeks.org

Step 2: Now choose the Windows Forms App with C# and click on the next button.

Картинка с сайта: www.geeksforgeeks.org

Step 3: Now locate the project with the name here we are using the default name which is Form1 and it will open a form in the editor which we can further modify.

Картинка с сайта: www.geeksforgeeks.org

Let’s understand the interface of Visual Studio Community 2022 for Windows forms

• Editor Window (Main Window): Here, We will work with forms and code editing. Notice the layout of the form which is now blank. If we double-click the form then it will open the code for that.
• Solution Explorer: A file manager for your project where you can navigate between forms, resources, and settings. For example, if we will select a file from this window then particular information will be displayed in the property window.
• Properties Window: Allows you to modify UI elements such as colors, text alignment, and visibility. Also, we can change the properties of components or controls that will add to the forms.

In the image, we have two files that are open one Design and there is Form1.cs these two play a major role. We use the Form 1.cs file for the custom logic.

Step 4: Now open a Toolbox go to the view > Toolbox or ctrl + alt + x.

Toolbox: Provides drag-and-drop controls like buttons, text boxes, and labels to design the UI.

Картинка с сайта: www.geeksforgeeks.org

Step 5. Now open the common controls and drag and drop the button on the form where we want it to be placed.

Картинка с сайта: www.geeksforgeeks.org

Step 6. Now open the properties of the button press right-click on the button and it will open the properties solution explorer now we can change the button name to Click here.

Картинка с сайта: www.geeksforgeeks.org

Step 7: Now again open the Toolbox and then click on the label and place where we want to show the message.

Картинка с сайта: www.geeksforgeeks.org

Note: The Form1.Designer.cs file automatically generates UI code for Windows Forms. You should not manually edit this file, as changes may be lost. Instead, add event-handling logic in Form1.cs

Note: To handle user interactions, double-click a button to generate a Click event in Form1.cs. Here, you can define actions when the button is clicked.

Step 8. Now again double click on the button and it will open Form1.cs file and add the text when the button1 click action is triggered.

Картинка с сайта: www.geeksforgeeks.org

Form1.cs file:

C#

namespace WinFormsApp2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            label1.Text = "Hello Geeks!";
        }

    }
}

Step 9: Now click on the start button or press F5 to execute the program.

Картинка с сайта: www.geeksforgeeks.org

It will open a Windows form now to interact with the program.

Advantages

• Comprehensive Controls: It comes up with a rich set of customizable controls (buttons, text boxes labels etc.) that makes it easier to use and allows more control through properties and event handling
• Visual Designer: It comes up with the visual design helps to see the changes of form design and comes up with features like drag-and-drop for easy UI design.
• Code Integration: A specially designed code editor for forms design helps to write application logic, handling events and data validation.
• Use-cases: It is used in a variety of applications including the data entry tools, management system and business purposes.
• Easy and optimal: Always become a first choice to make a lightweight desktop application for rapid development and come up with .NET support.

Prerequisites

• Visual Studio 2022
• TX Text Control .NET for Windows Forms

Step 1: Create a New Project

• Open Visual Studio 2022.
• Click on «Create a new project».
• From the options, select C# under Languages, Windows under Platform, and Desktop under Project Type.
• Scroll to find the Windows Forms App template.
• Select it and click Next.


Картинка с сайта: www.textcontrol.com

Step 2: Name Your Project and Choose the Framework

• Enter a project name and click Next.
• Select your Framework version as .NET 6 (Long-term support) and click Create.


Картинка с сайта: www.textcontrol.com

Step 3: Install the Required NuGet Package

• Right-click the project in Solution Explorer.
• Select Manage NuGet Packages from the context menu.
• Choose Text Control Offline Packages as the package source, then click Browse.
• Find TXTextControl.TextControl.WinForms.SDK and click Install.


Картинка с сайта: www.textcontrol.com

Step 4: Add the Text Control to Your Form

• In Solution Explorer, open Form1.
• In the Toolbox, find the TX Text Control 32.0 tab.
• Select the TextControl icon and draw it onto the Windows form.


Картинка с сайта: www.textcontrol.com

Step 5: Customize the Text Control

• Click the Smart Tag in the upper right corner of TextControl.
• In the Wizards group, click on:
• Add a Button Bar
• Add a Status Bar
• Add a Ruler
• Add a Vertical Ruler
• Finally, click Arrange Controls Automatically.


Картинка с сайта: www.textcontrol.com

The controls will now be connected and docked to fill the container.



Картинка с сайта: www.textcontrol.com

Step 6: Build and Compile

• Click the Start button to build and compile the project.
• The application will start and the Text Control will be displayed on the form.

Conclusion

In this tutorial, you learned how to create a new Windows Forms application in Visual Studio 2022 and how to add a Text Control to the form. You also learned how to customize the Text Control by adding a Button Bar, Status Bar, Ruler, and Vertical Ruler. Finally, you built and compiled the project to see the Text Control in action.

Windows Forms

Text Control combines the power of a reporting tool and an easy-to-use WYSIWYG word processor — fully programmable and embeddable in your Windows Forms application. TX Text Control .NET for Windows Forms is a royalty-free, fully programmable rich edit control that offers developers a broad range of word processing features in a reusable component for Visual Studio.

See Windows Forms products

Related Posts