In some cases, WinForm TextBox Control automatically selects all text by mistake.

In some cases, Textbox Control automatically selects all text by mistake.

TextBox Control will automatically select all texts and highlight them when TextBox control gets the focus. But in fact, in some cases, it may not be necessary to select all the text.

If the program is a Log Viewer, or Notepad, it is just a reader that simply displays more than 100,000 characters. It does not need to automatically select all the text when the application is launched.

After starting the application, if the TextBox is the first control, the TextBox will automatically select all the text and highlight them. Usually this is an unnecessary operation.

photo attachment:

Reproduced by the following code:

.Net Version:
.net Framework 4.8 and .net 5.0

using System;
using System.Text;
using System.Windows.Forms;

namespace TextBoxFocusTest
{
    static class Program
    {
        [STAThread]
        static void Main()
        {
            Application.SetHighDpiMode(HighDpiMode.SystemAware);
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            var userControl = new UserControl()
            {
                Dock = DockStyle.Fill,
            };

            var stringBuilder = new StringBuilder();

            for (int n = 0; n < 10000; n++)
                stringBuilder.Append("Sample Text ");

            userControl.Controls.Add(new TextBox()
            {
                Dock = DockStyle.Fill,
                ScrollBars = ScrollBars.Both,
                Multiline = true,
                Text = stringBuilder.ToString()
            });

            var form = new Form()
            {
                StartPosition = FormStartPosition.CenterScreen,
                Text = "Log Viewer",
                Width = 400,
                Height = 400
            };

            form.Controls.Add(userControl);

            Application.Run(form);
        }
    }
}

By viewing the source code on the Microsoft website, the following code will automatically select all the text when the TextBox gains focus.

If the .net can provide a public property, and users determine whether to select all of the text. It will be more flexible.

photo attachment:

[weltkante]

You may have noticed that the code is guarded by selectionSet to provide a form of lazy initialization of the selection. The current intended behavior seems to be to call textbox.Select(0, 0); or similar APIs when you don't want the default behavior and instead provide your own default selection. This will set selectionSet to true so the lazy initialization of the selection will be skipped.

(I'm just observing the current behavior here and don't have an opinion about adding an explicit property as an alternate and perhaps more discoverable way to control the behavior.)

Yes, But the selectionSet is a private member, and I have checked the source code, there is no similar API to directly control it. There are other libraries on Github also encountered similar problem. they are using a temporary remedy, and these methods may cause errors after the .net update.

[weltkante]

I have checked the source code, there is no similar API to directly control it

You call textbox.Select(0, 0); during setup of the form/control, like I mentioned above. This works for both Desktop Framework and .NET Core (the public Select method calls SelectInternal)

Yes, this can temporarily solve this problem. But if the characters exceed 100,000, or more. For example, a 100MB text file. This operation will cause a significant performance degradation, and may cause the interface to flicker. It is very obvious when TextBox.WordWrap = true.

It selects everything first, and then deselects everything. Two additional interface operations have been added.

The larger the file, the more serious each time to switch focus.

[weltkante]

It selects everything first, and then deselects everything. Two additional interface operations have been added.

I don't think we are talking about the same thing. The code snippet you quoted is lazy initialization when the control first gets focus. I'm suggesting to preinitialize selection during setup of the form/control at which point nothing is loaded into handles, much less displayed. There is no chance to flicker.

If you dynamically change text and immediately reset selection to empty (when appropriate, i.e. nothing selected by the user, if you care about that) there is nothing to flicker either, since focus did not change the lazy "select all" code did not have a chance to run. Maybe you misunderstood and thought to put that call into the focus event handler? Thats not is not the purpose of the selectionSet variable, you need to modify it before the focus change happens otherwise it won't take effect. The point is to suppress the whole thing to run in the first place.

Thank you weltkante. I have tried to use the code you said in the program and it worked. I'm not sure if this is a design or just an accidental coincidence. It initially does look like a bug. TextBox.WordWrap = true has a significant impact on the display speed of the TextBox, especially when reading very large files (eg: 100MB file). But I am not sure if textbox.Select(0, 0) will also affect the speed.

[dreddy-work]

Given the behavior is same across the framework versions and work around exist to alter this behavior, I do not see a reason to change/alter the default behavior here. @roland5572 , did you check the behavior with Native/Mfc application?

@dreddy-work I just tested it. MFC will also select all text. But if you use the following class. Then WinForm TextBox Control will not automatically select all text, I think WinForm can control the default behavior of TextBox.

Just like the Notepad program that comes with Windows, if Notepad automatically selects all text when it starts, it will make the program look weird.

class NewTextBox : TextBox
    {
        protected override void OnGotFocus(EventArgs e)
        {
            //Directly back
            return;

            base.OnGotFocus(e);
        }
    }

[RussKie]

As much as it can be frustrating, this behaviour existed for many years. We won't be changing it because it presents a significant risk of regression, as existing consumers may have comes to depend on it, and/or implemented workarounds, which may break.

It appears there is a simple enough workaround, and I don't believe we have seen any other reports against this behaviour that could justify changes (and subsequent regression testing) for this API.