5 Ways To Create A Borderless Form In C#

Quick Links :

Creating a borderless form in C# can be a useful technique for developing modern and sleek user interfaces. A borderless form, as the name suggests, is a form without the traditional borders and title bar that are typically seen in Windows applications. This design approach is often used in applications that require a more streamlined and integrated look, such as video games, multimedia applications, and certain types of productivity software.

Benefits of a Borderless Form

Before diving into the methods for creating a borderless form, it's essential to understand the benefits of this approach. Some of the key advantages include:

• Enhanced visual appeal: Borderless forms can create a more immersive and engaging user experience, allowing your application to stand out from traditional Windows applications.
• Increased flexibility: Without the constraints of a traditional title bar and borders, you can design a form that better suits your application's specific needs.
• Improved integration: Borderless forms can be designed to blend seamlessly with other elements of your application, creating a more cohesive and polished look.

Method 1: Setting the FormBorderStyle Property

One of the simplest ways to create a borderless form in C# is by setting the FormBorderStyle property to None. This can be done in the form's constructor or in the designer.

public Form1()
{
    InitializeComponent();
    FormBorderStyle = FormBorderStyle.None;
}

While this approach is straightforward, it has some limitations. For example, the form will no longer be resizable, and the user will not be able to move the form around by dragging its title bar.

Overcoming the Limitations of FormBorderStyle.None

To overcome these limitations, you can use the following code to make the form resizable and movable:

private const int WM_NCLBUTTONDOWN = 0xA1;
private const int HT_CAPTION = 0x2;

[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static void MoveForm(IntPtr handle)
{
    if (handle == IntPtr.Zero) return;
    PostMessage(handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0);
}

protected override void OnMouseDown(MouseEventArgs e)
{
    base.OnMouseDown(e);
    MoveForm(Handle);
}

protected override void OnMouseUp(MouseEventArgs e)
{
    base.OnMouseUp(e);
    MoveForm(Handle);
}

This code overrides the OnMouseDown and OnMouseUp events to post a WM_NCLBUTTONDOWN message to the form's handle, allowing the user to move the form around by dragging it.

Method 2: Using the CreateParams Property

Another way to create a borderless form is by overriding the CreateParams property of the form. This property allows you to specify additional parameters when creating the form's window.

protected override CreateParams CreateParams
{
    get
    {
        var cp = base.CreateParams;
        cp.Style &= ~0xC00000; // Remove WS_BORDER and WS_CAPTION
        return cp;
    }
}

This code overrides the CreateParams property to remove the WS_BORDER and WS_CAPTION styles from the form's window, effectively creating a borderless form.

Customizing the Form's Window Style

You can customize the form's window style by modifying the Style property of the CreateParams object. For example, you can add the WS_THICKFRAME style to make the form resizable:

protected override CreateParams CreateParams
{
    get
    {
        var cp = base.CreateParams;
        cp.Style &= ~0xC00000; // Remove WS_BORDER and WS_CAPTION
        cp.Style |= 0x00040000; // Add WS_THICKFRAME
        return cp;
    }
}

This code adds the WS_THICKFRAME style to the form's window, allowing the user to resize the form.

Method 3: Using the WS_POPUP Window Style

Another approach to creating a borderless form is by using the WS_POPUP window style. This style creates a window that is not constrained by the traditional title bar and borders.

protected override CreateParams CreateParams
{
    get
    {
        var cp = base.CreateParams;
        cp.Style = 0x80000000; // WS_POPUP
        return cp;
    }
}

This code overrides the CreateParams property to set the Style property to WS_POPUP, effectively creating a borderless form.

Method 4: Using a Custom Form Border

You can also create a custom form border by overriding the WndProc method of the form and handling the WM_NCPAINT message.

protected override void WndProc(ref Message m)
{
    base.WndProc(ref m);
    if (m.Msg == 0x0085) // WM_NCPAINT
    {
        var hdc = GetDC(Handle);
        var rect = new RECT();
        GetWindowRect(Handle, ref rect);
        using (var graphics = Graphics.FromHdc(hdc))
        {
            using (var pen = new Pen(Color.Black, 2))
            {
                graphics.DrawRectangle(pen, 0, 0, rect.Right - rect.Left, rect.Bottom - rect.Top);
            }
        }
        ReleaseDC(Handle, hdc);
    }
}

This code overrides the WndProc method to handle the WM_NCPAINT message and draws a custom border around the form using GDI+.

Method 5: Using a Third-Party Library

Finally, you can use a third-party library to create a borderless form. There are many libraries available that provide this functionality, such as DevExpress, Telerik, and Infragistics.

Using a third-party library can simplify the process of creating a borderless form and provide additional features and customization options.

Conclusion

Creating a borderless form in C# can be a useful technique for developing modern and sleek user interfaces. By using one of the methods outlined in this article, you can create a form that is visually appealing and provides a unique user experience. Whether you choose to use the FormBorderStyle property, the CreateParams property, the WS_POPUP window style, a custom form border, or a third-party library, you can achieve the look and feel you want for your application.