Replace "auto implemented" with "automatically"

Fixes #42252

In preparation for "field backed properties", make sure all our docs use the correct "automatically implemented" terminology.

Because, field backed properties are kind of auto-implemented as well.

I did update the VB docs as well, to keep them consistent.

Author: BillWagner

docs/csharp/advanced-topics/interop/walkthrough-office-programming.md

@@ -49,7 +49,7 @@ In **Solution Explorer**, right-click the **ThisAddIn.cs** file and then select
 
 ## Create a list of bank accounts
 
-In **Solution Explorer**, right-click your project's name, select **Add**, and then select **Class**. Name the class Account.cs. Select **Add**. Replace the definition of the `Account` class with the following code. The class definitions use *auto-implemented properties*.
+In **Solution Explorer**, right-click your project's name, select **Add**, and then select **Class**. Name the class Account.cs. Select **Add**. Replace the definition of the `Account` class with the following code. The class definitions use *automatically implemented properties*.
 
 :::code language="csharp" source="./snippets/OfficeWalkthrough/account.cs" id="AccountClass":::
 
@@ -122,13 +122,13 @@ In Visual Studio, select **Clean Solution** on the **Build** menu. Otherwise, th
 
 ## See also
 
-- [Auto-Implemented Properties (C#)](../../programming-guide/classes-and-structs/auto-implemented-properties.md)
-- [Object and Collection Initializers](../../programming-guide/classes-and-structs/object-and-collection-initializers.md)
+- [Automatically implemented properties (C#)](../../programming-guide/classes-and-structs/auto-implemented-properties.md)
+- [Object and collection initializers](../../programming-guide/classes-and-structs/object-and-collection-initializers.md)
 - [Visual Studio Tools for Office (VSTO)](/visualstudio/vsto/visual-studio-tools-for-office-runtime-overview)
-- [Named and Optional Arguments](../../programming-guide/classes-and-structs/named-and-optional-arguments.md)
+- [Named and optional arguments](../../programming-guide/classes-and-structs/named-and-optional-arguments.md)
 - [dynamic](../../language-reference/builtin-types/reference-types.md)
-- [Using Type dynamic](using-type-dynamic.md)
-- [Lambda Expressions (C#)](../../language-reference/operators/lambda-expressions.md)
-- [Walkthrough: Embedding Type Information from Microsoft Office Assemblies in Visual Studio](/previous-versions/visualstudio/visual-studio-2013/ee317478(v=vs.120))
-- [Walkthrough: Embedding Types from Managed Assemblies](../../../standard/assembly/embed-types-visual-studio.md)
-- [Walkthrough: Creating Your First VSTO Add-in for Excel](/visualstudio/vsto/walkthrough-creating-your-first-vsto-add-in-for-excel)
+- [Using type dynamic](using-type-dynamic.md)
+- [Lambda expressions (C#)](../../language-reference/operators/lambda-expressions.md)
+- [Walkthrough: Embedding type information from Microsoft Office assemblies in Visual Studio](/previous-versions/visualstudio/visual-studio-2013/ee317478(v=vs.120))
+- [Walkthrough: Embedding types from managed assemblies](../../../standard/assembly/embed-types-visual-studio.md)
+- [Walkthrough: Creating your first VSTO add-in for Excel](/visualstudio/vsto/walkthrough-creating-your-first-vsto-add-in-for-excel)

docs/csharp/advanced-topics/reflection-and-attributes/index.md

@@ -95,7 +95,7 @@ The list of possible `target` values is shown in the following table.
 | `return`     | Return value of a method, property indexer, or `get` property accessor |
 | `type`       | Struct, class, interface, enum, or delegate                            |
 
-You would specify the `field` target value to apply an attribute to the backing field created for an [auto-implemented property](../../programming-guide/classes-and-structs/properties.md).
+You would specify the `field` target value to apply an attribute to the backing field created for an [automatically implemented property](../../programming-guide/classes-and-structs/properties.md).
 
 The following example shows how to apply attributes to assemblies and modules. For more information, see [Common Attributes (C#)](../../language-reference/attributes/global.md).
 

docs/csharp/fundamentals/types/interfaces.md

@@ -8,7 +8,7 @@ helpviewer_keywords:
 ---
 # Interfaces - define behavior for multiple types
 
-An interface contains definitions for a group of related functionalities that a non-abstract [`class`](../../language-reference/keywords/class.md) or a [`struct`](../../language-reference/builtin-types/struct.md) must implement. An interface may define `static` methods, which must have an implementation. An interface may define a default implementation for members. An interface may not declare instance data such as fields, auto-implemented properties, or property-like events.
+An interface contains definitions for a group of related functionalities that a non-abstract [`class`](../../language-reference/keywords/class.md) or a [`struct`](../../language-reference/builtin-types/struct.md) must implement. An interface may define `static` methods, which must have an implementation. An interface may define a default implementation for members. An interface may not declare instance data such as fields, automatically implemented properties, or property-like events.
 
 By using interfaces, you can, for example, include behavior from multiple sources in a class. That capability is important in C# because the language doesn't support multiple inheritance of classes. In addition, you must use an interface if you want to simulate inheritance for structs, because they can't actually inherit from another struct or class.
 

docs/csharp/how-to/index.md

@@ -22,7 +22,7 @@ There are several tips and tricks that are common C# developer practices:
 
 You create classes, records, and structs to implement your program. These techniques are commonly used when writing classes, records, or structs.
 
-- [Declare auto implemented properties](../programming-guide/classes-and-structs/how-to-implement-a-lightweight-class-with-auto-implemented-properties.md).
+- [Declare automatically implemented properties](../programming-guide/classes-and-structs/how-to-implement-a-lightweight-class-with-auto-implemented-properties.md).
 - [Declare and use read/write properties](../programming-guide/classes-and-structs/how-to-declare-and-use-read-write-properties.md).
 - [Define constants](../programming-guide/classes-and-structs/how-to-define-constants.md).
 - [Override the `ToString` method to provide string output](../programming-guide/classes-and-structs/how-to-override-the-tostring-method.md).

docs/csharp/language-reference/attributes/general.md

@@ -120,7 +120,7 @@ If <xref:System.AttributeUsageAttribute.Inherited> is `false`, then derived clas
 
 In this case, `NonInheritedAttribute` isn't applied to `DClass` via inheritance.
 
-You can also use these keywords to specify where an attribute should be applied. For example, you can use the `field:` specifier to add an attribute to the backing field of an [autoimplemented property](../../programming-guide/classes-and-structs/properties.md#auto-implemented-properties). Or you can use the `field:`, `property:` or `param:` specifier to apply an attribute to any of the elements generated from a positional record. For an example, see [Positional syntax for property definition](../builtin-types/record.md#positional-syntax-for-property-definition).
+You can also use these keywords to specify where an attribute should be applied. For example, you can use the `field:` specifier to add an attribute to the backing field of an [automatically implemented property](../../programming-guide/classes-and-structs/properties.md#auto-implemented-properties). Or you can use the `field:`, `property:` or `param:` specifier to apply an attribute to any of the elements generated from a positional record. For an example, see [Positional syntax for property definition](../builtin-types/record.md#positional-syntax-for-property-definition).
 
 ## `AsyncMethodBuilder` attribute
 

docs/csharp/language-reference/builtin-types/struct.md

@@ -28,7 +28,7 @@ Because structure types have value semantics, we recommend you define *immutable
 You use the `readonly` modifier to declare that a structure type is immutable. All data members of a `readonly` struct must be read-only as follows:
 
 - Any field declaration must have the [`readonly` modifier](../keywords/readonly.md)
-- Any property, including auto-implemented ones, must be read-only or [`init` only](../keywords/init.md). Note that init-only setters are only available from [C# version 9 onwards](../../whats-new/csharp-version-history.md).
+- Any property, including automatically implemented ones, must be read-only or [`init` only](../keywords/init.md). Note that init-only setters are only available from [C# version 9 onwards](../../whats-new/csharp-version-history.md).
 
 That guarantees that no member of a `readonly` struct modifies the state of the struct. That means that other instance members except constructors are implicitly [`readonly`](#readonly-instance-members).
 
@@ -62,7 +62,7 @@ Typically, you apply the `readonly` modifier to the following kinds of instance
   If you need to apply the `readonly` modifier to both accessors of a property or indexer, apply it in the declaration of the property or indexer.
 
   > [!NOTE]
-  > The compiler declares a `get` accessor of an [auto-implemented property](../../programming-guide/classes-and-structs/auto-implemented-properties.md) as `readonly`, regardless of presence of the `readonly` modifier in a property declaration.
+  > The compiler declares a `get` accessor of an [automatically implemented property](../../programming-guide/classes-and-structs/auto-implemented-properties.md) as `readonly`, regardless of presence of the `readonly` modifier in a property declaration.
 
   You may apply the `readonly` modifier to a property or indexer with an `init` accessor:
 

docs/csharp/language-reference/compiler-messages/cs0840.md

@@ -12,7 +12,7 @@ ms.assetid: f307083f-8d86-4142-a9fd-b735910687b2
 
 'Property name' must declare a body because it is not marked abstract or extern. Automatically implemented properties must define both get and set accessors.  
 
- Unless a regular property is marked as `abstract` or `extern`, or is a member of a `partial` type, it must supply a body. Auto-implemented properties do not provide accessor bodies, but they must specify both accessors. To create a read-only auto-implemented property, make the set accessor `private`.  
+ Unless a regular property is marked as `abstract` or `extern`, or is a member of a `partial` type, it must supply a body. Automatically implemented properties do not provide accessor bodies, but they must specify both accessors. To create a read-only automatically implemented property, make the set accessor `private`.  
 
 ## To correct this error  
 
@@ -39,4 +39,4 @@ class Test
 
 ## See also
 
-- [Auto-Implemented Properties](../../programming-guide/classes-and-structs/auto-implemented-properties.md)
+- [Automatically implemented properties](../../programming-guide/classes-and-structs/auto-implemented-properties.md)

docs/csharp/language-reference/compiler-messages/cs8145.md

@@ -11,7 +11,7 @@ helpviewer_keywords:
 
 Auto-implemented properties cannot return by reference
 
-Auto-implemented properties are not guaranteed to have a member or variable that can be referenced and thus do not support return by reference.
+Automatically implemented properties are not guaranteed to have a member or variable that can be referenced and thus do not support return by reference.
 
 ## Example
 

docs/csharp/language-reference/compiler-messages/partial-declarations.md

@@ -229,4 +229,4 @@ The following warning indicates a signature difference in the declaring and impl
 
 - **CS9256**: *Partial property declarations have signature differences.*
 
-A partial property or indexer must have both a *declaring declaration* and an *implementing declaration*. The signatures for both declarations must match. Because the *declaring declaration* uses the same syntax as an auto-implemented property, the *implementing declaration* can't be an auto-implemented property. The accessors must have bodies.
+A partial property or indexer must have both a *declaring declaration* and an *implementing declaration*. The signatures for both declarations must match. Because the *declaring declaration* uses the same syntax as an automatically implemented property, the *implementing declaration* can't be an automatically implemented property. The accessors must have bodies.

docs/csharp/language-reference/compiler-messages/ref-struct-errors.md

@@ -56,7 +56,7 @@ ms.date: 07/30/2024
 
 A [`ref struct`](../builtin-types/ref-struct.md) type can include `ref` fields. Other types aren't allowed `ref` fields. The compiler enforces restrictions on the declarations and use of `ref struct` types to enforce ref safety rules on instances of any `ref struct` type:
 
-- Only `ref struct` types can contain auto-implemented `ref` properties.
+- Only `ref struct` types can contain automatically implemented `ref` properties.
 - Only `ref struct` types or `ref` variables can have the `scoped` modifier.
 - A `ref` field can be declared only in a `ref struct` type.
 - A `ref` field can't refer to a `ref struct` type/