Remove construction notice (#1811)

dotnet-desktop-guide/net/winforms/controls-design/designer-differences-framework.md

@@ -15,8 +15,6 @@ The Visual Designer for Windows Forms for .NET has had some improvements and cha
 
 Visual Studio is a .NET Framework-based application, and as such, the Visual Designer you see for Windows Forms is also based on .NET Framework. With a .NET Framework project, both the Visual Studio environment and the Windows Forms app being designed, run within the same process: **devenv.exe**. This poses a problem when you're working with a Windows Forms .NET (not .NET Framework) app. Both .NET and .NET Framework code can't work within the same process. As a result, Windows Forms .NET uses a different designer, the "out-of-process" designer.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Out-of-process designer
 
 The out-of-process designer is a process called **DesignToolsServer.exe**, and is run along-side Visual Studio's **devenv.exe** process. The **DesignToolsServer.exe** process runs on the same version and platform of .NET that your app has been set up to target, such as .NET 7 and x64.

dotnet-desktop-guide/net/winforms/controls-design/designer-errors.md

@@ -17,8 +17,6 @@ If the Windows Forms Designer fails to load due to an error in your code, in a t
 
 :::image type="content" source="media/designer-errors/vs-designer-error-message.png" alt-text="A designer error tab in Visual Studio that says that the event for a button is missing.":::
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Yellow bar
 
 The yellow collapsible bar is created for every error, grouped by description. The bar describes the compiler error preventing the designer from loading property. It includes these details:

dotnet-desktop-guide/net/winforms/controls-design/designer-overview.md

@@ -24,8 +24,6 @@ helpviewer_keywords:
 
 As you've noticed when interacting with the Windows Forms designer, there are many different design-time features offered by the Windows Forms controls. Some of the features offered by the Visual Studio Designer include snap lines, action items, and the property grid. All of these features offer you an easier way to interact and customize a control during design-time. This article is an overview about what kind of support you can add to your custom controls, to make the design-time experience better for the consumers of your controls.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## What's different from .NET Framework
 
 Many basic design elements of custom controls have remained the same from .NET Framework. However, if you use more advanced designer customization features, such as action lists, type converters, custom dialogs, you have some unique scenarios to handle.

dotnet-desktop-guide/net/winforms/controls-design/designer-properties-overview.md

@@ -28,8 +28,6 @@ Every control inherits many properties from the base class <xref:System.Windows.
 
 When creating a control, you can define new properties and control how they appear in the designer.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Define a property
 
 Any public property with a **get** accessor defined by a control is automatically visible in the Visual Studio **Properties** window. If the property also defines a **set** accessor, the property can be changed in the **Properties** window. However, properties can be explicitly displayed or hidden from the **Properties** window by applying the <xref:System.ComponentModel.BrowsableAttribute>. This attribute takes a single boolean parameter to indicate whether or not it's displayed. For more information about attributes, see [Attributes (C#)](/dotnet/csharp/programming-guide/concepts/attributes/index) or [Attributes overview (Visual Basic)](/dotnet/visual-basic/programming-guide/concepts/attributes/index).

dotnet-desktop-guide/net/winforms/controls-design/extend-existing.md

@@ -13,8 +13,6 @@ helpviewer_keywords:
 
 If you want to add more features to an existing control, you can create a control that inherits from an existing control. The new control contains all of the capabilities and visual aspect of the base control, but gives you opportunity to extend it. For example, if you created a control that inherits <xref:System.Windows.Forms.Button>, your new control would look and act exactly like a button. You could create new methods and properties to customize the behavior of the control. Some controls allow you to override the <xref:System.Windows.Forms.Control.OnPaint%2A> method to change the way the control looks.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Add a custom control to a project
 
 After creating a new project, use the Visual Studio templates to create a user control. The following steps demonstrate how to add a user control to your project:

dotnet-desktop-guide/net/winforms/controls-design/how-to-create-usercontrol.md

@@ -24,8 +24,6 @@ helpviewer_keywords:
 
 This article teaches you how to add a user control to your project and then add that user control to a form. You'll create a reusable user control that's both visually appealing and functional. The new control groups a <xref:System.Windows.Forms.TextBox> control with a <xref:System.Windows.Forms.Button> control. When the user selects the button, the text in the text box is cleared. For more information about user controls, see [User control overview](usercontrol-overview.md).
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Add a user control to a project
 
 After opening your Windows Forms project in Visual Studio, use the Visual Studio templates to create a user control:

dotnet-desktop-guide/net/winforms/controls-design/how-to-designer-properties-shouldserialize-reset.md

@@ -25,8 +25,6 @@ In this article, you learn how to create the `Reset<PropertyName>` and `ShouldSe
 
 For more information about properties, see [Reset and ShouldSerialize](designer-properties-overview.md#reset-and-shouldserialize).
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Supporting code
 
 This article demonstrates the `Reset` and `ShouldSerialize` methods by creating a compass rose control. If you're working with your own user control, you can skip this section.

dotnet-desktop-guide/net/winforms/controls-design/how-to-set-toolbox-icon.md

@@ -16,8 +16,6 @@ helpviewer_keywords:
 
 Controls that you create always receive a generic icon for the **Toolbox** window in Visual Studio. However, when you change the icon, it adds a sense of professionalism to your control, and makes it stand out in the toolbox. This article teaches you how to set the icon for your control.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Bitmap icon
 
 Icons for the **Toolbox** window in Visual Studio must conform to certain standards, otherwise they're ignored or are displayed incorrectly.

dotnet-desktop-guide/net/winforms/controls-design/overview.md

@@ -20,8 +20,6 @@ helpviewer_keywords:
 
 With Windows Forms, you can create new controls or modify existing controls through inheritance. This article highlights the differences among the ways of creating new controls, and provides you with information about how to choose a particular type of control for your project.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Base control class
 
 The <xref:System.Windows.Forms.Control> class is the base class for Windows Forms controls. It provides the infrastructure required for visual display in Windows Forms applications and provides the following capabilities:

dotnet-desktop-guide/net/winforms/controls-design/usercontrol-guidelines.md

@@ -19,8 +19,6 @@ helpviewer_keywords:
 
 This article provides guidelines for creating user controls. We recommend that you follow these guidelines to make sure that you design a user control that's consistent with other Windows Forms controls.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Defining events
 
 Events commonly communicate state change and alert you to how the user is interacting with a Windows Forms control. For more information about events and delegates, see [Handle and raise events](/dotnet/standard/events/index).

dotnet-desktop-guide/net/winforms/controls-design/usercontrol-overview.md

@@ -24,8 +24,6 @@ User controls are designed like Forms, with a visual designer. You create, arran
 
 User controls are usable by the project in which they're created, or in other projects that have reference to the user control's library.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Constituent controls
 
 The constituent controls are available to the user control, and the app user can interact with them all individually at runtime, but the properties and methods declared by the constituent controls aren't exposed to the consumer. For example, if you place a `TextBox` and `Button` control on the user control, the button's `Click` event is handled internally by the user control, but not by the Form where the user control is placed.

dotnet-desktop-guide/net/winforms/controls/custom-painting-drawing.md

@@ -23,8 +23,6 @@ helpviewer_keywords:
 
 Custom painting of controls is one of the many complicated tasks made easy by Windows Forms. When authoring a custom control, you have many options available to handle your control's graphical appearance. If you're authoring a [custom control](../controls-design/overview.md#custom-controls), that is, a control that inherits from <xref:System.Windows.Forms.Control>, you must provide code to render its graphical representation.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 If you're creating a [composite control](../controls-design/usercontrol-overview.md), that is a control that inherits from <xref:System.Windows.Forms.UserControl> or one of the [existing Windows Forms controls](../controls-design/extend-existing.md), you may override the standard graphical representation and provide your own graphics code.
 
 If you want to provide custom rendering for an existing control without creating a new control, your options become more limited. However, there are still a wide range of graphical possibilities for your controls and applications.

dotnet-desktop-guide/net/winforms/controls/events.md

@@ -21,8 +21,6 @@ helpviewer_keywords:
 
 Controls provide events that are raised when the user interacts with the control or when the state of the control changes. This article describes the common events shared by most controls, events raised by user interaction, and events unique to specific controls. For more information about events in Windows Forms, see [Events overview](../forms/events.md) and [Handling and raising events](/dotnet/standard/events/index).
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 For more information about how to add or remove a control event handler, see [How to handle an event](how-to-add-an-event-handler.md).
 
 ## Common events

dotnet-desktop-guide/net/winforms/controls/how-to-add-a-picture-to-a-control.md

@@ -17,8 +17,6 @@ helpviewer_keywords:
 
 Several Windows Forms controls can display images. These images can be icons that clarify the purpose of the control, such as a diskette icon on a button denoting the Save command. Alternatively, the icons can be background images to give the control the appearance and behavior you want.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Display an image - designer
 
 In Visual Studio, use the Visual Designer to display an image.

dotnet-desktop-guide/net/winforms/controls/how-to-add-an-event-handler.md

@@ -22,8 +22,6 @@ helpviewer_keywords:
 
 Events for controls (and for forms) are generally set through the Visual Studio Visual Designer for Windows Forms. Setting an event through the Visual Designer is known as handling an event at design-time. You can also handle events dynamically in code, known as handling events at run-time. An event created at run-time allows you to connect event handlers dynamically based on what your app is currently doing.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Handle an event - designer
 
 In Visual Studio, use the Visual Designer to manage handlers for control events. The Visual Designer will generate the handler code and add it to the event for you.

dotnet-desktop-guide/net/winforms/controls/how-to-add-to-a-form.md

@@ -16,8 +16,6 @@ Most forms are designed by adding controls to the surface of the form to define
 
 The primary way a control is added to a form is through the Visual Studio Designer, but you can also manage the controls on a form at run time through code.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Add with Designer
 
 Visual Studio uses the Forms Designer to design forms. There is a Controls pane which lists all the controls available to your app. You can add controls from the pane in two ways:

dotnet-desktop-guide/net/winforms/controls/how-to-create-access-keys.md

@@ -26,8 +26,6 @@ An *access key* is an underlined character in the text of a menu, menu item, or
 
 Controls that cannot receive focus can't have access keys, except label controls.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Designer
 
 In the **Properties** window of Visual Studio, set the **Text** property to a string that includes an ampersand (&) before the letter that will be the access key. For example, to set the letter "P" as the access key, enter **&Print**.

dotnet-desktop-guide/net/winforms/controls/how-to-dock-and-anchor.md

@@ -23,8 +23,6 @@ helpviewer_keywords:
 
 If you're designing a form that the user can resize at run time, the controls on your form should resize and reposition properly. Controls have two properties that help with automatic placement and sizing, when the form changes size.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 - <xref:System.Windows.Forms.Control.Dock%2A?displayProperty=nameWithType>
 
   Controls that are docked fill the edges of the control's container, either the form or a container control. For example, Windows Explorer docks its <xref:System.Windows.Forms.TreeView> control to the left side of the window and its <xref:System.Windows.Forms.ListView> control to the right side of the window. The docking mode can be any side of the control's container, or set to fill the remaining space of the container.

dotnet-desktop-guide/net/winforms/controls/how-to-make-thread-safe-calls.md

@@ -21,8 +21,6 @@ helpviewer_keywords:
 
 Multithreading can improve the performance of Windows Forms apps, but access to Windows Forms controls isn't inherently thread-safe. Multithreading can expose your code to serious and complex bugs. Two or more threads manipulating a control can force the control into an inconsistent state and lead to race conditions, deadlocks, and freezes or hangs. If you implement multithreading in your app, be sure to call cross-thread controls in a thread-safe way. For more information, see [Managed threading best practices](/dotnet/standard/threading/managed-threading-best-practices).
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 There are two ways to safely call a Windows Forms control from a thread that didn't create that control. Use the <xref:System.Windows.Forms.Control.Invoke%2A?displayProperty=fullName> method to call a delegate created in the main thread, which in turn calls the control. Or, implement a <xref:System.ComponentModel.BackgroundWorker?displayProperty=nameWithType>, which uses an event-driven model to separate work done in the background thread from reporting on the results.
 
 ## Unsafe cross-thread calls

dotnet-desktop-guide/net/winforms/controls/how-to-set-the-display-text.md

@@ -27,8 +27,6 @@ Windows Forms controls usually display some text that's related to the primary f
 
 You can also set the text by using the [designer](#designer).
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Designer
 
 01. In the **Properties** window in Visual Studio, set the **Text** property of the control to an appropriate string.

dotnet-desktop-guide/net/winforms/controls/how-to-set-the-tab-order.md

@@ -17,8 +17,6 @@ The tab order is the order in which a user moves focus from one control to anoth
 
 You can also set the tab order by using the [designer](#designer).
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 Tab order can be set in the **Properties** window of the designer using the <xref:System.Windows.Forms.Control.TabIndex%2A> property. The `TabIndex` property of a control determines where it's positioned in the tab order. By default, the first control added to the designer has a `TabIndex` value of 0, the second has a `TabIndex` of 1, and so on. Once the highest `TabIndex` has been focused, pressing <kbd>Tab</kbd> will cycle and focus the control with the lowest `TabIndex` value.
 
 Container controls, such as a <xref:System.Windows.Forms.GroupBox> control, treat their children as separate from the rest of the form. Each child in the container has its own <xref:System.Windows.Forms.Control.TabIndex%2A> value. Because a container control can't be focused, when the tab order reaches the container control, the child control of the container with the lowest `TabIndex` is focused. As the <kbd>Tab</kbd> is pressed, each child control is focused according to its `TabIndex` value until the last control. When <kbd>Tab</kbd> is pressed on the last control, focus resumes to the next control in the parent of the container, based on the next `TabIndex` value.

dotnet-desktop-guide/net/winforms/controls/labels.md

@@ -15,8 +15,6 @@ helpviewer_keywords:
 
 Windows Forms <xref:System.Windows.Forms.Label> controls are used to display text that cannot be edited by the user. They're used to identify objects on a form and to provide a description of what a certain control represents or does. For example, you can use labels to add descriptive captions to text boxes, list boxes, combo boxes, and so on. You can also write code that changes the text displayed by a label in response to events at run time.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Working with the Label Control  
 
 Because the <xref:System.Windows.Forms.Label> control can't receive focus, it can be used to create access keys for other controls. An access key allows a user to focus the next control in tab order by pressing the <kbd>Alt</kbd> key with the chosen access key. For more information, see [Use a label to focus a control](how-to-create-access-keys.md#use-a-label-to-focus-a-control).

dotnet-desktop-guide/net/winforms/controls/layout.md

@@ -24,8 +24,6 @@ helpviewer_keywords:
 
 Control placement in Windows Forms is determined not only by the control, but also by the parent of the control. This article describes the different settings provided by controls and the different types of parent containers that affect layout.
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Fixed position and size
 
 The position a control appears on a parent is determined by the value of the <xref:System.Windows.Forms.Control.Location> property relative to the top-left of the parent surface. The top-left position coordinate in the parent is `(x0,y0)`. The size of the control is determined by the <xref:System.Windows.Forms.Control.Size> property and represents the width and height of the control.

dotnet-desktop-guide/net/winforms/controls/overview.md

@@ -15,8 +15,6 @@ helpviewer_keywords:
 
 Windows Forms controls are reusable components that encapsulate user interface functionality and are used in client-side, Windows-based applications. Not only does Windows Forms provide many ready-to-use controls, it also provides the infrastructure for developing your own controls. You can combine existing controls, extend existing controls, or author your own custom controls. For more information, see [Types of custom controls](custom.md).
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## Adding controls
 
 Controls are added through the Visual Studio Designer. With the Designer, you can place, size, align, and move controls. Alternatively, controls can be added through code. For more information, see [Add a control (Windows Forms)](how-to-add-to-a-form.md).

dotnet-desktop-guide/net/winforms/controls/provide-accessibility-information.md

@@ -21,8 +21,6 @@ Accessibility aids are specialized programs and devices that help people with di
 - <xref:System.Windows.Forms.Control.AccessibleName?displayProperty=fullName>
 - <xref:System.Windows.Forms.AccessibleRole?displayProperty=fullName>
 
-[!INCLUDE [desktop guide under construction](../../includes/desktop-guide-preview-note.md)]
-
 ## AccessibilityObject Property
 
 This read-only property contains an <xref:System.Windows.Forms.AccessibleObject> instance. The `AccessibleObject` implements the <xref:Accessibility.IAccessible> interface, which provides information about the control's description, screen location, navigational abilities, and value. The designer sets this value when the control is added to the form.