Remove references to "new" features introduced before C# 9 (#31333)

* Remove "beginning in C# 2"

Remove any version consideration for a feature that was introduced in C# 2.

In once instance, the description of delegate creation discussed syntax added in C# 3. Remove that as well.

* Remove references to C# 3

Several COM / Office interop samples show the syntax used before C# 4.0 Several reference to LINQ introduce it as a "new" feature.

* Remove "new" references to C# 4 features

These are mostly dynamic and COM interop features.

* Remove references to "new" C# 5.

When describing any features in C#, remove the version information.

* remove references to "new" in C# 6 features.

They are not "new" as of C# 11.

* Remove references to C# 7.x as "new" features

New features in C# 7 aren't "new" anymore.

* Remove references to C# 8 as "new" features

They are just C# features now.

* fix markdown lint issue

* add expected errors.

This reverts commit 4cafd60.

* add notes in code files for CI build error suppression

* Apply suggestions from code review

Co-authored-by: Petr Kulikov <[email protected]>

Co-authored-by: Petr Kulikov <[email protected]>

Author: BillWagner

docs/csharp/expression-trees-building.md

@@ -208,8 +208,8 @@ represented not by their C# constructs, but by constructs that represent the und
 logic that the compiler generates from these higher level constructs.
 
 Also, at this time, there are C# expressions that cannot be built directly
-using `Expression` class methods. In general, these will be the newest operators
-and expressions added in C# 5 and C# 6. (For example, `async` expressions cannot be built, and
+using `Expression` class methods. In general, these will be the any operators
+and expressions added in C# 5 and more recent versions. (For example, `async` expressions cannot be built, and
 the new `?.` operator cannot be directly created.)
 
 [Next -- Translating Expressions](expression-trees-translating.md)

docs/csharp/expression-trees-summary.md

@@ -26,7 +26,7 @@ translate that algorithm into another language or environment.
 There are some newer C# language elements that don't translate
 well into expression trees. Expression trees cannot contain
 `await` expressions, or `async` lambda expressions. Many of the
-features added in the C# 6 release don't appear exactly as written
+features added in C# 6 and later don't appear exactly as written
 in expression trees. Instead, newer features will be exposed
 in expressions trees in the equivalent, earlier syntax. This
 may not be as much of a limitation as you might think. In fact,

docs/csharp/fundamentals/coding-style/coding-conventions.md

@@ -263,7 +263,7 @@ The following declaration uses the full syntax.
 
   :::code language="csharp" source="./snippets/coding-conventions/program.cs" id="Snippet17b":::
 
-  In C# 8 and later versions, use the new [`using` syntax](../../language-reference/keywords/using-statement.md) that doesn't require braces:
+  Use the new [`using` syntax](../../language-reference/keywords/using-statement.md) that doesn't require braces:
 
   :::code language="csharp" source="./snippets/coding-conventions/program.cs" id="Snippet17c":::
 

docs/csharp/fundamentals/functional/deconstruct.md

@@ -11,7 +11,7 @@ A tuple provides a lightweight way to retrieve multiple values from a method cal
 
 Retrieving multiple field and property values from an object can be equally cumbersome: you must assign a field or property value to a variable on a member-by-member basis.
 
-In C# 7.0 and later, you can retrieve multiple elements from a tuple or retrieve multiple field, property, and computed values from an object in a single *deconstruct* operation. To deconstruct a tuple, you assign its elements to individual variables. When you deconstruct an object, you assign selected values to individual variables.
+You can retrieve multiple elements from a tuple or retrieve multiple field, property, and computed values from an object in a single *deconstruct* operation. To deconstruct a tuple, you assign its elements to individual variables. When you deconstruct an object, you assign selected values to individual variables.
 
 ## Tuples
 
@@ -52,7 +52,7 @@ You must assign each element of the tuple to a variable. If you omit any element
 
 ## Tuple elements with discards
 
-Often when deconstructing a tuple, you're interested in the values of only some elements. Starting with C# 7.0, you can take advantage of C#'s support for *discards*, which are write-only variables whose values you've chosen to ignore. A discard is chosen by an underscore character ("\_") in an assignment. You can discard as many values as you like; all are represented by the single discard, `_`.
+Often when deconstructing a tuple, you're interested in the values of only some elements. You can take advantage of C#'s support for *discards*, which are write-only variables whose values you've chosen to ignore. A discard is chosen by an underscore character ("\_") in an assignment. You can discard as many values as you like; all are represented by the single discard, `_`.
 
 The following example illustrates the use of tuples with discards. The `QueryCityDataForYears` method returns a six-tuple with the name of a city, its area, a year, the city's population for that year, a second year, and the city's population for that second year. The example shows the change in population between those two years. Of the data available from the tuple, we're unconcerned with the city area, and we know the city name and the two dates at design-time. As a result, we're only interested in the two population values stored in the tuple, and can handle its remaining values as discards.
 

docs/csharp/fundamentals/functional/discards.md

@@ -7,7 +7,7 @@ f1_keywords:
 ---
 # Discards - C# Fundamentals
 
-Starting with C# 7.0, C# supports discards, which are placeholder variables that are intentionally unused in application code. Discards are equivalent to unassigned variables; they don't have a value. A discard communicates intent to the compiler and others that read your code: You intended to ignore the result of an expression. You may want to ignore the result of an expression, one or more members of a tuple expression, an `out` parameter to a method, or the target of a pattern matching expression.
+Discards are placeholder variables that are intentionally unused in application code. Discards are equivalent to unassigned variables; they don't have a value. A discard communicates intent to the compiler and others that read your code: You intended to ignore the result of an expression. You may want to ignore the result of an expression, one or more members of a tuple expression, an `out` parameter to a method, or the target of a pattern matching expression.
 
 Discards make the intent of your code clear. A discard indicates that our code never uses the variable. They enhance its readability and maintainability.
 

docs/csharp/fundamentals/program-structure/main-command-line.md

@@ -30,7 +30,7 @@ For information about how to write application code with an implicit entry point
 
 - The `Main` method is the entry point of an executable program; it is where the program control starts and ends.
 - `Main` is declared inside a class or struct. `Main` must be [`static`](../../language-reference/keywords/static.md) and it need not be [`public`](../../language-reference/keywords/public.md). (In the earlier example, it receives the default access of [`private`](../../language-reference/keywords/private.md).) The enclosing class or struct is not required to be static.
-- `Main` can either have a `void`, `int`, or, starting with C# 7.1, `Task`, or `Task<int>` return type.
+- `Main` can either have a `void`, `int`, `Task`, or `Task<int>` return type.
 - If and only if `Main` returns a `Task` or `Task<int>`, the declaration of `Main` may include the [`async`](../../language-reference/keywords/async.md) modifier. This specifically excludes an `async void Main` method.
 - The `Main` method can be declared with or without a `string[]` parameter that contains command-line arguments. When using Visual Studio to create Windows applications, you can add the parameter manually or else use the <xref:System.Environment.GetCommandLineArgs> method to obtain the command-line arguments. Parameters are read as zero-indexed command-line arguments. Unlike C and C++, the name of the program is not treated as the first command-line argument in the `args` array, but it is the first element of the <xref:System.Environment.GetCommandLineArgs> method.
 

docs/csharp/fundamentals/tutorials/pattern-matching.md

@@ -6,7 +6,7 @@ ms.custom: contperf-fy21q1
 ---
 # Tutorial: Use pattern matching to build type-driven and data-driven algorithms
 
-C# 7 introduced basic pattern matching features. Those features are extended in C# 8 through C# 10 with new expressions and patterns. You can write functionality that behaves as though you extended types that may be in other libraries. Another use for patterns is to create functionality your application requires that isn't a fundamental feature of the type being extended.
+You can write functionality that behaves as though you extended types that may be in other libraries. Another use for patterns is to create functionality your application requires that isn't a fundamental feature of the type being extended.
 
 In this tutorial, you'll learn how to:
 

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. Beginning with C# 8.0, 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, auto-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/language-reference/attributes/general.md

@@ -82,7 +82,7 @@ The first <xref:System.AttributeUsageAttribute> argument must be one or more ele
 
 :::code language="csharp" source="snippets/NewPropertyOrFieldAttribute.cs" ID="SnippetDefinePropertyAttribute" :::
 
-Beginning in C# 7.3, attributes can be applied to either the property or the backing field for an auto-implemented property. The attribute applies to the property, unless you specify the `field` specifier on the attribute. Both are shown in the following example:
+Attributes can be applied to either the property or the backing field for an auto-implemented property. The attribute applies to the property, unless you specify the `field` specifier on the attribute. Both are shown in the following example:
 
 :::code language="csharp" source="snippets/NewPropertyOrFieldAttribute.cs" ID="SnippetUsePropertyAttribute" :::
 
@@ -102,7 +102,7 @@ You can also use these keywords to specify where an attribute should be applied.
 
 ## `AsyncMethodBuilder` attribute
 
-Beginning with C# 7, you add the <xref:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute?displayProperty=nameWithType> attribute to a type that can be an async return type. The attribute specifies the type that builds the async method implementation when the specified type is returned from an async method. The `AsyncMethodBuilder` attribute can be applied to a type that:
+You add the <xref:System.Runtime.CompilerServices.AsyncMethodBuilderAttribute?displayProperty=nameWithType> attribute to a type that can be an async return type. The attribute specifies the type that builds the async method implementation when the specified type is returned from an async method. The `AsyncMethodBuilder` attribute can be applied to a type that:
 
 * Has an accessible `GetAwaiter` method.
 * The object returned by the `GetAwaiter` method implements the <xref:System.Runtime.CompilerServices.ICriticalNotifyCompletion?displayProperty=nameWithType> interface.

docs/csharp/language-reference/attributes/nullable-analysis.md

@@ -14,7 +14,7 @@ These states enable the compiler to provide warnings when you may dereference a
 
 This article provides a brief description of each of the nullable reference type attributes and how to use them.
 
-Let's start with an example. Imagine your library has the following API to retrieve a resource string. This method was originally written before C# 8.0 and nullable annotations:
+Let's start with an example. Imagine your library has the following API to retrieve a resource string. This method was originally compiled in a *nullable oblivious* context:
 
 :::code language="csharp" source="snippets/NullableAttributes.cs" ID="TryGetExample" :::
 
@@ -24,7 +24,7 @@ The preceding example follows the familiar `Try*` pattern in .NET. There are two
 - Callers can pass a variable whose value is `null` as the argument for `message`.
 - If the `TryGetMessage` method returns `true`, the value of `message` isn't null. If the return value is `false,` the value of `message` is null.
 
-The rule for `key` can be expressed succinctly in C# 8.0: `key` should be a non-nullable reference type. The `message` parameter is more complex. It allows a variable that is `null` as the argument, but guarantees, on success, that the `out` argument isn't `null`. For these scenarios, you need a richer vocabulary to describe the expectations. The `NotNullWhen` attribute, described below describes the *null-state* for the argument used for the `message` parameter.
+The rule for `key` can be expressed succinctly: `key` should be a non-nullable reference type. The `message` parameter is more complex. It allows a variable that is `null` as the argument, but guarantees, on success, that the `out` argument isn't `null`. For these scenarios, you need a richer vocabulary to describe the expectations. The `NotNullWhen` attribute, described below describes the *null-state* for the argument used for the `message` parameter.
 
 > [!NOTE]
 > Adding these attributes gives the compiler more information about the rules for your API. When calling code is compiled in a nullable enabled context, the compiler will warn callers when they violate those rules. These attributes don't enable more checks on your implementation.