Change "alignment" to "width" (#45780)

Author: gewarren

docs/core/extensions/globalization.md

@@ -128,15 +128,11 @@ How you handle date and time values depends on whether they are displayed in the
 
 Typically, when dates and times are displayed in the user interface, you should use the formatting conventions of the user's culture, which is defined by the <xref:System.Globalization.CultureInfo.CurrentCulture%2A?displayProperty=nameWithType> property and by the <xref:System.Globalization.DateTimeFormatInfo> object returned by the `CultureInfo.CurrentCulture.DateTimeFormat` property. The formatting conventions of the current culture are automatically used when you format a date by using any of these methods:
 
-- The parameterless <xref:System.DateTime.ToString?displayProperty=nameWithType> method
-
-- The <xref:System.DateTime.ToString%28System.String%29?displayProperty=nameWithType> method, which includes a format string
-
-- The parameterless <xref:System.DateTimeOffset.ToString?displayProperty=nameWithType> method
-
-- The <xref:System.DateTimeOffset.ToString%28System.String%29?displayProperty=nameWithType>, which includes a format string
-
-- The [composite formatting](../../standard/base-types/composite-formatting.md) feature, when it is used with dates
+- The parameterless <xref:System.DateTime.ToString?displayProperty=nameWithType> method.
+- The <xref:System.DateTime.ToString%28System.String%29?displayProperty=nameWithType> method, which includes a format string.
+- The parameterless <xref:System.DateTimeOffset.ToString?displayProperty=nameWithType> method.
+- The <xref:System.DateTimeOffset.ToString%28System.String%29?displayProperty=nameWithType>, which includes a format string.
+- The [composite formatting](../../standard/base-types/composite-formatting.md) feature, when it is used with dates.
 
 The following example displays sunrise and sunset data twice for October 11, 2012. It first sets the current culture to Croatian (Croatia), and then to English (United Kingdom). In each case, the dates and times are displayed in the format that is appropriate for that culture.
 

docs/csharp/language-reference/tokens/interpolated.md

@@ -29,16 +29,16 @@ To identify a string literal as an interpolated string, prepend it with the `$`
 The structure of an item with an interpolation expression is as follows:
 
 ```csharp
-{<interpolationExpression>[,<alignment>][:<formatString>]}
+{<interpolationExpression>[,<width>][:<formatString>]}
 ```
 
 Elements in square brackets are optional. The following table describes each element:
 
-| Element | Description |
-|--|--|
+| Element                   | Description |
+|---------------------------|-------------|
 | `interpolationExpression` | The expression that produces a result to be formatted. When the expression is `null`, the output is the empty string (<xref:System.String.Empty?displayProperty=nameWithType>). |
-| `alignment` | The constant expression whose value defines the minimum number of characters in the string representation of the expression result. If positive, the string representation is right-aligned; if negative, left-aligned. For more information, see the [Alignment component](../../../standard/base-types/composite-formatting.md#alignment-component) section of the [Composite formatting](../../../standard/base-types/composite-formatting.md) article. |
-| `formatString` | A format string supported by the type of the expression result. For more information, see the [Format string component](../../../standard/base-types/composite-formatting.md#format-string-component) section of the [Composite formatting](../../../standard/base-types/composite-formatting.md) article. |
+| `width`               | The constant expression whose value defines the minimum number of characters in the string representation of the expression result. If positive, the string representation is right-aligned; if negative, left-aligned. For more information, see the [Width component](../../../standard/base-types/composite-formatting.md#width-component) section of the [Composite formatting](../../../standard/base-types/composite-formatting.md) article. |
+| `formatString`            | A format string supported by the type of the expression result. For more information, see the [Format string component](../../../standard/base-types/composite-formatting.md#format-string-component) section of the [Composite formatting](../../../standard/base-types/composite-formatting.md) article. |
 
 The following example uses optional formatting components described in the preceding table:
 
@@ -95,7 +95,7 @@ If you're new to string interpolation, see the [String interpolation in C#](../.
 The compiler checks if an interpolated string is assigned to a type that satisfies the [_interpolated string handler pattern_](~/_csharplang/proposals/csharp-10.0/improved-interpolated-strings.md#the-handler-pattern). An _interpolated string handler_ is a type that converts the interpolated string into a result string. When an interpolated string has the type `string`, it's processed by the <xref:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler?displayProperty=fullName>. For the example of a custom interpolated string handler, see the [Write a custom string interpolation handler](../../advanced-topics/performance/interpolated-string-handler.md) tutorial. Use of an interpolated string handler is an advanced scenario, typically required for performance reasons.
 
 > [!NOTE]
-> One side effect of interpolated string handlers is that a custom handler, including <xref:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler?displayProperty=nameWithType>, may not evaluate all the interpolation expressions within the interpolated string under all conditions. That means side effects of those expressions may not occur.
+> One side effect of interpolated string handlers is that a custom handler, including <xref:System.Runtime.CompilerServices.DefaultInterpolatedStringHandler?displayProperty=nameWithType>, might not evaluate all the interpolation expressions within the interpolated string under all conditions. That means side effects of those expressions might not occur.
 
 If an interpolated string has the type `string`, it's typically transformed into a <xref:System.String.Format%2A?displayProperty=nameWithType> method call. The compiler can replace <xref:System.String.Format%2A?displayProperty=nameWithType> with <xref:System.String.Concat%2A?displayProperty=nameWithType> if the analyzed behavior would be equivalent to concatenation.
 

docs/csharp/programming-guide/strings/index.md

@@ -108,7 +108,7 @@ A format string is a string whose contents are determined dynamically at run tim
 
 You declare [*Interpolated strings*](../../language-reference/tokens/interpolated.md) with the `$` special character. An interpolated string includes interpolated expressions in braces. If you're new to string interpolation, see the [String interpolation - C# interactive tutorial](../../tutorials/exploration/interpolated-strings.yml) for a quick overview.
 
-Use string interpolation to improve the readability and maintainability of your code. String interpolation achieves the same results as the `String.Format` method, but improves ease of use and inline clarity.
+Use string interpolation to improve the readability and maintainability of your code. String interpolation achieves the same results as the `String.Format` method, but is easier to use and improves inline clarity.
 
 :::code language="csharp" source="./snippets/StringInterpolation.cs" id="StringInterpolation":::
 
@@ -132,7 +132,7 @@ The <xref:System.String.Format%2A?displayProperty=nameWithType> utilizes placeho
 
 :::code language="csharp" source="./snippets/StringInterpolation.cs" id="StringFormat":::
 
-For more information on formatting .NET types, see [Formatting Types in .NET](../../../standard/base-types/formatting-types.md).
+For more information, see [Composite formatting in .NET](../../../standard/base-types/composite-formatting.md).
 
 ## Substrings
 

docs/csharp/tutorials/string-interpolation.md

@@ -25,7 +25,7 @@ Interpolated strings support all the capabilities of the [string composite forma
 
 ## How to specify a format string for an interpolation expression
 
-To specify a format string that is supported by the type of the expression result, follow the interpolation expression with a colon (":") and the format string:
+To specify a format string that's supported by the type of the expression result, follow the interpolation expression with a colon (":") and the format string:
 
 ```csharp
 {<interpolationExpression>:<formatString>}
@@ -42,24 +42,24 @@ For more information, see the [Format string component](../../standard/base-type
 To specify the minimum field width and the alignment of the formatted expression result, follow the interpolation expression with a comma (",") and the constant expression:
 
 ```csharp
-{<interpolationExpression>,<alignment>}
+{<interpolationExpression>,<width>}
 ```
 
-If the *alignment* value is positive, the formatted expression result is right-aligned; if negative, it's left-aligned.
+If the *width* value is positive, the formatted expression result is right-aligned; if negative, it's left-aligned.
 
-If you need to specify both alignment and a format string, start with the alignment component:
+If you need to specify both width and a format string, start with the width component:
 
 ```csharp
-{<interpolationExpression>,<alignment>:<formatString>}
+{<interpolationExpression>,<width>:<formatString>}
 ```
 
-The following example shows how to specify alignment and uses pipe characters ("|") to delimit text fields:
+The following example shows how to specify width and alignment, and uses pipe characters ("|") to delimit text fields:
 
 :::code language="csharp" interactive="try-dotnet-method" source="./snippets/StringInterpolation/Program.cs" id="AlignmentAndFormatString":::
 
-As the example output shows, if the length of the formatted expression result exceeds specified field width, the *alignment* value is ignored.
+As the example output shows, if the length of the formatted expression result exceeds specified field width, the *width* value is ignored.
 
-For more information, see the [Alignment component](../../standard/base-types/composite-formatting.md#alignment-component) section of the [Composite formatting](../../standard/base-types/composite-formatting.md) article.
+For more information, see the [Width component](../../standard/base-types/composite-formatting.md#width-component) section of the [Composite formatting](../../standard/base-types/composite-formatting.md) article.
 
 ## How to use escape sequences in an interpolated string
 

docs/framework/configure-apps/file-schema/runtime/timespan-legacyformatmode-element.md

@@ -16,7 +16,7 @@ Determines whether the runtime preserves legacy behavior in formatting operation
 
 [**\<configuration>**](../configuration-element.md)\
 &nbsp;&nbsp;[**\<runtime>**](runtime-element.md)\
-&nbsp;&nbsp;&nbsp;&nbsp;**\<TimeSpan_LegacyFormatMode>**  
+&nbsp;&nbsp;&nbsp;&nbsp;**\<TimeSpan_LegacyFormatMode>**
 
 ## Syntax
 
@@ -37,27 +37,27 @@ The following sections describe attributes, child elements, and parent elements.
 
 ## enabled Attribute
 
-|Value|Description|
-|-----------|-----------------|
-|`false`|The runtime does not restore legacy formatting behavior.|
-|`true`|The runtime restores legacy formatting behavior.|
+| Value   | Description                                              |
+|---------|----------------------------------------------------------|
+| `false` | The runtime does not restore legacy formatting behavior. |
+| `true`  | The runtime restores legacy formatting behavior.         |
 
 ### Child Elements
 
 None.
 
 ### Parent Elements
 
-|Element|Description|
-|-------------|-----------------|
-|`configuration`|The root element in every configuration file used by the common language runtime and .NET Framework applications.|
-|`runtime`|Contains information about runtime initialization options.|
+| Element         | Description                                                |
+|-----------------|------------------------------------------------------------|
+| `configuration` | The root element in every configuration file used by the common language runtime and .NET Framework applications. |
+| `runtime`       | Contains information about runtime initialization options. |
 
 ## Remarks
 
-Starting with the .NET Framework 4, the <xref:System.TimeSpan?displayProperty=nameWithType> structure implements the <xref:System.IFormattable> interface and supports formatting operations with standard and custom format strings. If a parsing method encounters an unsupported format specifier or format string, it throws a <xref:System.FormatException>.
+Starting with .NET Framework 4, the <xref:System.TimeSpan?displayProperty=nameWithType> structure implements the <xref:System.IFormattable> interface and supports formatting operations with standard and custom format strings. If a parsing method encounters an unsupported format specifier or format string, it throws a <xref:System.FormatException>.
 
-In previous versions of the .NET Framework, the <xref:System.TimeSpan> structure did not implement <xref:System.IFormattable> and did not support format strings. However, many developers mistakenly assumed that <xref:System.TimeSpan> did support a set of format strings and used them in [composite formatting operations](../../../../standard/base-types/composite-formatting.md) with methods such as <xref:System.String.Format%2A?displayProperty=nameWithType>. Ordinarily, if a type implements <xref:System.IFormattable> and supports format strings, calls to formatting methods with unsupported format strings usually throw a <xref:System.FormatException>. However, because <xref:System.TimeSpan> did not implement <xref:System.IFormattable>, the runtime ignored the format string and instead called the <xref:System.TimeSpan.ToString?displayProperty=nameWithType> method. This means that, although the format strings had no effect on the formatting operation, their presence did not result in a <xref:System.FormatException>.
+In previous versions of .NET Framework, the <xref:System.TimeSpan> structure did not implement <xref:System.IFormattable> and did not support format strings. However, many developers mistakenly assumed that <xref:System.TimeSpan> did support a set of format strings and used them in [composite formatting operations](../../../../standard/base-types/composite-formatting.md) with methods such as <xref:System.String.Format%2A?displayProperty=nameWithType>. Ordinarily, if a type implements <xref:System.IFormattable> and supports format strings, calls to formatting methods with unsupported format strings usually throw a <xref:System.FormatException>. However, because <xref:System.TimeSpan> did not implement <xref:System.IFormattable>, the runtime ignored the format string and instead called the <xref:System.TimeSpan.ToString?displayProperty=nameWithType> method. This means that, although the format strings had no effect on the formatting operation, their presence did not result in a <xref:System.FormatException>.
 
 For cases in which legacy code passes a composite formatting method and an invalid format string, and that code cannot be recompiled, you can use the `<TimeSpan_LegacyFormatMode>` element to restore the legacy <xref:System.TimeSpan> behavior. When you set the `enabled` attribute of this element to `true`, the composite formatting method results in a call to <xref:System.TimeSpan.ToString?displayProperty=nameWithType> rather than <xref:System.TimeSpan.ToString%28System.String%2CSystem.IFormatProvider%29?displayProperty=nameWithType>, and a <xref:System.FormatException> is not thrown.
 
@@ -68,7 +68,7 @@ The following example instantiates a <xref:System.TimeSpan> object and attempts
 [!code-csharp[TimeSpan.BreakingChanges#1](../../../../../samples/snippets/csharp/VS_Snippets_CLR/timespan.breakingchanges/cs/legacyformatmode1.cs#1)]
 [!code-vb[TimeSpan.BreakingChanges#1](../../../../../samples/snippets/visualbasic/VS_Snippets_CLR/timespan.breakingchanges/vb/legacyformatmode1.vb#1)]
 
-When you run the example on the .NET Framework 3.5 or on an earlier version, it displays the following output:
+When you run the example on .NET Framework 3.5 or on an earlier version, it displays the following output:
 
 ```console
 12:30:45
@@ -80,7 +80,7 @@ This differs markedly from the output if you run the example on the .NET Framewo
 Invalid Format
 ```
 
-However, if you add the following configuration file to the example's directory and then run the example on the .NET Framework 4 or later version, the output is identical to that produced by the example when it is run on .NET Framework 3.5.
+However, if you add the following configuration file to the example's directory and then run the example on .NET Framework 4 or a later version, the output is identical to that produced by the example when it is run on .NET Framework 3.5.
 
 ```xml
 <?xml version ="1.0"?>

docs/fundamentals/runtime-libraries/includes/interpolated-strings.md

@@ -1,2 +1,2 @@
 > [!IMPORTANT]
-> Instead of calling the **String.Format** method or using [composite format strings](../../../standard/base-types/composite-formatting.md), you can use *interpolated strings* if your language supports them. An interpolated string is a string that contains *interpolated expressions*. Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. For more information, see [String interpolation (C# Reference)](../../../csharp/language-reference/tokens/interpolated.md) and [Interpolated Strings (Visual Basic Reference)](../../../visual-basic/programming-guide/language-features/strings/interpolated-strings.md).
+> Instead of calling the **String.Format** method or using [composite format strings](../../../standard/base-types/composite-formatting.md), you can use *interpolated strings* if your language supports them. An interpolated string is a string that contains *interpolated expressions*. Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. For more information, see [String interpolation (C# Reference)](../../../csharp/language-reference/tokens/interpolated.md) and [Interpolated strings (Visual Basic Reference)](../../../visual-basic/programming-guide/language-features/strings/interpolated-strings.md).

docs/fundamentals/runtime-libraries/system-double.md

@@ -191,7 +191,7 @@ The <xref:System.Double> structure and related types provide methods to perform
 
 - **Rounding**. Rounding is often used as a technique for reducing the impact of differences between values caused by problems of floating-point representation and precision. You can round a <xref:System.Double> value by calling the <xref:System.Math.Round%2A?displayProperty=nameWithType> method.
 
-- **Formatting**. You can convert a <xref:System.Double> value to its string representation by calling the <xref:System.Double.ToString%2A> method or by using the composite formatting feature. For information about how format strings control the string representation of floating-point values, see the [Standard Numeric Format Strings](../../standard/base-types/standard-numeric-format-strings.md) and [Custom Numeric Format Strings](../../standard/base-types/custom-numeric-format-strings.md) topics.
+- **Formatting**. You can convert a <xref:System.Double> value to its string representation by calling the <xref:System.Double.ToString%2A> method or by using the composite formatting feature. For information about how format strings control the string representation of floating-point values, see [Standard Numeric Format Strings](../../standard/base-types/standard-numeric-format-strings.md) and [Custom Numeric Format Strings](../../standard/base-types/custom-numeric-format-strings.md).
 
 - **Parsing strings**. You can convert the string representation of a floating-point value to a <xref:System.Double> value by calling either the <xref:System.Double.Parse%2A> or <xref:System.Double.TryParse%2A> method. If the parse operation fails, the <xref:System.Double.Parse%2A> method throws an exception, whereas the <xref:System.Double.TryParse%2A> method returns `false`.