Fixing code samples to C# with VS2015 highlighting (#108)

Author: SteveWilkes

docs/src/Assembly-Scanning.md

@@ -1,6 +1,6 @@
 By default, the assembly in which a base type is declared is searched for derived types. If there are additional assemblies which should be searched, use:
 
-```C#
+```cs
 Mapper.WhenMapping.LookForDerivedTypesIn(
     typeof(DerivedType1).Assembly,
     typeof(DerivedType2).Assembly);

docs/src/Cloning-Mappers.md

@@ -1,6 +1,6 @@
 Mappers can be cloned, to enable 'derived' mappers to inherit, add to and override a 'root' configuration:
 
-``` C#
+```cs
 var baseMapper = Mapper.CreateNew();
 
 // Setup the base configuration:

docs/src/Collections.md

@@ -23,7 +23,7 @@ Generic `List<T>` instances are created for interface-type members except `ISet<
 
 By default, if the source collection matching a target collection is null, the target collection is populated with an empty collection. You can configure setting the target collection to null instead like this:
 
-```C#
+```cs
 // Map null-source collections to null for all source
 // and target types:
 Mapper.WhenMapping.MapNullCollectionsToNull();

docs/src/Configuration-Classes.md

@@ -6,7 +6,7 @@ Multiple, dedicated configuration classes can be created by deriving from the ab
 
 Mapper configuration is set up by implementing the abstract `Configure` method:
 
-```C#
+```cs
 public class ProductMappingConfiguration : MapperConfiguration
 {
     protected override void Configure()
@@ -34,21 +34,21 @@ In this example the default mapper is configured - the one used via the [static]
 
 To apply a particular `MapperConfiguration` Type, supply it explicitly:
 
-```C#
+```cs
 Mapper.WhenMapping
     .UseConfigurations.From<ProductMappingConfiguration>();
 ```
 
 To apply all `MapperConfiguration` Types from an Assembly, supply a Type from that Assembly:
 
-```C#
+```cs
 Mapper.WhenMapping
     .UseConfigurations.FromAssemblyOf<Product>();
 ```
 
 To apply all `MapperConfiguration` Types from multiple Assemblies, supply the Assemblies:
 
-```C#
+```cs
 // Scan all Assemblies from the AppDomain:
 Mapper.WhenMapping
     .UseConfigurations.From(assembly1, assembly2, assembly3);
@@ -63,7 +63,7 @@ Mapper.WhenMapping
 
 To apply all `MapperConfiguration` Types from the Assemblies current loaded into the `AppDomain`, use:
 
-```C#
+```cs
 // Scan all Assemblies from the AppDomain:
 Mapper.WhenMapping
     .UseConfigurations.FromCurrentAppDomain();
@@ -79,7 +79,7 @@ Mapper.WhenMapping
 
 Calling `GetPlansFor<Source>().To<Target>()` caches the mapping function at the point you call it. If Types configured in the object graph are configured in more than one `MapperConfiguration`, you might need to define an order in which configuration classes are applied. Use:
 
-```C#
+```cs
 // Configure aspects of Parent -> Parent mapping, which includes 
 // mapping Child -> Child. Automatically apply ChildMapperConfiguration,
 // then apply this configuration afterwards.
@@ -100,7 +100,7 @@ Chains of `ApplyAfter` attributes will be followed, with all configurations auto
 
 [Configured Service Providers](Dependency-Injection) are available to `MapperConfiguration` classes. For example:
 
-```C#
+```cs
 // Get a Dependency Injection container:
 var diContainer = GetDiContainer();
 
@@ -114,7 +114,7 @@ Mapper.WhenMapping
 
 ...the DI container and its registered services are now available to the `MapperConfiguration` class via the `GetService<TService>()` and `GetServiceProvider<TContainer>()` methods:
 
-```C#
+```cs
 public class MyMappingConfiguration : MapperConfiguration
 {
     protected override void Configure()

docs/src/Configuring-Constructor-Arguments.md

@@ -4,7 +4,7 @@ Constructor arguments can be configured by type or name, and constant values or
 
 For example, to configure mapping these types:
 
-```C#
+```cs
 public class CustomerDto
 {
     public string CustomerNum { get; set; }
@@ -21,7 +21,7 @@ public class Customer
 
 ...use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<CustomerDto>()              // Apply to CustomerDto mappings
     .ToANew<Customer>()               // Apply to Customer creations
@@ -34,7 +34,7 @@ Mapper.WhenMapping
 
 ...or, if inline configuration is preferred:
 
-```C#
+```cs
 // Source, target and mapping types are implicit from the mapping:
 Mapper
     .Map(customerDto).ToANew<Customer>(cfg => cfg

docs/src/Configuring-Exception-Handling.md

@@ -1,13 +1,13 @@
 By default, an `Exception` thrown during a mapping is wrapped in a [`MappingException`](/agileobjects/AgileMapper/blob/master/AgileMapper/MappingException.cs) and rethrown. To configure a mapper to swallow exceptions and return null instead, use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .SwallowAllExceptions();
 ```
 
 Alternatively, to have a mapper call a callback in the event of an exception use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .PassExceptionsTo(ctx =>
     {
@@ -23,7 +23,7 @@ Mapper.WhenMapping
 
 To only swallow exceptions thrown when mapping particular types, use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<PersonViewModel>() // Apply to PersonViewModel mappings (optional)
     .To<Person>()            // Apply to Person creation, updates and merges
@@ -32,7 +32,7 @@ Mapper.WhenMapping
 
 ...and to have a callback called for a particular type, use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .To<Person>()
     .PassExceptionsTo(ctx =>

docs/src/Configuring-Mapping-Callbacks.md

@@ -2,7 +2,7 @@ You can configure code to be executed at specific points in a mapping - conditio
 
 Before mapping of a specified type begins:
 
-```C#
+```cs
 mapper.WhenMapping
     .To<Customer>() // Apply to Customer creation, updates and merges
     .Before
@@ -13,7 +13,7 @@ mapper.WhenMapping
 
 Before an instance of a specified type is created:
 
-```C#
+```cs
 mapper.WhenMapping
     .From<AddressDto>() // Apply to AddressDto mappings
     .ToANew<Address>()  // Apply to Address creation
@@ -24,7 +24,7 @@ mapper.WhenMapping
 
 After an instance of a specified type is created:
 
-```C#
+```cs
 mapper
     .After
     .CreatingInstancesOf<Address>()
@@ -34,7 +34,7 @@ mapper
 
 On either side of the mapping of a particular member:
 
-```C#
+```cs
 mapper.WhenMapping
     .From<Person>()   // Apply to Person mappings
     .Over<PersonVm>() // Apply to PersonVm updates
@@ -49,7 +49,7 @@ mapper.WhenMapping
 
 At the end of any mapping (conditionally):
 
-```C#
+```cs
 Mapper
     .After
     .MappingEnds

docs/src/Configuring-Member-Name-Patterns.md

@@ -1,6 +1,6 @@
 If a naming convention prevents normal [member matching](Member-Matching), you can configure naming patterns to use to match names up. For example:
 
-```C#
+```cs
 public class ProductDto
 {
     public string strName { get; set; }
@@ -15,21 +15,21 @@ public class Product
 
 To have the name prefixes `str` and `dec` ignored when matching member names, use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .UseNamePrefixes("str", "dec"); 
 ```
 
 You can also configure name suffixes:
 
-```C#
+```cs
 Mapper.WhenMapping
     .UseNameSuffix("Value"); // Match 'PriceValue' to 'Price'
 ```
 
 ...or a regex pattern:
 
-```C#
+```cs
 Mapper.WhenMapping
     .UseNamePattern("^_(.+)Value$"); // Match '_PriceValue' to 'Price'
 ```
@@ -38,7 +38,7 @@ Configured regex patterns must start with `^` and end with `$`, contain the capt
 
 Naming patterns can also be configured [inline](Inline-Configuration)
 
-```C#
+```cs
 var anonSource = new { _PriceValue = default(double) };
 
 // Source, target and mapping types are implicit from the mapping:
@@ -49,7 +49,7 @@ Mapper
 
 ...or for specific source and target types:
 
-```C#
+```cs
 var anonSource = new { _PriceValue = default(double) };
 
 Mapper.WhenMapping

docs/src/Configuring-Member-Values.md

@@ -2,7 +2,7 @@ There are several ways of configuring a custom data source for a target member.
 
 **A source member**:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<ProductDto>()          // Apply to ProductDto mappings
     .To<Product>()               // Apply to Product creation, updates and merges
@@ -18,7 +18,7 @@ Mapper.WhenMapping
 
 **A source expression** (in this example, supplied [inline](Inline-Configuration)):
 
-```C#
+```cs
 // Source, target and mapping types are implicit from the mapping:
 Mapper.Map(productDto).ToANew<Product>(cfg => cfg
     .Map(ctx => "$" + ctx.Source.Price) // ctx.Source is the ProductDto
@@ -27,7 +27,7 @@ Mapper.Map(productDto).ToANew<Product>(cfg => cfg
 
 **A constant value**:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<ProductDto>()      // Apply to ProductDto mappings
     .OnTo<Product>()         // Apply to Product merges only
@@ -42,7 +42,7 @@ Mapper.WhenMapping
 
 **A value from an [injected service](Dependency-Injection)**:
 
-```C#
+```cs
 // Retrieve an IDateTimeProvider instance from a configured
 // service provider, and use its UtcNow value:
 Mapper.WhenMapping
@@ -54,7 +54,7 @@ Mapper.WhenMapping
 
 **The result of a function call** ([inline](Inline-Configuration)):
 
-```C#
+```cs
 Func<ProductDto, Product, string> companyNameFactory = 
     (dto, p) => dto.ManufaturerName + " Ltd";
 
@@ -68,7 +68,7 @@ Mapper.Map(productDto).ToANew<Product>(cfg => cfg
 
 Any of these methods can be configured to be conditional:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<ProductDto>()                 // Apply to ProductDto mappings
     .ToANew<Product>()                  // Apply to Product creation only
@@ -79,7 +79,7 @@ Mapper.WhenMapping
 
 And in an [inline](Inline-Configuration) example:
 
-```C#
+```cs
 Mapper.Map(productDto).ToANew<Product>(cfg => cfg
     .If((dto, p) => dto.CompanyId == 0) // Apply only if CompanyId is 0
     .Map("No-one")                      // Always the same value
@@ -92,21 +92,21 @@ By default, configured data sources only apply in the direction configured - con
 
 To make every source- to target-member pairing you configure apply to mappings in either direction, use:
 
-```C#
+```cs
 Mapper.WhenMapping.AutoReverseConfiguredDataSources();
 ```
 
 To make every source- to target-member pairing you configure for a particular pair of Types apply to mappings in either direction, use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<Product>().To<ProductDto>()
     .AutoReverseConfiguredDataSources();
 ```
 
 To make a source- to target-member pairing you configure apply to mappings in either direction, use:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<Product>().To<ProductDto>()
     .Map(p => p.Specification, dto => dtp.Spec)
@@ -117,7 +117,7 @@ Mapper.WhenMapping
 
 If you use the mapper-level `AutoReverseConfiguredDataSources()` to set the default behaviour, source- to target-member pairings you configure for a particular pair of Types can opt out using:
 
-```C#
+```cs
 // Set the default behaviour:
 Mapper.WhenMapping.AutoReverseConfiguredDataSources();
 
@@ -129,7 +129,7 @@ Mapper.WhenMapping
 
 ...and individual source- to target-member pairings can opt out with:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<Product>().To<ProductDto>()
     .Map(p => p.Specification, dto => dtp.Spec)
@@ -140,7 +140,7 @@ Mapper.WhenMapping
 
 To map a data source to the root target object, use, *e.g*:
 
-```C#
+```cs
 // Source class - has a nested member 'Statistics':
 class Video
 {

docs/src/Configuring-Object-Construction.md

@@ -1,6 +1,6 @@
 Configure a custom factory for a particular type using:
 
-```C#
+```cs
 Mapper.WhenMapping
     .InstancesOf<Customer>() // Apply to Customer creation, updates and merges
     .CreateUsing(ctx => new Customer
@@ -11,7 +11,7 @@ Mapper.WhenMapping
 
 Configure a custom factory for a particular type when mapping between particular types using:
 
-```C#
+```cs
 Mapper.WhenMapping
     .From<PersonViewModel>() // Apply to PersonViewModel mappings
     .To<Customer>()          // Apply to Customer creation, updates and merges
@@ -23,7 +23,7 @@ Mapper.WhenMapping
 
 Configure a conditional custom factory using ([inline](Inline-Configuration) example):
 
-```C#
+```cs
 Mapper.Map(customerViewModels).ToANew<Customer[]>(cfg => cfg
     .WhenMapping
     .From<CustomerViewModel>()