[v3] Markdown sub-headings must be parent level incremented by one.

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

Author: ErikSchierboom

concepts/casting/about.md

@@ -8,7 +8,7 @@ In C# very often, outside of the realm of numeric values and class hierarchies,
 
 Note that implicit an explicit cast [operators][operator-overloading] (discussed in (TODO cross-ref-tba)) are available which can bring fairly arbitrary casting to your own types.
 
-#### Casting Primitive Types - Implicit
+## Casting Primitive Types - Implicit
 
 C#'s type system is somewhat stricter than _C_'s or Javascript's and as a consequence, casting operations are more restricted. [Implicit casting][implicit-casts] takes place between two numeric types as long as the "to" type can preserve the scale and sign of the "from" type's value. Note in the documentation the exception for converting to real numbers where precision may be lost.
 
@@ -23,15 +23,15 @@ There is no implicit conversion of a numeric (or string) expression to `bool`. T
 
 An expression of type `char` can be implicitly cast to `int`. The cast in the opposite direction must be explicit. Not all values of `int` are valid utf 16 chars.
 
-#### Casting Primitive Types - Explicit
+## Casting Primitive Types - Explicit
 
 Where numeric types cannot be cast implicitly you can generally use the explicit cast [operator][cast-operator].
 
 Where the value being cast cannot be represented by the "to" type because it is insufficiently wide or there is a sign conflict then an overflow exception may be thrown in the case of integers, or the "to" type variable may take a value of `Infinity` in the case of floats and doubles.
 
 An expression of type `int` can be explicitly cast to `char`. This may result in an invalid `char`.
 
-#### Casting Primitive Types - Examples
+## Casting Primitive Types - Examples
 
 ```csharp
 int largeInt = Int32.MaxValue;
@@ -61,7 +61,7 @@ int fromString_bad = Int32.Parse("forty two");     // FormatException is thrown
 
 See this [article][checked] for the _**checked**_ keyword.
 
-#### Type Conversion for types in a hierarchy
+## Type Conversion for types in a hierarchy
 
 Any type can be implicitly converted to its base class or interface.
 
@@ -112,13 +112,13 @@ if (r is Foo foo3)
 
 The [`as`][as-operator] keyword fulfills a similar function to `is` e.g. `var foo = ifoo as Foo;`. In this example `foo` will be `null` if `ifoo` is not of type `Foo` otherwise `ifoo` will be assigned to it.
 
-#### Custom Cast Operator
+## Custom Cast Operator
 
 Types can define their own custom explicit and implicit [cast operators][custom-casts]. See (TODO cross-ref-tba) for coverage of this..
 
 Examples of [explicit][big-integer-explicit] and [implicit][big-integer-implicit] casts in the BCL is conversions from the `BigInteger` struct to and from other numeric types
 
-#### Using `typeof`
+## Using `typeof`
 
 If you need to detect the precise type of an object then `is` may be a little too permissive as it will convert an object to a class or any of its base classes. `typeof` and `Object.GetType()` are the solution in this case.
 

concepts/chars/about.md

@@ -14,7 +14,7 @@ These rough edges mostly relate to the opposition
 between the full unicode standard on the one side and historic representations
 of text as well as performance and memory usage on the other.
 
-### Unicode Issues
+## Unicode Issues
 
 When dealing with strings, if `System.String` library methods are available you should
 seek these out and use them rather than breaking the string down into characters.
@@ -45,15 +45,15 @@ is where you can use `String`'s library methods.
 If you do find yourself in the unenviable position of dealing with the minutiae of unicode
 then [this][char-encoding-net] is a good starting point.
 
-### Globalization
+## Globalization
 
 If you are working in an environment where you are dealing with multiple cultures or
 the culture is important in some parts of the code but not others then be
 aware of the overloads of [`ToUpper`][to-upper] and [`ToLower`][to-lower] which take a culture and
 [`ToUpperInvariant`][to-upper-invariant] and [`ToLowerInvariant`][to-lower-invariant] which will provide a consistent
 result irrespective of the current [culture][culture-info].
 
-### Representation, Characters and Integers
+## Representation, Characters and Integers
 
 Like other simple types (`int`s, `bool`s, etc.) the `char` has a companion
 or alias type, in this case, `System.Char`. This is in fact a `struct` with

concepts/constants/about.md

@@ -1,6 +1,6 @@
 # About
 
-#### const
+## 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.
 
@@ -27,7 +27,7 @@ public double Area(double r)
 
 Identifying a value with `const` in this way can be useful if it is used multiple times in the method or you want to draw attention to its meaning. There is no performance gain over using literals inline.
 
-#### readonly
+## readonly
 
 The [`readonly`][readonly-fields] modifier can be (and generally should be) applied to any field that cannot be made `const` where its value will not change during the lifetime of the program and is either set by an inline initializer or during instantiation (by the constructor or a method called by the constructor).
 

concepts/equality/about.md

@@ -2,9 +2,9 @@
 
 The coding exercise illustrates a number of properties of equality in C#:
 
-### `Object.Equals()`
+## `Object.Equals()`
 
-#### Topics covered by the coding exercise
+### Topics covered by the coding exercise
 
 - Simple types (strings and primitives) are typically tested for equality with the `==` and `!=`. This is considered more idiomatic than using the [`Equals()`][object-equals] method which is also available with these types. Java programmers should be alert, when dealing with strings, to the fact that `==` compares by value in C# but by reference in Java when returning to their former language.
 - 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()`.
@@ -48,7 +48,7 @@ ReferenceEquals(winA, winC);
 // => true
 ```
 
-#### Ancillary topics
+### Ancillary topics
 
 - In addition to `public override bool Equals(object obj)` IDEs typically generate the overload `protected bool Equals(FacialFeatures other)` for use when inheritance is involved. A derived class can call the base classe's `Equals()` and then add its own test.
 - Do not use `==` unless you have [overloaded][operator-overloading] the `==` operator, as well as the `Equals()` method in your class (see the `operator-overloading` exercise) or you care only that the references are equal.

concepts/equality/introduction.md

@@ -10,7 +10,7 @@ An overridden `Equals()` method will contain equality tests on members of simple
 
 The `Object` class provides appropriate methods to compare two objects to detect if they are one and the same instance.
 
-### `Object.GetHashCode()`
+## `Object.GetHashCode()`
 
 The `Object.GetHashCode()` method returns a hash code in the form of a 32 bit integer. The hash code is used by _dictionary_ and _set_ classes such as `Dictionary<T>` and `HashSet<T>`to store and retrieve objects in a performant manner.
 

concepts/integral-numbers/about.md

@@ -21,7 +21,7 @@ The types discussed so far are _primitive_ types. Each is paired with a `struct`
 | `uint`   | `UInt32` | 32 bit | 0                          | +4_294_967_295              |
 | `ulong`  | `UInt64` | 64 bit | 0                          | +18_446_744_073_709_551_615 |
 
-#### Casting
+## Casting
 
 A variable (or expression) of one type can easily be converted to another. For instance, in an assignment operation, if the type of the value being assigned (rhs) ensures that the value will fit within the range of the type being assigned to (lhs) then there is a simple assignment:
 
@@ -45,13 +45,13 @@ The requirement for casting is determined by the two types involved rather than
 
 The following paragraphs discuss the casting of integral types. (TODO cross-ref-tba casting) provides a broader discussion of casting and type conversion. See that documentation for a discussion of conversion between integral types and floating-point numbers, `char` and `bool`.
 
-##### Casting Primitive Types - Implicit
+### Casting Primitive Types - Implicit
 
 C#'s type system is somewhat stricter than _C_'s or Javascript's and as a consequence, casting operations are more restricted. [Implicit casting][implicit-casts] takes place between two numeric types as long as the "to" type can preserve the scale and sign of the "from" type's value.
 
 An implicit cast is not signified by any special syntax.
 
-##### Casting Primitive Types - Explicit
+### Casting Primitive Types - Explicit
 
 Where numeric types cannot be cast implicitly you can generally use the explicit cast [operator][cast-operator].
 

concepts/integral-numbers/introduction.md

@@ -31,6 +31,6 @@ short s = 42;
 uint ui = (uint)s;
 ```
 
-#### Bit conversion
+## Bit conversion
 
 The `BitConverter` class provides a convenient way of converting integer types to and from arrays of bytes.

concepts/interfaces/about.md

@@ -117,7 +117,7 @@ By design, C# does not support multiple inheritance, but it facilitates a kind o
 
 Moreover, the concept of [polymorphism can be implemented through interfaces][interface-polymorphism] underpins the interface mechanism.
 
-#### Explicit interface implementation
+## Explicit interface implementation
 
 Sometimes method names and signatures can be shared in two different interfaces.
 In order provide a distinct implementation of these methods, C# provides [explicit implementation of interfaces][explicit-implementation]. Note that to use a particular implementation of an interface you need to convert the expression containing referencing the object to that interface. Assignment, casting or passing as a parameter will achieve this.
@@ -166,7 +166,7 @@ There are a number of use cases:
 - Methods with the same name but different return types: if you implement your own collection classes you may find that an explicit interface for the legacy `IEnumerable.GetEnumerator()`, alongside `IEnumerable<T>.GetEnuerator()`, is required. You may never make use of such the interface but the compiler may insist.
 - Methods where there is no clash of names between interfaces but it is desirable that the implementing class uses the name for some related purpose: `IFormattable` has a `ToString()` method which takes a _format type_ parameter as well as parameter of type `IFormatProvider`. A class like `FormattableString` from the Base Class Library (BCL) has the interface to ensure it can be used by routines that take an `IFormattable` but it is more expressive for its main version of `ToString(IFormatProvider)` to omit the _format type_ parameter as it is not used in the implementation and would confuse API users.
 
-#### Default implementation
+## Default implementation
 
 Version 8 of C# addresses a nagging problem with APIs. If you add methods to an interface to enhance functionality for new implementations then it is necessary to modify all the existing implementations of the interface so that they comply with the API-contract even though they have no implementation specific behavior. C# now allows for a _default method_ to be provided as part of the interface (Java developers will be familiar). Previously, when such a change occurred a _version 2_ of the interface would exist alongside the original.
 

concepts/lists/about.md

@@ -13,7 +13,7 @@ A collection definition typically includes a place holder in angle brackets, oft
 
 Unlike arrays (TODO cross-ref-tba) lists can resize themselves dynamically.
 
-#### LINQ
+## LINQ
 
 Although the built-in API of `List<T>` is rich (including mappings and filters such as `ConvertAll`, `FindAll` and `Foreach`) and its [looping syntax][for-each] is very clear, and you definitely need to be familiar with this API, Language Integrated Query ([LINQ][linq]) is available for many tasks, is even more powerful and widely used and has the advantage of providing a consistent interface across library collections, third-party collections and your own classes. See (TODO cross-ref-tba).
 

concepts/namespaces/about.md

@@ -22,7 +22,7 @@ According to the [official documentation][namespaces] namespaces have two princi
 
 Namespaces are used widely by the base class library (BCL) to organize its functionality.
 
-#### References to namespaced types
+## References to namespaced types
 
 Types enclosed in namespaces are referred to outside the namespace by prefixing the type name with the dot syntax. Alternatively, and more usually, you can place a `using` directive at the top of the file (or within a namespace) and any types in the imported namespace can be used without the prefix. Within the same namespace there is no need to qualify type names.
 
@@ -68,13 +68,13 @@ This [article][using] clearly explains the ways in which the `using` directive c
 - `using static`: avoid having to qualify members with types (a good example is `Math.Max()`).
 - `using MyAlias = YourNamespace;`: substitute a more readable name for the namespace name.
 
-#### Clash of namespaces
+## Clash of namespaces
 
 .NET addresses the issue of two namespaces with the same name in different assemblies where there would be a clash of fully qualified identifier names (perhaps a scenario where multiple versions of an assembly are loaded). This issue is addressed with the [namespace alias qualifier][namespace-alias-qualifier] and the [extern alias][extern-alias].
 
 One reason to raise this fairly niche topic is because of its use of the [`::` operator][dot-dot-operator]. You will often see the qualifier `global::` prefixing namespaces, particularly in generated code. The intention here is to avoid a potential clash with some nested namespace or class name. By prefixing a namespace with `global::` you ensure that a top-level namespace is selected.
 
-#### Note for Java developers
+## Note for Java developers
 
 When comparing with the `import` of Java `packages` some differences and similarities should be noted: