[v3] Add level one headings to Markdown files.

All Markdown files should, from this point on, start with a level one heading.
See exercism/configlet#150 for the rationale behind these changes.

The full specification can be found [here](https://github.com/exercism/docs/blob/main/contributing/standards/markdown.md).

concepts/arrays/about.md

@@ -1,3 +1,5 @@
+# About
+
 TODO: about.md files and links.json files are the same for arrays, for-loops and foreach. Consider how to prise these apart of otherwise treat these closely coupled concepts.
 Data structures that can hold zero or more elements are known as _collections_. An **array** is a collection that has a fixed size/length and whose elements must all be of the same type. Elements can be assigned to an array or retrieved from it using an index. C# arrays are zero-based, meaning that the first element's index is always zero:
 

concepts/arrays/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 In C#, data structures that can hold zero or more elements are known as _collections_. An **array** is a collection that has a fixed size/length and whose elements must all be of the same type. Elements can be assigned to an array or retrieved from it using an index. C# arrays are zero-based, meaning that the first element's index is always zero:
 
 ```csharp

concepts/attributes/about.md

@@ -1,3 +1,5 @@
+# About
+
 A [C# `Attribute`][attribute-concept] provides a way to decorate a declaration to associate metadata to: a class, a method, an enum, a field, a property or any [other supported][attribute-targets] declarations.
 
 You can apply [an attribute][attribute] to a declaration by adding it between brackets `[]` before the declaration, the following example uses both a `ClassAttribute` and a `FieldAttribute`:

concepts/attributes/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 A [C# `Attribute`](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/) provides a way to decorate a declaration to associate metadata to: a class, a method, an enum, a field, a property or any [other supported](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/attributes/#attribute-targets) declarations.
 
 You can apply an attribute by adding it on the line before the declaration using a `ClassAttribute` and a `FieldAttribute`:

concepts/basics/about.md

@@ -1,3 +1,5 @@
+# About
+
 C# is a statically-typed language, which means that everything has a type at compile-time. Choosing a name for a [variable][variable] is referred to as defining a variable. Once a variable is defined, setting or updating a value is called variable assignment. A variable can be defined either by explicitly specifying its type, or by using the [`var` keyword][var] to have the C# compiler infer its type based on the assigned value. The use of `var` is known as _type inference_.
 
 ```csharp

concepts/basics/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 C# is a statically-typed language, which means that everything has a type at compile-time. Assigning a value to a name is referred to as defining a variable. A variable can be defined either by explicitly specifying its type, or by letting the C# compiler infer its type based on the assigned value (known as _type inference_). Therefore, the following two variable definitions are equivalent:
 
 ```csharp

concepts/bit-manipulation/about.md

@@ -1,3 +1,5 @@
+# About
+
 TODO: See #2112. We need to reconsider the text below now that it is a stand alone concept or maybe bitwise manipulation should be introduced in a separate exercise and the flag-enums exercise and concept should take that as a dependency showing how bitwise manipulation is used in the context of enums.
 
 To allow a single enum instance to represent multiple values (usually referred to as _flags_), one can annotate the enum with the `[Flags]` attribute. By carefully assigning the values of the enum members such that specific bits are set to `1`, bitwise operators can be used to set or unset flags.

concepts/bit-manipulation/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 TODO: add introduction for bit-manipulation concept

concepts/booleans/about.md

@@ -1,3 +1,5 @@
+# About
+
 Booleans in C# are represented by the `bool` type, which values can be either `true` or `false`.
 
 C# supports three [boolean operators][operators]: `!` (NOT), `&&` (AND), and `||` (OR). The `&&` and `||` operators use _short-circuit evaluation_, which means that the right-hand side of the operator is only evaluated when needed.

concepts/booleans/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 Booleans in C# are represented by the `bool` type, which values can be either `true` or `false`.
 
 C# supports three boolean operators: `!` (NOT), `&&` (AND), and `||` (OR).

concepts/casting/about.md

@@ -1,3 +1,5 @@
+# About
+
 Casting and type conversion [are different ways of changing an expression from one data type to another][wiki-casting].
 
 The [C# documentation][type-testing-and-cast-operators] classifies type conversion as the use of the [`as` operator][as-operator] or [`is` operator][is-operator]. Casting is defined as the use of the [cast operator][cast-operator].

concepts/casting/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 Casting and type conversion are different ways of changing an expression from one data type to another.
 
 An expression can be cast to another type with the cast operator `(<type>)`.

concepts/chars/about.md

@@ -1,3 +1,5 @@
+# About
+
 `char`s are generally easy to use. They can be extracted from strings, added back
 (by means of a string builder), defined and initialised using literals with single quotes, as in `char ch = 'A';`
 , assigned and compared.

concepts/chars/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 The C# `char` type is a 16 bit quantity to represent the smallest addressable components of text.
 Multiple `char`s can comprise a string such as `"word"` or `char`s can be
 processed independently. Their literals have single quotes e.g. `'A'`.

concepts/classes/about.md

@@ -1,3 +1,5 @@
+# About
+
 The primary object-oriented construct in C# is the _class_, which is a combination of data ([_fields_][fields]) and behavior ([_methods_][methods]). The fields and methods of a class are known as its _members_.
 
 Access to members can be restricted through access modifiers, the two most common ones being:

concepts/classes/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 The primary object-oriented construct in C# is the _class_, which is a combination of data (_fields_) and behavior (_methods_). The fields and methods of a class are known as its _members_.
 
 Access to members can be restricted through access modifiers, the two most common ones being:

concepts/compound-assignment/about.md

@@ -1,3 +1,5 @@
+# About
+
 TODO: See issue #2112. I think we need a different exercise to introduce compound assignments (one that shows it being used in a more conventional numeric or string context. flag-enums could then take that as a dependency and show how it is used in this more unusual context.
 
 The bitwise operators can also be used as [compound assignments][compound-assignment], which are a shorthand notation where `x = op y` can be written as `x op= y`:

concepts/compound-assignment/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 TODO: add introduction for compound-assignment concept

concepts/const-readonly/about.md

@@ -1 +1,3 @@
+# About
+
 TODO: add information on const-readonly concept

concepts/const-readonly/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 TODO: add introduction for const-readonly concept

concepts/constants/about.md

@@ -1,3 +1,5 @@
+# About
+
 #### const
 
 The [`const`][constants] modifier can be (and generally should be) applied to any field where its value is known at compile time and will not change during the lifetime of the program.

concepts/constants/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 The `const` modifier can be (and generally should be) applied to any field where its value is known at compile time and will not change during the lifetime of the program.
 
 ```csharp

concepts/constructors/about.md

@@ -1,3 +1,5 @@
+# About
+
 Creating an instance of a _class_ is done by calling its [_constructor_][constructors] through the [`new` operator][new]. A constructor is a special type of method whose goal is to initialize a newly created instance. [Constructors look like regular methods][constructor-syntax], but without a return type and with a name that matches the classes' name.
 
 ```csharp

concepts/constructors/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 Creating an instance of a _class_ is done by calling its _constructor_ through the `new` operator. A constructor is a special type of method whose goal is to initialize a newly created instance. Constructors look like regular methods, but without a return type and with a name that matches the classes' name.
 
 ```csharp

concepts/datetimes/about.md

@@ -1,3 +1,5 @@
+# About
+
 A `DateTime` in C# is an immutable object that contains both date _and_ time information. The date and time information can be accessed through its built-in [properties][properties].
 
 Manipulating a `DateTime` can be done by calling one of its [methods][methods]. As `DateTime` values can never change after having been defined, all methods that appear to modify a `DateTime` will actually return a new `DateTime`.

concepts/datetimes/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 A `DateTime` in C# is an immutable object that contains both date _and_ time information. `DateTime` instances are manipulated by calling their methods. Once a `DateTime` has been constructed, its value can never change. Any methods that appear to modify a `DateTime` will actually return a new `DateTime`.
 
 The textual representation of dates and times is dependent on the _culture_. Consider a `DateTime` with its date set to March 28 2019 and its time set to 14:30:59. Converting this `DateTime` to a `string` when using the `en-US` culture (American English) returns `"3/28/19 2:30:59 PM"`. When using the `fr-BE` culture (Belgian French), the same code returns a different value: `"28/03/19 14:30:59"`.

concepts/defensive-copying/about.md

@@ -1,3 +1,5 @@
+# About
+
 Imagine you have a code-base of several hundred thousand lines. You are passed the dictionary of developers into some method you are developing. Perhaps you have been tasked with printing out details of privileged developers. You decide to blank out the eye color in the dictionary to protect the developers' privacy. Unless a [deep copy][so-deep-copy] of the dictionary was made in the `Authenticator.GetDevelopers()` method, or, even better, it was wrapped in a read-only collection then you will have just trashed the authenticator.
 
 This follows the principle of [defensive copying][defensive-copying]. You can make sure your formal API is not circumvented by avoiding exposure to callers of internal writeable state.

concepts/defensive-copying/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 In security sensitive situations (or even simply on a large code-base where developers have different priorities and agendas) you should avoid allowing a class's public API to be circumvented by accepting and storing a method's mutable parameters or by exposing a mutable member of a class through a return value or as an `out` parameter.

concepts/dictionaries/about.md

@@ -1,3 +1,5 @@
+# About
+
 Dictionaries, like their equivalents in other languages such as maps or associative arrays, store key/value pairs such that a value can be retrieved or changed directly by passing the key to the dictionary's indexer property.
 
 In addition key/value pairs can be added and removed from the dictionary. Keys, values and key/value pairs can be enumerated.

concepts/dictionaries/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 A dictionary is a collection of elements where each element comprises a key and value such that if a key is passed to a method of the dictionary its associated value is returned. It has the same role as maps or associative arrays do in other languages.
 
 A dictionary can be created as follows:

concepts/do-while-loops/about.md

@@ -1,3 +1,5 @@
+# About
+
 To repeatedly execute logic, one can use loops. If the code in a loop should always be executed at least one, a `do/while` loop can be used:
 
 ```csharp

concepts/do-while-loops/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 An less commonly used alternative to the above syntax is a `do-while` loop:
 
 ```csharp

concepts/enumerables/about.md

@@ -1 +1,3 @@
+# About
+
 TODO: complete document

concepts/enumerables/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 TODO: complete document

concepts/enums/about.md

@@ -1,3 +1,5 @@
+# About
+
 You can use [Enumeration types][enumeration types] whenever you have a fixed set of constant values. Using an `enum` gives one a type-safe way of interacting with constant values. Defining an enum is done through the `enum` keyword. An enum member is referred to by prepending it with the enum name and a dot (e.g. `Status.Active`).
 
 Each enum member is an association of a name and an `int` value. If the first member does not have an explicit value, its value is set to `0`. If no value is explicitly defined for an enum member, its value is automatically assigned to the previous member's value plus `1`.

concepts/enums/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 The C# `enum` type represents a fixed set of named constants (an enumeration). Its chief purpose is to provide a type-safe way of interacting with numeric constants, limiting the available values to a pre-defined set. A simple enum can be defined as follows:
 
 ```csharp

concepts/equality/about.md

@@ -1,3 +1,5 @@
+# About
+
 The coding exercise illustrates a number of properties of equality in C#:
 
 ### `Object.Equals()`

concepts/equality/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 Simple types (strings and primitives) are typically tested for equality with the `==` and `!=`.
 
 Reference types (Instances of classes) are compared using the `Equals()` method inherited from `Object`. If your goal with the equality test is to ensure that two objects are the exact same instance then relying on `Object`'s implementation will suffice. If not, you need to override `object.Equals()`.

concepts/exception-filtering/about.md

@@ -1,3 +1,5 @@
+# About
+
 TODO: This may need a more rounded introduction to filtering here.
 `when` is the keyword in filtering exceptions. It is placed after the catch
 statement and can take a boolean expression containing any values in scope at the time. They don't just have to be members of the exception itself. If the type of the exception matches and the expression evaluates to true then the block associated with that `catch` statement is executed otherwise the next `catch` statement, if any, is checked.

concepts/exception-filtering/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 `when` is the key word in filtering exceptions. It is placed after the catch
 statement and can take a boolean expression containing any values in scope at the time. If the expression evaluates to true then the block associated with that `catch` statement is executed otherwise the next `catch` statement, if any, is checked.
 

concepts/exceptions/about.md

@@ -1,3 +1,5 @@
+# About
+
 It is important to note that `exceptions` should be used in cases where something exceptional happens, an error that needs special handeling. It should not be used for control-flow of a program, as that is considered bad design, which often leads to bad performance and maintainability.
 
 Some of the more common exceptions include `IndexOutOfRangeException`, `ArgumentOutOfRangeException`, `NullReferenceException`, `StackOverflowException`, `ArgumentException`, `InvalidOperationException` and `DivideByZeroException`.

concepts/exceptions/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 Exceptions in C# provide a structured, uniform, and type-safe way of handling error conditions that occur during runtime. Proper handling of exceptions and error is important when trying to prevent application crashes.
 
 In C#, all exceptions have `System.Exception` class as their base type. It contains important properties such as `Message`, which contains a human-readable description of the reason for the exception being thrown.

concepts/explicit-casts/about.md

@@ -1 +1,3 @@
+# About
+
 TODO: add information on explicit-casts concept

concepts/explicit-casts/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 TODO: add introduction for explicit-casts concept

concepts/expression-bodied-members/about.md

@@ -1,3 +1,5 @@
+# About
+
 Many [types of struct and class members][expression-bodied-members] (fields being the primary exception) can use the expression-bodied member syntax. Defining a member with an expression often produces more concise and readable code than traditional blocks/statements.
 
 ```csharp

concepts/expression-bodied-members/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 Many types of struct and class members (fields being the primary exception) can use the expression-bodied member syntax. Defining a member with an expression often produces more concise and readable code than traditional blocks/statements.
 
 Methods and read-only properties are amongst the members that can be defined with expression bodies.

concepts/flag-enums/about.md

@@ -1,3 +1,5 @@
+# About
+
 To allow a single enum instance to represent multiple values (usually referred to as _flags_), one can annotate the enum with the `[Flags]` attribute. By carefully assigning the values of the enum members such that specific bits are set to `1`, bitwise operators can be used to set or unset flags.
 
 ```csharp

concepts/flag-enums/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 The C# [`enum` type](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/enum) represents a fixed set of named constants (an enumeration).
 
 Normally, one `enum` member can only refer to exactly one of those named constants. However, sometimes it is useful to refer to more than one constant. To do so, one can annotate the `enum` with the [`Flags` attribute](https://docs.microsoft.com/en-us/dotnet/api/system.flagsattribute?view=net-5.0). A _flags_ enum's constants are interpreted as bitwise _flags_ and therefor indicates the enum supports the bitwise operators and additional features like the method `Enum.HasFlag()`.

concepts/floating-point-numbers/about.md

@@ -1,3 +1,5 @@
+# About
+
 There are three floating-point types in C#: `double`, `float` and `decimal`. The most commonly used type is `double`, whereas `decimal` is normally used when working with monetary data. A `double` is written as `2.45` or `2.45d`, a `float` as `2.45f` and a decimal as `2.45m`.
 
 Each floating-point type has its own [precision, approximate range and size][docs-microsoft.com-characteristics-of-the-floating-point-types].

concepts/floating-point-numbers/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 A floating-point number is a number with zero or more digits behind the decimal separator. Examples are `-2.4`, `0.1`, `3.14`, `16.984025` and `1024.0`.
 
 Different floating-point types can store different numbers of digits after the digit separator - this is referred to as its precision.

concepts/for-loops/about.md

@@ -1,3 +1,5 @@
+# About
+
 TODO: about.md files and links.json files are the same for arrays, for-loops and foreach. Consider how to prise these apart of otherwise treat these closely coupled concepts.
 Data structures that can hold zero or more elements are known as _collections_. An **array** is a collection that has a fixed size/length and whose elements must all be of the same type. Elements can be assigned to an array or retrieved from it using an index. C# arrays are zero-based, meaning that the first element's index is always zero:
 

concepts/for-loops/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 If you want more control over which values to iterate over, a `for` loop can be used:
 
 ```csharp

concepts/foreach-loops/about.md

@@ -1,3 +1,5 @@
+# About
+
 TODO: about.md files and links.json files are the same for arrays, for-loops and foreach. Consider how to prise these apart of otherwise treat these closely coupled concepts.
 Data structures that can hold zero or more elements are known as _collections_. An **array** is a collection that has a fixed size/length and whose elements must all be of the same type. Elements can be assigned to an array or retrieved from it using an index. C# arrays are zero-based, meaning that the first element's index is always zero:
 

concepts/foreach-loops/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 The fact that an array is also a _collection_ means that, besides accessing values by index, you can iterate over _all_ its values using a `foreach` loop:
 
 ```csharp

concepts/generic-types/about.md

@@ -1,3 +1,5 @@
+# About
+
 Lists are an example of generic classes. You will also see `HashSet<T>` and `Dictionary<T>` in early exercises.
 
 More [advanced generic techniques][generics] are discussed in (TODO cross-ref-tba) including creating your own generics.

concepts/generic-types/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 A collection definition typically includes a place holder in angle brackets, often `T` by convention. Such a collection is referred to as a generic type. This allows the collection user to specify what type of items to store in the collection. In the above example code we are instantiating a list of strings.

concepts/if-statements/about.md

@@ -1,3 +1,5 @@
+# About
+
 An `if` statement can be used to conditionally execute code. The condition of an `if` statement must be of type `bool`. C# has no concept of _truthy_ values.
 
 The most common way to do this in C# is by using [an `if/else` statement][if-else]:

concepts/if-statements/introduction.md

@@ -1,3 +1,5 @@
+# Introduction
+
 In this exercise you must conditionally execute logic. The most common way to do this in C# is by using an `if/else` statement:
 
 ```csharp

concepts/indexers/about.md

@@ -1 +1,3 @@
+# About
+
 TODO: add information on indexers concept

concepts/indexers/introduction.md

@@ -1 +1,3 @@
+# Introduction
+
 TODO: add introduction for indexers concept

concepts/inheritance/about.md

@@ -1,3 +1,5 @@
+# About
+
 In C#, a _class_ hierarchy can be defined using _inheritance_, which allows a derived class (`Car`) to inherit the behavior and data of its parent class (`Vehicle`). If no parent is specified, the class inherits from the `object` class.
 
 Parent classes can provide functionality to derived classes in three ways: