configuration json register detail access

Common/.vs/config/applicationhost.config

@@ -155,11 +155,19 @@
 			</site>
             <site name="MeterProcessState" id="2">
                 <application path="/" applicationPool="Clr4IntegratedAppPool">
-                    <virtualDirectory path="/" physicalPath="D:\Projekte\SENSUS_GitLab\laa_production\Common\Service\MeterProcessState" />
+                    <virtualDirectory path="/" physicalPath="C:\Users\SZLATEV\source\repos\laa_production\Common\Service\MeterProcessState" />
                 </application>
                 <bindings>
                     <binding protocol="http" bindingInformation="*:56011:localhost" />
                 </bindings>
+            </site>
+            <site name="TestMVC" id="3">
+                <application path="/" applicationPool="Clr4IntegratedAppPool">
+                    <virtualDirectory path="/" physicalPath="C:\Users\SZLATEV\source\repos\laa_production\Common\TestMVC" />
+                </application>
+                <bindings>
+                    <binding protocol="http" bindingInformation="*:59615:localhost" />
+                </bindings>
             </site>
 			<siteDefaults>
 				<!-- To enable logging, please change the below attribute "enabled" to "true" -->

Common/CommonConsole/BitExtensions.cs

@@ -0,0 +1,117 @@
+namespace CommonConsole
+{
+    using System;
+    using System.Linq;
+    using System.Text;
+
+    public static class BitExtensions
+    {
+        public static byte[] GetBits(this byte[] bytes)
+        {
+            if (bytes is null)
+            {
+                return Array.Empty<byte>();
+            }
+
+            var bytesCount = bytes.Length;
+            var bitsCount = bytesCount * 8;
+            var bits = new byte[bitsCount];
+            var bit = 0;
+
+            foreach (var @byte in bytes)
+            {
+                for (int b = 7; b >= 0; b--)
+                {
+                    bits[bit++] = (byte)((@byte >> b) % 2);
+                }
+            }
+
+            return bits;
+        }
+
+        public static byte[] GetBytes(this byte value, int take = 1) 
+            => BitConverter.GetBytes(value).Take(take);
+
+        public static byte[] GetBytes(this sbyte value, int take = 2) 
+            => BitConverter.GetBytes(value).Take(take);
+
+        public static byte[] GetBytes(this short value, int take = 2) 
+            => BitConverter.GetBytes(value).Take(2);
+
+        public static byte[] GetBytes(this ushort value, int take = 2) 
+            => BitConverter.GetBytes(value).Take(2);
+
+        public static byte[] GetBytes(this int value, int take = 4) 
+            => BitConverter.GetBytes(value).Take(take);
+
+        public static byte[] GetBytes(this uint value, int take = 4) 
+            => BitConverter.GetBytes(value).Take(take);
+
+        public static byte[] GetBytes(this long value, int take = 8) 
+            => BitConverter.GetBytes(value).Take(take);
+
+        public static byte[] GetBytes(this ulong value, int take = 8) 
+            => BitConverter.GetBytes(value).Take(take);
+
+        public static byte[] GetBytes(this double value) 
+            => BitConverter.GetBytes(value);
+
+        public static byte[] GetBytes(this string value) 
+            => Encoding.ASCII.GetBytes(value);
+
+        public static byte[] Swap(this byte[] bytes)
+        {
+            if (bytes is null)
+            {
+                return Array.Empty<byte>();
+            }
+            
+            var length = bytes.Length;
+            var swapped = new byte[length];
+
+            for (int x = 0; x < length; x++)
+            {
+                swapped[x] = bytes[length - x - 1];
+            }
+
+            return swapped;
+        }
+
+        public static byte[] Take(this byte[] bytesSRC, int count)
+        {
+            if (bytesSRC is null || count < 0)
+            {
+                return Array.Empty<byte>();
+            }
+
+            var bytesDST = new byte[count];
+
+            Array.Copy(bytesSRC, 0, bytesDST, 0, count);
+
+            return bytesDST;
+        }
+
+        public static string ToHex(this byte[] value, string separator = " ")
+        {
+            if (value is null)
+            {
+                return string.Empty;
+            }
+
+            return BitConverter.ToString(value).Replace("-", separator);
+        }
+
+        public static byte[] FromHex(this string value, string separator = " ")
+        {
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                return Array.Empty<byte>();
+            }
+
+            return value
+                .Split(new[] { separator }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(x => byte.TryParse(x, out byte b) ? b : default(byte))
+                .ToArray();
+        }
+    }
+}

Common/CommonConsole/CommonConsole.csproj

@@ -46,11 +46,22 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="BitExtensions.cs" />
+    <Compile Include="JsonConfiguration.cs" />
+    <Compile Include="JsonConverters\CurrentConverter.cs" />
+    <Compile Include="JsonConverters\FlowConverter.cs" />
+    <Compile Include="JsonConverters\PressureConverter.cs" />
+    <Compile Include="JsonConverters\TemperatureConverter.cs" />
+    <Compile Include="JsonConverters\TimeConverter.cs" />
+    <Compile Include="JsonConverters\VolumeConverter.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Unit.cs" />
+    <Compile Include="Value.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="configuration.json" />
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
@@ -59,5 +70,6 @@
       <Name>CommonMessurementUnits</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

Common/CommonConsole/JsonConfiguration.cs

@@ -0,0 +1,273 @@
+namespace CommonConsole
+{
+    using Newtonsoft.Json;
+
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Runtime.Serialization;
+
+    public class JsonConfiguration : Dictionary<string, Section>
+    {
+        public Section this[byte id] 
+            => this.Values.FirstOrDefault(x => x.Id == id)
+            ?? new Section();
+
+        public new Section this[string key]
+        {
+            get
+            {
+                if (string.IsNullOrWhiteSpace(key))
+                {
+                    throw new ArgumentException("Section name should not be null or white space!");
+                }
+
+                if (!this.TryGetValue(key, out var section))
+                {
+                    section = new Section();
+
+                    this[key] = section;
+                }
+
+                return section;
+            }
+            set
+            {
+                if (string.IsNullOrWhiteSpace(key))
+                {
+                    throw new ArgumentException("Section name should not be null or white space!");
+                }
+
+                this[key] = value;
+            }
+        }
+
+        [OnDeserialized]
+        internal void OnDeserialized(StreamingContext _)
+        {
+            foreach (var kvp in this)
+            {
+                kvp.Value.Name = kvp.Key;
+            }
+        }
+    }
+
+    public class Section
+    {
+        public byte Id { get; set; }
+
+        [JsonIgnore]
+        public string Name { get; internal set; }
+
+        public Version Version { get; set; }
+
+        public Registers Registers { get; set; }
+
+        public Status Status { get; set; }
+
+        public Register this[string key]
+        {
+            get
+            {
+                if (this.Registers is null)
+                {
+                    return new Register();
+                }
+
+                return this.Registers[key];
+            }
+            set
+            {
+                if (this.Registers != null)
+                {
+                    this.Registers[key] = value;
+                }
+            }
+        }
+
+        public Register this[byte id]
+            => this.Registers?[id] ?? new Register();
+    }
+
+    public class Version
+    {
+        public int? First { get; set; }
+
+        public int? Last { get; set; }
+
+        public bool InVersion(int version)
+        {
+            if (this.First is null && this.Last is null)
+            {
+                return false;
+            }
+
+            return (this.First ?? int.MinValue) <= version && (this.First ?? int.MaxValue) >= version;
+        }
+    }
+
+    public class Registers : Dictionary<string, Register>
+    {
+        public Register this[byte id]
+            => this.Values.FirstOrDefault(x => x.Id == id) 
+            ?? new Register();
+
+        public new Register this[string key]
+        {
+            get
+            {
+                if (string.IsNullOrWhiteSpace(key))
+                {
+                    throw new ArgumentException("Register name should not be null or white space!");
+                }
+
+                if (!this.TryGetValue(key, out var register))
+                {
+                    register = new Register();
+
+                    this[key] = register;
+                }
+
+                return register;
+            }
+            set
+            {
+                if (string.IsNullOrWhiteSpace(key))
+                {
+                    throw new ArgumentException("Register name should not be null or white space!");
+                }
+
+                this[key] = value;
+            }
+        }
+
+        [OnDeserialized]
+        internal void OnDeserialized(StreamingContext _)
+        {
+            foreach (var kvp in this)
+            {
+                kvp.Value.Name = kvp.Key;
+            }
+        }
+    }
+
+    public class Register
+    {
+        public byte Id { get; set; }
+
+        [JsonIgnore]
+        public string Name { get; internal set; }
+
+        public Details Details { get; set; }
+
+        public Detail this[int version]
+            => this.Details?[version] ?? new Detail();
+    }
+
+    public class Details : List<Detail>
+    {
+        public new Detail this[int version]
+            => this.FirstOrDefault(x => x.Version?.InVersion(version) ?? false)
+            ?? new Detail();
+    }
+
+    public class Detail
+    {
+        public string Type { get; set; }
+
+        public string StaticType { get; set; }
+
+        public Privilege Privilege { get; set; }
+
+        public Version Version { get; set; }
+
+        public Values Values { get; set; }
+
+        public Value Value { get; set; }
+
+        public Unit Unit { get; set; }
+    }
+
+    public class Values
+    {
+        public object Default { get; set; }
+
+        public object Minimum { get; set; }
+
+        public object Maximum { get; set; }
+    }
+
+    public class Privilege
+    {
+        public Access Lvl1 { get; set; }
+
+        public Access Lvl2 { get; set; }
+
+        public Access Lvl3 { get; set; }
+
+        public Access Lvl4 { get; set; }
+
+        public Access Lvl5 { get; set; }
+
+        public Access Lvl6 { get; set; }
+
+        public Access Lvl7 { get; set; }
+
+        public Access Lvl8 { get; set; }
+    }
+
+    public enum Access : byte
+    {
+        NS,
+        NA,
+        RO,
+        WO,
+        RW
+    }
+
+    public class Status : Dictionary<string, StatusInfo>
+    {
+
+    }
+
+    public class StatusInfo
+    {
+        public byte Id { get; set; }
+
+        public string Action { get; set; }
+
+        public string Description { get; set; }
+    }
+
+    public class AccessConverter : JsonConverter
+    {
+        public override bool CanConvert(Type type)
+            => type == typeof(Access)
+            || type == typeof(Access?);
+
+        public override object ReadJson(JsonReader reader, Type _, object existingValue, JsonSerializer serializer)
+        {
+            if (reader.TokenType == JsonToken.Null)
+            {
+                return null;
+            }
+
+            var value = serializer.Deserialize<string>(reader);
+
+            if (Enum.TryParse(value, true, out Access access))
+            {
+                return access;
+            }
+
+            return default(Access);
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer _1)
+        {
+            if (value != null)
+            {
+                writer.WriteValue($"{value}");
+            }
+        }
+    }
+}

Common/CommonConsole/JsonConverters/CurrentConverter.cs

@@ -0,0 +1,27 @@
+namespace CommonConsole.JsonConverters
+{
+    using Newtonsoft.Json;
+
+    using System;
+
+    public class CurrentConverter : JsonConverter<Current>
+    {
+        public override Current ReadJson(JsonReader reader, Type objectType, Current existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            while (reader.ValueType != typeof(double))
+            {
+                reader.Read();
+            }
+
+            if (reader.Value is double value)
+            {
+                return value;
+            }
+
+            return existingValue;
+        }
+
+        public override void WriteJson(JsonWriter writer, Current value, JsonSerializer serializer)
+            => writer.WriteValue((double)value);
+    }
+}

Common/CommonConsole/JsonConverters/FlowConverter.cs

@@ -0,0 +1,27 @@
+namespace CommonConsole.JsonConverters
+{
+    using Newtonsoft.Json;
+
+    using System;
+
+    public class FlowConverter : JsonConverter<Flow>
+    {
+        public override Flow ReadJson(JsonReader reader, Type objectType, Flow existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            while (reader.ValueType != typeof(double))
+            {
+                reader.Read();
+            }
+
+            if (reader.Value is double value)
+            {
+                return value;
+            }
+
+            return existingValue;
+        }
+
+        public override void WriteJson(JsonWriter writer, Flow value, JsonSerializer serializer)
+            => writer.WriteValue((double)value);
+    }
+}

Common/CommonConsole/JsonConverters/PressureConverter.cs

@@ -0,0 +1,27 @@
+namespace CommonConsole.JsonConverters
+{
+    using Newtonsoft.Json;
+
+    using System;
+
+    public class PressureConverter : JsonConverter<Pressure>
+    {
+        public override Pressure ReadJson(JsonReader reader, Type objectType, Pressure existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            while (reader.ValueType != typeof(double))
+            {
+                reader.Read();
+            }
+
+            if (reader.Value is double value)
+            {
+                return value;
+            }
+
+            return existingValue;
+        }
+
+        public override void WriteJson(JsonWriter writer, Pressure value, JsonSerializer serializer)
+            => writer.WriteValue((double)value);
+    }
+}

Common/CommonConsole/JsonConverters/TemperatureConverter.cs

@@ -0,0 +1,27 @@
+namespace CommonConsole.JsonConverters
+{
+    using Newtonsoft.Json;
+
+    using System;
+
+    public class TemperatureConverter : JsonConverter<Temperature>
+    {
+        public override Temperature ReadJson(JsonReader reader, Type objectType, Temperature existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            while (reader.ValueType != typeof(double))
+            {
+                reader.Read();
+            }
+
+            if (reader.Value is double value)
+            {
+                return value;
+            }
+
+            return existingValue;
+        }
+
+        public override void WriteJson(JsonWriter writer, Temperature value, JsonSerializer serializer)
+            => writer.WriteValue((double)value);
+    }
+}

Common/CommonConsole/JsonConverters/TimeConverter.cs

@@ -0,0 +1,27 @@
+namespace CommonConsole.JsonConverters
+{
+    using Newtonsoft.Json;
+
+    using System;
+
+    public class TimeConverter : JsonConverter<Time>
+    {
+        public override Time ReadJson(JsonReader reader, Type objectType, Time existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            while (reader.ValueType != typeof(double))
+            {
+                reader.Read();
+            }
+
+            if (reader.Value is double value)
+            {
+                return value;
+            }
+
+            return existingValue;
+        }
+
+        public override void WriteJson(JsonWriter writer, Time value, JsonSerializer serializer)
+            => writer.WriteValue((double)value);
+    }
+}

Common/CommonConsole/JsonConverters/VolumeConverter.cs

@@ -0,0 +1,27 @@
+namespace CommonConsole.JsonConverters
+{
+    using Newtonsoft.Json;
+
+    using System;
+
+    public class VolumeConverter : JsonConverter<Volume>
+    {
+        public override Volume ReadJson(JsonReader reader, Type objectType, Volume existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            while (reader.ValueType != typeof(double))
+            {
+                reader.Read();
+            }
+
+            if (reader.Value is double value)
+            {
+                return value;
+            }
+
+            return existingValue;
+        }
+
+        public override void WriteJson(JsonWriter writer, Volume value, JsonSerializer serializer)
+            => writer.WriteValue((double)value);
+    }
+}

Common/CommonConsole/Program.cs

@@ -1,52 +1,55 @@
 namespace CommonConsole
 {
-    using CommonMessurementUnits;
     using Newtonsoft.Json;
-    using System;
+    using Newtonsoft.Json.Converters;
+
+    using System.Globalization;
+    using System.IO;
 
     public class Program
     {
         public static void Main(string[] args)
         {
-            int x = 3;
+            var content = File.ReadAllText("../../configuration.json");
-            Console.WriteLine($"From Int32: {x}");
+            var configuration = JsonConvert.DeserializeObject<JsonConfiguration>(content);
-            byte[] xb = x.GetBytes();
+            
-            Console.WriteLine($"Bits: {string.Join("", xb.GetBits())}");
+            byte sectionId = 10;
-            Console.WriteLine($"Hex bytes: {xb.ToHex()}");
+            byte registerId = 2;
-            int y = BitConverter.ToInt32(xb, 0);
+            int version = 20;
-            Console.WriteLine($"To Int32: {y}");
-            Console.WriteLine();
 
-            var model = new TestClass
+            /// Getting application section from the configuration
+            var sectionById = configuration[sectionId];
+
+            if (!string.IsNullOrWhiteSpace(sectionById.Name))
             {
-                Current = 130,
+                /// ??? When requested by name creates new Section if name not exists in the keys collection.
-                Flow = 40,
+                var sectionByName = configuration[sectionById.Name];
-                Pressure = 250000,
+            }
-                Temperature = 21,
-                Time = 960,
-                Volume = 40,
-            };
 
-            var modelJson = JsonConvert.SerializeObject(model, Formatting.Indented);
+            /// Geting register by sectionId and registerId
-            var testModel = JsonConvert.DeserializeObject<TestClass>(modelJson);
+            var registerById = configuration[sectionId][registerId];
 
-            Console.WriteLine($"To Json: {modelJson}");
+            if (!string.IsNullOrWhiteSpace(registerById.Name))
-            Console.WriteLine($"From Json: {JsonConvert.SerializeObject(testModel, Formatting.Indented)}");
+            {
+                /// ??? When requested by name creates new Register for the section if name not exists in the keys collection.
+                var registerByName = configuration[sectionId][registerById.Name];
+            }
+
+            var valueByV = configuration[sectionId][registerId][version];
         }
-    }
 
-    public class TestClass
+        private static JsonSerializerSettings settings => new JsonSerializerSettings
-    {
+        {
-        public Current Current { get; set; }
+            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
-
+            DateParseHandling = DateParseHandling.None,
-        public Flow Flow { get; set; }
+            Converters =
-
+            {
-        public Pressure Pressure { get; set; }
+                new AccessConverter(),
-
+                new IsoDateTimeConverter
-        public Temperature Temperature { get; set; }
+                {
-
+                    DateTimeStyles = DateTimeStyles.AssumeUniversal
-        public Time Time { get; set; }
+                }
-
+            },
-        public Volume Volume { get; set; }
+        };
     }
 }

Common/CommonConsole/Unit.cs

@@ -0,0 +1,187 @@
+namespace CommonConsole
+{
+    using CommonConsole.JsonConverters;
+
+    using Newtonsoft.Json;
+
+    public abstract class Unit
+    {
+        public const int MsInSec = 1000;
+        public const int SecInMin = 60;
+        public const int MinInH = 60;
+        public const int HInDay = 24;
+        public const int MlInL = 1000;
+        public const int LInm3 = 1000;
+        public const int PInBar = 100000;
+        public const int MAInH = 1000;
+
+        protected double value;
+
+        public override string ToString() 
+            => this.value.ToString();
+
+        public override bool Equals(object obj) 
+            => this.value.Equals(obj);
+
+        public override int GetHashCode()
+            => this.value.GetHashCode();
+
+        public static explicit operator double (Unit @base)
+            => @base?.value ?? default(double);
+
+        public static explicit operator double? (Unit @base)
+            => @base?.value;
+    }
+
+    [JsonConverter(typeof(CurrentConverter))]
+    public class Current : Unit
+    {
+        public double MiliampereHours
+        {
+            get => this.AmpereHours * MAInH;
+            set => this.AmpereHours = value / MAInH;
+        }
+
+        public double AmpereHours
+        {
+            get => this.value;
+            set => this.value = value;
+        }
+
+        public static implicit operator Current(double x)
+            => new Current { value = x };
+
+        public static implicit operator Current(double? x)
+            => new Current { value = x ?? 0 };
+    }
+
+    [JsonConverter(typeof(FlowConverter))]
+    public class Flow : Unit
+    {
+        public double CubicMeterInHour
+        {
+            get => this.value;
+            set => this.value = value;
+        }
+
+        public double LiterInMinute
+        {
+            get => this.CubicMeterInHour / MinInH * LInm3;
+            set => this.CubicMeterInHour = value * MinInH / LInm3;
+        }
+
+        public static implicit operator Flow(double x)
+            => new Flow { value = x };
+
+        public static implicit operator Flow(double? x)
+            => new Flow { value = x ?? 0 };
+    }
+
+    [JsonConverter(typeof(PressureConverter))]
+    public class Pressure : Unit
+    {
+        public double Pascal
+        {
+            get => this.value;
+            set => this.value = value;
+        }
+
+        public double Bar
+        {
+            get => this.Pascal / PInBar;
+            set => this.Pascal = value * PInBar;
+        }
+
+        public static implicit operator Pressure(double x)
+            => new Pressure { value = x };
+
+        public static implicit operator Pressure(double? x)
+            => new Pressure { value = x ?? 0 };
+    }
+
+    [JsonConverter(typeof(TemperatureConverter))]
+    public class Temperature : Unit
+    {
+        public double Celsius
+        {
+            get => this.value;
+            set => this.value = value;
+        }
+
+        public static implicit operator Temperature(double x)
+            => new Temperature { value = x };
+
+        public static implicit operator Temperature(double? x)
+            => new Temperature { value = x ?? 0 };
+    }
+
+    [JsonConverter(typeof(TimeConverter))]
+    public class Time : Unit
+    {
+        public double Miliseconds
+        {
+            get => this.Seconds * MsInSec;
+            set => this.Seconds = value / MsInSec;
+        }
+
+        public double Seconds
+        {
+            get => this.value;
+            set => this.value = value;
+        }
+
+        public double Minutes
+        {
+            get => this.Seconds / SecInMin;
+            set => this.Seconds = value * SecInMin;
+        }
+
+        public double Hours
+        {
+            get => this.Minutes / MinInH;
+            set => this.Minutes = value * MinInH;
+        }
+
+        public double Days
+        {
+            get => this.Hours / HInDay;
+            set => this.Hours = value * HInDay;
+        }
+
+        public static implicit operator Time(double x)
+            => new Time { value = x };
+
+        public static implicit operator Time(double? x)
+            => new Time { value = x ?? 0 };
+    }
+
+    [JsonConverter(typeof(VolumeConverter))]
+    public class Volume : Unit
+    {
+        public double Mililiter
+        {
+            get => this.Liter * MlInL;
+            set => this.Liter = value / MlInL;
+        }
+
+        public double Liter
+        {
+            get => this.value * LInm3;
+            set => this.value = value / LInm3;
+        }
+
+        public double CubicMeter
+        {
+            get => this.value * this.Factor;
+            set => this.value = value / this.Factor;
+        }
+
+        public int Factor { get; set; } = 1000;
+
+        public static implicit operator Volume(double x)
+            => new Volume { value = x };
+
+        public static implicit operator Volume(double? x)
+            => new Volume { value = x ?? 0 };
+    }
+}

Common/CommonConsole/Value.cs

@@ -0,0 +1,149 @@
+namespace CommonConsole
+{
+    public class Value
+    {
+        public virtual object Current { get; set; }
+
+        public virtual byte[] Buffer { get; set; }
+    }
+
+    public class Value<T> : Value
+    {
+        protected T value;
+    }
+
+    public class bool_t : Value<bool>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (bool)value;
+        }
+    }
+
+    public class rpc : Value<int>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (int)value;
+        }
+    }
+
+    public class @string : Value<string>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (string)value;
+        }
+    }
+
+    public class time_t : Value<int>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (int)value;
+        }
+    }
+
+    public class status_t : Value<byte>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (byte)value;
+        }
+    }
+
+    public class enum8 : Value<byte>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (byte)value;
+        }
+    }
+
+    public class uint8_t : Value<byte>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (byte)value;
+        }
+    }
+
+    public class uint16_t : Value<ushort>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (ushort)value;
+        }
+    }
+
+    public class uint32_t : Value<uint>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (uint)value;
+        }
+    } 
+
+    public class uint64_t : Value<ulong>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (ulong)value;
+        }
+    }
+
+    public class uint96_t : Value<string>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (string)value;
+        }
+    }
+
+    public class int8_t : Value<sbyte>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (sbyte)value;
+        }
+    }
+
+    public class int16_t : Value<short>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (short)value;
+        }
+    }
+
+    public class int32_t : Value<int>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (int)value;
+        }
+    }
+
+    public class int64_t : Value<long>
+    {
+        public override object Current
+        {
+            get => this.value;
+            set => this.value = (long)value;
+        }
+    }
+}

Common/CommonMessurementUnits/CommonMessurementUnits.csproj

@@ -56,7 +56,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Base.cs" />
+    <Compile Include="Unit.cs" />
     <Compile Include="BitExtensions.cs" />
     <Compile Include="Current.cs" />
     <Compile Include="Flow.cs" />

Common/CommonMessurementUnits/Current.cs

@@ -5,7 +5,7 @@
     using Newtonsoft.Json;
 
     [JsonConverter(typeof(CurrentConverter))]
-    public class Current : Base
+    public class Current : Unit
     {
         public double MiliampereHours
         {

Common/CommonMessurementUnits/Flow.cs

@@ -5,7 +5,7 @@
     using Newtonsoft.Json;
 
     [JsonConverter(typeof(FlowConverter))]
-    public class Flow : Base
+    public class Flow : Unit
     {
         public double CubicMeterInHour
         {

Common/CommonMessurementUnits/Pressure.cs

@@ -5,7 +5,7 @@
     using Newtonsoft.Json;
 
     [JsonConverter(typeof(PressureConverter))]
-    public class Pressure : Base
+    public class Pressure : Unit
     {
         public double Pascal
         {

Common/CommonMessurementUnits/Temperature.cs

@@ -5,7 +5,7 @@
     using Newtonsoft.Json;
 
     [JsonConverter(typeof(TemperatureConverter))]
-    public class Temperature : Base
+    public class Temperature : Unit
     {
         public double Celsius
         {

Common/CommonMessurementUnits/Time.cs

@@ -5,7 +5,7 @@
     using Newtonsoft.Json;
 
     [JsonConverter(typeof(TimeConverter))]
-    public class Time : Base
+    public class Time : Unit
     {
         public double Miliseconds
         {

Common/CommonMessurementUnits/Unit.cs

@@ -1,6 +1,6 @@
 namespace CommonMessurementUnits
 {
-    public abstract class Base
+    public abstract class Unit
     {
         public const int MsInSec = 1000;
         public const int SecInMin = 60;
@@ -22,10 +22,10 @@
         public override int GetHashCode()
             => this.value.GetHashCode();
 
-        public static explicit operator double (Base @base)
+        public static explicit operator double (Unit @base)
             => @base?.value ?? default(double);
 
-        public static explicit operator double? (Base @base)
+        public static explicit operator double? (Unit @base)
             => @base?.value;
     }
 }

Common/CommonMessurementUnits/Volume.cs

@@ -5,7 +5,7 @@
     using Newtonsoft.Json;
 
     [JsonConverter(typeof(VolumeConverter))]
-    public class Volume : Base
+    public class Volume : Unit
     {
         public double Mililiter
         {
@@ -21,10 +21,12 @@
 
         public double CubicMeter
         {
-            get => this.value;
+            get => this.value * this.Factor;
-            set => this.value = value;
+            set => this.value = value / this.Factor;
         }
 
+        public int Factor { get; set; } = 1000;
+
         public static implicit operator Volume(double x)
             => new Volume { value = x };
 

Common/Hardware/WaterMeter/Genesis/GenesisCore/GenesisConfigReader.cs

@@ -209,14 +209,14 @@
                 return null;
             }
 
-            var value = serializer.Deserialize<String>(reader);
+            var value = serializer.Deserialize<string>(reader);
 
             if (Enum.TryParse(value, true, out Access access))
             {
                 return access;
             }
 
-            throw new Exception("Cannot unmarshal type Lvl");
+            return default(Access);
         }
 
         /// <summary>

Common/TestMVC/App_Start/BundleConfig.cs

@@ -0,0 +1,27 @@
+using System.Web;
+using System.Web.Optimization;
+
+namespace TestMVC
+{
+    public class BundleConfig
+    {
+        // For more information on bundling, visit https://go.microsoft.com/fwlink/?LinkId=301862
+        public static void RegisterBundles(BundleCollection bundles)
+        {
+            bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
+                        "~/Scripts/jquery-{version}.js"));
+
+            // Use the development version of Modernizr to develop with and learn from. Then, when you're
+            // ready for production, use the build tool at https://modernizr.com to pick only the tests you need.
+            bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
+                        "~/Scripts/modernizr-*"));
+
+            bundles.Add(new ScriptBundle("~/bundles/bootstrap").Include(
+                      "~/Scripts/bootstrap.js"));
+
+            bundles.Add(new StyleBundle("~/Content/css").Include(
+                      "~/Content/bootstrap.css",
+                      "~/Content/site.css"));
+        }
+    }
+}

Common/TestMVC/App_Start/FilterConfig.cs

@@ -0,0 +1,13 @@
+using System.Web;
+using System.Web.Mvc;
+
+namespace TestMVC
+{
+    public class FilterConfig
+    {
+        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
+        {
+            filters.Add(new HandleErrorAttribute());
+        }
+    }
+}

Common/TestMVC/App_Start/RouteConfig.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Web.Mvc;
+using System.Web.Routing;
+
+namespace TestMVC
+{
+    public class RouteConfig
+    {
+        public static void RegisterRoutes(RouteCollection routes)
+        {
+            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
+
+            routes.MapRoute(
+                name: "Default",
+                url: "{controller}/{action}/{id}",
+                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
+            );
+        }
+    }
+}

Common/TestMVC/App_Start/WebApiConfig.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Http;
+
+namespace TestMVC
+{
+    public static class WebApiConfig
+    {
+        public static void Register(HttpConfiguration config)
+        {
+            // Web API configuration and services
+
+            // Web API routes
+            config.MapHttpAttributeRoutes();
+
+            config.Routes.MapHttpRoute(
+                name: "DefaultApi",
+                routeTemplate: "api/{controller}/{id}",
+                defaults: new { id = RouteParameter.Optional }
+            );
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/ApiDescriptionExtensions.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Text;
+using System.Web;
+using System.Web.Http.Description;
+
+namespace TestMVC.Areas.HelpPage
+{
+    public static class ApiDescriptionExtensions
+    {
+        /// <summary>
+        /// Generates an URI-friendly ID for the <see cref="ApiDescription"/>. E.g. "Get-Values-id_name" instead of "GetValues/{id}?name={name}"
+        /// </summary>
+        /// <param name="description">The <see cref="ApiDescription"/>.</param>
+        /// <returns>The ID as a string.</returns>
+        public static string GetFriendlyId(this ApiDescription description)
+        {
+            string path = description.RelativePath;
+            string[] urlParts = path.Split('?');
+            string localPath = urlParts[0];
+            string queryKeyString = null;
+            if (urlParts.Length > 1)
+            {
+                string query = urlParts[1];
+                string[] queryKeys = HttpUtility.ParseQueryString(query).AllKeys;
+                queryKeyString = String.Join("_", queryKeys);
+            }
+
+            StringBuilder friendlyPath = new StringBuilder();
+            friendlyPath.AppendFormat("{0}-{1}",
+                description.HttpMethod.Method,
+                localPath.Replace("/", "-").Replace("{", String.Empty).Replace("}", String.Empty));
+            if (queryKeyString != null)
+            {
+                friendlyPath.AppendFormat("_{0}", queryKeyString.Replace('.', '-'));
+            }
+            return friendlyPath.ToString();
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/App_Start/HelpPageConfig.cs

@@ -0,0 +1,113 @@
+// Uncomment the following to provide samples for PageResult<T>. Must also add the Microsoft.AspNet.WebApi.OData
+// package to your project.
+////#define Handle_PageResultOfT
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Reflection;
+using System.Web;
+using System.Web.Http;
+#if Handle_PageResultOfT
+using System.Web.Http.OData;
+#endif
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// Use this class to customize the Help Page.
+    /// For example you can set a custom <see cref="System.Web.Http.Description.IDocumentationProvider"/> to supply the documentation
+    /// or you can provide the samples for the requests/responses.
+    /// </summary>
+    public static class HelpPageConfig
+    {
+        [SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters",
+            MessageId = "TestMVC.Areas.HelpPage.TextSample.#ctor(System.String)",
+            Justification = "End users may choose to merge this string with existing localized resources.")]
+        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly",
+            MessageId = "bsonspec",
+            Justification = "Part of a URI.")]
+        public static void Register(HttpConfiguration config)
+        {
+            //// Uncomment the following to use the documentation from XML documentation file.
+            //config.SetDocumentationProvider(new XmlDocumentationProvider(HttpContext.Current.Server.MapPath("~/App_Data/XmlDocument.xml")));
+
+            //// Uncomment the following to use "sample string" as the sample for all actions that have string as the body parameter or return type.
+            //// Also, the string arrays will be used for IEnumerable<string>. The sample objects will be serialized into different media type 
+            //// formats by the available formatters.
+            //config.SetSampleObjects(new Dictionary<Type, object>
+            //{
+            //    {typeof(string), "sample string"},
+            //    {typeof(IEnumerable<string>), new string[]{"sample 1", "sample 2"}}
+            //});
+
+            // Extend the following to provide factories for types not handled automatically (those lacking parameterless
+            // constructors) or for which you prefer to use non-default property values. Line below provides a fallback
+            // since automatic handling will fail and GeneratePageResult handles only a single type.
+#if Handle_PageResultOfT
+            config.GetHelpPageSampleGenerator().SampleObjectFactories.Add(GeneratePageResult);
+#endif
+
+            // Extend the following to use a preset object directly as the sample for all actions that support a media
+            // type, regardless of the body parameter or return type. The lines below avoid display of binary content.
+            // The BsonMediaTypeFormatter (if available) is not used to serialize the TextSample object.
+            config.SetSampleForMediaType(
+                new TextSample("Binary JSON content. See http://bsonspec.org for details."),
+                new MediaTypeHeaderValue("application/bson"));
+
+            //// Uncomment the following to use "[0]=foo&[1]=bar" directly as the sample for all actions that support form URL encoded format
+            //// and have IEnumerable<string> as the body parameter or return type.
+            //config.SetSampleForType("[0]=foo&[1]=bar", new MediaTypeHeaderValue("application/x-www-form-urlencoded"), typeof(IEnumerable<string>));
+
+            //// Uncomment the following to use "1234" directly as the request sample for media type "text/plain" on the controller named "Values"
+            //// and action named "Put".
+            //config.SetSampleRequest("1234", new MediaTypeHeaderValue("text/plain"), "Values", "Put");
+
+            //// Uncomment the following to use the image on "../images/aspNetHome.png" directly as the response sample for media type "image/png"
+            //// on the controller named "Values" and action named "Get" with parameter "id".
+            //config.SetSampleResponse(new ImageSample("../images/aspNetHome.png"), new MediaTypeHeaderValue("image/png"), "Values", "Get", "id");
+
+            //// Uncomment the following to correct the sample request when the action expects an HttpRequestMessage with ObjectContent<string>.
+            //// The sample will be generated as if the controller named "Values" and action named "Get" were having string as the body parameter.
+            //config.SetActualRequestType(typeof(string), "Values", "Get");
+
+            //// Uncomment the following to correct the sample response when the action returns an HttpResponseMessage with ObjectContent<string>.
+            //// The sample will be generated as if the controller named "Values" and action named "Post" were returning a string.
+            //config.SetActualResponseType(typeof(string), "Values", "Post");
+        }
+
+#if Handle_PageResultOfT
+        private static object GeneratePageResult(HelpPageSampleGenerator sampleGenerator, Type type)
+        {
+            if (type.IsGenericType)
+            {
+                Type openGenericType = type.GetGenericTypeDefinition();
+                if (openGenericType == typeof(PageResult<>))
+                {
+                    // Get the T in PageResult<T>
+                    Type[] typeParameters = type.GetGenericArguments();
+                    Debug.Assert(typeParameters.Length == 1);
+
+                    // Create an enumeration to pass as the first parameter to the PageResult<T> constuctor
+                    Type itemsType = typeof(List<>).MakeGenericType(typeParameters);
+                    object items = sampleGenerator.GetSampleObject(itemsType);
+
+                    // Fill in the other information needed to invoke the PageResult<T> constuctor
+                    Type[] parameterTypes = new Type[] { itemsType, typeof(Uri), typeof(long?), };
+                    object[] parameters = new object[] { items, null, (long)ObjectGenerator.DefaultCollectionSize, };
+
+                    // Call PageResult(IEnumerable<T> items, Uri nextPageLink, long? count) constructor
+                    ConstructorInfo constructor = type.GetConstructor(parameterTypes);
+                    return constructor.Invoke(parameters);
+                }
+            }
+
+            return null;
+        }
+#endif
+    }
+}

Common/TestMVC/Areas/HelpPage/Controllers/HelpController.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Web.Http;
+using System.Web.Mvc;
+using TestMVC.Areas.HelpPage.ModelDescriptions;
+using TestMVC.Areas.HelpPage.Models;
+
+namespace TestMVC.Areas.HelpPage.Controllers
+{
+    /// <summary>
+    /// The controller that will handle requests for the help page.
+    /// </summary>
+    public class HelpController : Controller
+    {
+        private const string ErrorViewName = "Error";
+
+        public HelpController()
+            : this(GlobalConfiguration.Configuration)
+        {
+        }
+
+        public HelpController(HttpConfiguration config)
+        {
+            Configuration = config;
+        }
+
+        public HttpConfiguration Configuration { get; private set; }
+
+        public ActionResult Index()
+        {
+            ViewBag.DocumentationProvider = Configuration.Services.GetDocumentationProvider();
+            return View(Configuration.Services.GetApiExplorer().ApiDescriptions);
+        }
+
+        public ActionResult Api(string apiId)
+        {
+            if (!String.IsNullOrEmpty(apiId))
+            {
+                HelpPageApiModel apiModel = Configuration.GetHelpPageApiModel(apiId);
+                if (apiModel != null)
+                {
+                    return View(apiModel);
+                }
+            }
+
+            return View(ErrorViewName);
+        }
+
+        public ActionResult ResourceModel(string modelName)
+        {
+            if (!String.IsNullOrEmpty(modelName))
+            {
+                ModelDescriptionGenerator modelDescriptionGenerator = Configuration.GetModelDescriptionGenerator();
+                ModelDescription modelDescription;
+                if (modelDescriptionGenerator.GeneratedModels.TryGetValue(modelName, out modelDescription))
+                {
+                    return View(modelDescription);
+                }
+            }
+
+            return View(ErrorViewName);
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/HelpPage.css

@@ -0,0 +1,134 @@
+.help-page h1,
+.help-page .h1,
+.help-page h2,
+.help-page .h2,
+.help-page h3,
+.help-page .h3,
+#body.help-page,
+.help-page-table th,
+.help-page-table pre,
+.help-page-table p {
+    font-family: "Segoe UI Light", Frutiger, "Frutiger Linotype", "Dejavu Sans", "Helvetica Neue", Arial, sans-serif;
+}
+
+.help-page pre.wrapped {
+    white-space: -moz-pre-wrap;
+    white-space: -pre-wrap;
+    white-space: -o-pre-wrap;
+    white-space: pre-wrap;
+}
+
+.help-page .warning-message-container {
+    margin-top: 20px;
+    padding: 0 10px;
+    color: #525252;
+    background: #EFDCA9; 
+    border: 1px solid #CCCCCC;
+}
+
+.help-page-table {
+    width: 100%;
+    border-collapse: collapse;
+    text-align: left;
+    margin: 0px 0px 20px 0px;
+    border-top: 1px solid #D4D4D4;
+}
+
+.help-page-table th {
+    text-align: left;
+    font-weight: bold;
+    border-bottom: 1px solid #D4D4D4;
+    padding: 5px 6px 5px 6px;
+}
+
+.help-page-table td {
+    border-bottom: 1px solid #D4D4D4;
+    padding: 10px 8px 10px 8px;
+    vertical-align: top;
+}
+
+.help-page-table pre,
+.help-page-table p {
+    margin: 0px;
+    padding: 0px;
+    font-family: inherit;
+    font-size: 100%;
+}
+
+.help-page-table tbody tr:hover td {
+    background-color: #F3F3F3;
+}
+
+.help-page a:hover {
+    background-color: transparent;
+}
+
+.help-page .sample-header {
+    border: 2px solid #D4D4D4;
+    background: #00497E;
+    color: #FFFFFF;
+    padding: 8px 15px;
+    border-bottom: none;
+    display: inline-block;
+    margin: 10px 0px 0px 0px;
+}
+
+.help-page .sample-content {
+    display: block;
+    border-width: 0;
+    padding: 15px 20px;
+    background: #FFFFFF;
+    border: 2px solid #D4D4D4;
+    margin: 0px 0px 10px 0px;
+}
+
+.help-page .api-name {
+    width: 40%;
+}
+
+.help-page .api-documentation {
+    width: 60%;
+}
+
+.help-page .parameter-name {
+    width: 20%;
+}
+
+.help-page .parameter-documentation {
+    width: 40%;
+}
+
+.help-page .parameter-type {
+    width: 20%;
+}
+
+.help-page .parameter-annotations {
+    width: 20%;
+}
+
+.help-page h1,
+.help-page .h1 {
+    font-size: 36px;
+    line-height: normal;
+}
+
+.help-page h2,
+.help-page .h2 {
+    font-size: 24px;
+}
+
+.help-page h3,
+.help-page .h3 {
+    font-size: 20px;
+}
+
+#body.help-page {
+    font-size: 14px;
+    line-height: 143%;
+    color: #333;
+}
+
+.help-page a {
+    color: #0000EE;
+    text-decoration: none;
+}

Common/TestMVC/Areas/HelpPage/HelpPageAreaRegistration.cs

@@ -0,0 +1,26 @@
+using System.Web.Http;
+using System.Web.Mvc;
+
+namespace TestMVC.Areas.HelpPage
+{
+    public class HelpPageAreaRegistration : AreaRegistration
+    {
+        public override string AreaName
+        {
+            get
+            {
+                return "HelpPage";
+            }
+        }
+
+        public override void RegisterArea(AreaRegistrationContext context)
+        {
+            context.MapRoute(
+                "HelpPage_Default",
+                "Help/{action}/{apiId}",
+                new { controller = "Help", action = "Index", apiId = UrlParameter.Optional });
+
+            HelpPageConfig.Register(GlobalConfiguration.Configuration);
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/HelpPageConfigurationExtensions.cs

@@ -0,0 +1,467 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Web.Http;
+using System.Web.Http.Controllers;
+using System.Web.Http.Description;
+using TestMVC.Areas.HelpPage.ModelDescriptions;
+using TestMVC.Areas.HelpPage.Models;
+
+namespace TestMVC.Areas.HelpPage
+{
+    public static class HelpPageConfigurationExtensions
+    {
+        private const string ApiModelPrefix = "MS_HelpPageApiModel_";
+
+        /// <summary>
+        /// Sets the documentation provider for help page.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="documentationProvider">The documentation provider.</param>
+        public static void SetDocumentationProvider(this HttpConfiguration config, IDocumentationProvider documentationProvider)
+        {
+            config.Services.Replace(typeof(IDocumentationProvider), documentationProvider);
+        }
+
+        /// <summary>
+        /// Sets the objects that will be used by the formatters to produce sample requests/responses.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sampleObjects">The sample objects.</param>
+        public static void SetSampleObjects(this HttpConfiguration config, IDictionary<Type, object> sampleObjects)
+        {
+            config.GetHelpPageSampleGenerator().SampleObjects = sampleObjects;
+        }
+
+        /// <summary>
+        /// Sets the sample request directly for the specified media type and action.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sample">The sample request.</param>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        public static void SetSampleRequest(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName)
+        {
+            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, new[] { "*" }), sample);
+        }
+
+        /// <summary>
+        /// Sets the sample request directly for the specified media type and action with parameters.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sample">The sample request.</param>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        public static void SetSampleRequest(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName, params string[] parameterNames)
+        {
+            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, parameterNames), sample);
+        }
+
+        /// <summary>
+        /// Sets the sample request directly for the specified media type of the action.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sample">The sample response.</param>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        public static void SetSampleResponse(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName)
+        {
+            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, new[] { "*" }), sample);
+        }
+
+        /// <summary>
+        /// Sets the sample response directly for the specified media type of the action with specific parameters.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sample">The sample response.</param>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        public static void SetSampleResponse(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName, params string[] parameterNames)
+        {
+            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, parameterNames), sample);
+        }
+
+        /// <summary>
+        /// Sets the sample directly for all actions with the specified media type.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sample">The sample.</param>
+        /// <param name="mediaType">The media type.</param>
+        public static void SetSampleForMediaType(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType)
+        {
+            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType), sample);
+        }
+
+        /// <summary>
+        /// Sets the sample directly for all actions with the specified type and media type.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sample">The sample.</param>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="type">The parameter type or return type of an action.</param>
+        public static void SetSampleForType(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, Type type)
+        {
+            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, type), sample);
+        }
+
+        /// <summary>
+        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
+        /// The help page will use this information to produce more accurate request samples.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        public static void SetActualRequestType(this HttpConfiguration config, Type type, string controllerName, string actionName)
+        {
+            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Request, controllerName, actionName, new[] { "*" }), type);
+        }
+
+        /// <summary>
+        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
+        /// The help page will use this information to produce more accurate request samples.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        public static void SetActualRequestType(this HttpConfiguration config, Type type, string controllerName, string actionName, params string[] parameterNames)
+        {
+            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Request, controllerName, actionName, parameterNames), type);
+        }
+
+        /// <summary>
+        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> returned as part of the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
+        /// The help page will use this information to produce more accurate response samples.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        public static void SetActualResponseType(this HttpConfiguration config, Type type, string controllerName, string actionName)
+        {
+            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Response, controllerName, actionName, new[] { "*" }), type);
+        }
+
+        /// <summary>
+        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> returned as part of the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
+        /// The help page will use this information to produce more accurate response samples.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        public static void SetActualResponseType(this HttpConfiguration config, Type type, string controllerName, string actionName, params string[] parameterNames)
+        {
+            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Response, controllerName, actionName, parameterNames), type);
+        }
+
+        /// <summary>
+        /// Gets the help page sample generator.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <returns>The help page sample generator.</returns>
+        public static HelpPageSampleGenerator GetHelpPageSampleGenerator(this HttpConfiguration config)
+        {
+            return (HelpPageSampleGenerator)config.Properties.GetOrAdd(
+                typeof(HelpPageSampleGenerator),
+                k => new HelpPageSampleGenerator());
+        }
+
+        /// <summary>
+        /// Sets the help page sample generator.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="sampleGenerator">The help page sample generator.</param>
+        public static void SetHelpPageSampleGenerator(this HttpConfiguration config, HelpPageSampleGenerator sampleGenerator)
+        {
+            config.Properties.AddOrUpdate(
+                typeof(HelpPageSampleGenerator),
+                k => sampleGenerator,
+                (k, o) => sampleGenerator);
+        }
+
+        /// <summary>
+        /// Gets the model description generator.
+        /// </summary>
+        /// <param name="config">The configuration.</param>
+        /// <returns>The <see cref="ModelDescriptionGenerator"/></returns>
+        public static ModelDescriptionGenerator GetModelDescriptionGenerator(this HttpConfiguration config)
+        {
+            return (ModelDescriptionGenerator)config.Properties.GetOrAdd(
+                typeof(ModelDescriptionGenerator),
+                k => InitializeModelDescriptionGenerator(config));
+        }
+
+        /// <summary>
+        /// Gets the model that represents an API displayed on the help page. The model is initialized on the first call and cached for subsequent calls.
+        /// </summary>
+        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
+        /// <param name="apiDescriptionId">The <see cref="ApiDescription"/> ID.</param>
+        /// <returns>
+        /// An <see cref="HelpPageApiModel"/>
+        /// </returns>
+        public static HelpPageApiModel GetHelpPageApiModel(this HttpConfiguration config, string apiDescriptionId)
+        {
+            object model;
+            string modelId = ApiModelPrefix + apiDescriptionId;
+            if (!config.Properties.TryGetValue(modelId, out model))
+            {
+                Collection<ApiDescription> apiDescriptions = config.Services.GetApiExplorer().ApiDescriptions;
+                ApiDescription apiDescription = apiDescriptions.FirstOrDefault(api => String.Equals(api.GetFriendlyId(), apiDescriptionId, StringComparison.OrdinalIgnoreCase));
+                if (apiDescription != null)
+                {
+                    model = GenerateApiModel(apiDescription, config);
+                    config.Properties.TryAdd(modelId, model);
+                }
+            }
+
+            return (HelpPageApiModel)model;
+        }
+
+        private static HelpPageApiModel GenerateApiModel(ApiDescription apiDescription, HttpConfiguration config)
+        {
+            HelpPageApiModel apiModel = new HelpPageApiModel()
+            {
+                ApiDescription = apiDescription,
+            };
+
+            ModelDescriptionGenerator modelGenerator = config.GetModelDescriptionGenerator();
+            HelpPageSampleGenerator sampleGenerator = config.GetHelpPageSampleGenerator();
+            GenerateUriParameters(apiModel, modelGenerator);
+            GenerateRequestModelDescription(apiModel, modelGenerator, sampleGenerator);
+            GenerateResourceDescription(apiModel, modelGenerator);
+            GenerateSamples(apiModel, sampleGenerator);
+
+            return apiModel;
+        }
+
+        private static void GenerateUriParameters(HelpPageApiModel apiModel, ModelDescriptionGenerator modelGenerator)
+        {
+            ApiDescription apiDescription = apiModel.ApiDescription;
+            foreach (ApiParameterDescription apiParameter in apiDescription.ParameterDescriptions)
+            {
+                if (apiParameter.Source == ApiParameterSource.FromUri)
+                {
+                    HttpParameterDescriptor parameterDescriptor = apiParameter.ParameterDescriptor;
+                    Type parameterType = null;
+                    ModelDescription typeDescription = null;
+                    ComplexTypeModelDescription complexTypeDescription = null;
+                    if (parameterDescriptor != null)
+                    {
+                        parameterType = parameterDescriptor.ParameterType;
+                        typeDescription = modelGenerator.GetOrCreateModelDescription(parameterType);
+                        complexTypeDescription = typeDescription as ComplexTypeModelDescription;
+                    }
+
+                    // Example:
+                    // [TypeConverter(typeof(PointConverter))]
+                    // public class Point
+                    // {
+                    //     public Point(int x, int y)
+                    //     {
+                    //         X = x;
+                    //         Y = y;
+                    //     }
+                    //     public int X { get; set; }
+                    //     public int Y { get; set; }
+                    // }
+                    // Class Point is bindable with a TypeConverter, so Point will be added to UriParameters collection.
+                    // 
+                    // public class Point
+                    // {
+                    //     public int X { get; set; }
+                    //     public int Y { get; set; }
+                    // }
+                    // Regular complex class Point will have properties X and Y added to UriParameters collection.
+                    if (complexTypeDescription != null
+                        && !IsBindableWithTypeConverter(parameterType))
+                    {
+                        foreach (ParameterDescription uriParameter in complexTypeDescription.Properties)
+                        {
+                            apiModel.UriParameters.Add(uriParameter);
+                        }
+                    }
+                    else if (parameterDescriptor != null)
+                    {
+                        ParameterDescription uriParameter =
+                            AddParameterDescription(apiModel, apiParameter, typeDescription);
+
+                        if (!parameterDescriptor.IsOptional)
+                        {
+                            uriParameter.Annotations.Add(new ParameterAnnotation() { Documentation = "Required" });
+                        }
+
+                        object defaultValue = parameterDescriptor.DefaultValue;
+                        if (defaultValue != null)
+                        {
+                            uriParameter.Annotations.Add(new ParameterAnnotation() { Documentation = "Default value is " + Convert.ToString(defaultValue, CultureInfo.InvariantCulture) });
+                        }
+                    }
+                    else
+                    {
+                        Debug.Assert(parameterDescriptor == null);
+
+                        // If parameterDescriptor is null, this is an undeclared route parameter which only occurs
+                        // when source is FromUri. Ignored in request model and among resource parameters but listed
+                        // as a simple string here.
+                        ModelDescription modelDescription = modelGenerator.GetOrCreateModelDescription(typeof(string));
+                        AddParameterDescription(apiModel, apiParameter, modelDescription);
+                    }
+                }
+            }
+        }
+
+        private static bool IsBindableWithTypeConverter(Type parameterType)
+        {
+            if (parameterType == null)
+            {
+                return false;
+            }
+
+            return TypeDescriptor.GetConverter(parameterType).CanConvertFrom(typeof(string));
+        }
+
+        private static ParameterDescription AddParameterDescription(HelpPageApiModel apiModel,
+            ApiParameterDescription apiParameter, ModelDescription typeDescription)
+        {
+            ParameterDescription parameterDescription = new ParameterDescription
+            {
+                Name = apiParameter.Name,
+                Documentation = apiParameter.Documentation,
+                TypeDescription = typeDescription,
+            };
+
+            apiModel.UriParameters.Add(parameterDescription);
+            return parameterDescription;
+        }
+
+        private static void GenerateRequestModelDescription(HelpPageApiModel apiModel, ModelDescriptionGenerator modelGenerator, HelpPageSampleGenerator sampleGenerator)
+        {
+            ApiDescription apiDescription = apiModel.ApiDescription;
+            foreach (ApiParameterDescription apiParameter in apiDescription.ParameterDescriptions)
+            {
+                if (apiParameter.Source == ApiParameterSource.FromBody)
+                {
+                    Type parameterType = apiParameter.ParameterDescriptor.ParameterType;
+                    apiModel.RequestModelDescription = modelGenerator.GetOrCreateModelDescription(parameterType);
+                    apiModel.RequestDocumentation = apiParameter.Documentation;
+                }
+                else if (apiParameter.ParameterDescriptor != null &&
+                    apiParameter.ParameterDescriptor.ParameterType == typeof(HttpRequestMessage))
+                {
+                    Type parameterType = sampleGenerator.ResolveHttpRequestMessageType(apiDescription);
+
+                    if (parameterType != null)
+                    {
+                        apiModel.RequestModelDescription = modelGenerator.GetOrCreateModelDescription(parameterType);
+                    }
+                }
+            }
+        }
+
+        private static void GenerateResourceDescription(HelpPageApiModel apiModel, ModelDescriptionGenerator modelGenerator)
+        {
+            ResponseDescription response = apiModel.ApiDescription.ResponseDescription;
+            Type responseType = response.ResponseType ?? response.DeclaredType;
+            if (responseType != null && responseType != typeof(void))
+            {
+                apiModel.ResourceDescription = modelGenerator.GetOrCreateModelDescription(responseType);
+            }
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is recorded as ErrorMessages.")]
+        private static void GenerateSamples(HelpPageApiModel apiModel, HelpPageSampleGenerator sampleGenerator)
+        {
+            try
+            {
+                foreach (var item in sampleGenerator.GetSampleRequests(apiModel.ApiDescription))
+                {
+                    apiModel.SampleRequests.Add(item.Key, item.Value);
+                    LogInvalidSampleAsError(apiModel, item.Value);
+                }
+
+                foreach (var item in sampleGenerator.GetSampleResponses(apiModel.ApiDescription))
+                {
+                    apiModel.SampleResponses.Add(item.Key, item.Value);
+                    LogInvalidSampleAsError(apiModel, item.Value);
+                }
+            }
+            catch (Exception e)
+            {
+                apiModel.ErrorMessages.Add(String.Format(CultureInfo.CurrentCulture,
+                    "An exception has occurred while generating the sample. Exception message: {0}",
+                    HelpPageSampleGenerator.UnwrapException(e).Message));
+            }
+        }
+
+        private static bool TryGetResourceParameter(ApiDescription apiDescription, HttpConfiguration config, out ApiParameterDescription parameterDescription, out Type resourceType)
+        {
+            parameterDescription = apiDescription.ParameterDescriptions.FirstOrDefault(
+                p => p.Source == ApiParameterSource.FromBody ||
+                    (p.ParameterDescriptor != null && p.ParameterDescriptor.ParameterType == typeof(HttpRequestMessage)));
+
+            if (parameterDescription == null)
+            {
+                resourceType = null;
+                return false;
+            }
+
+            resourceType = parameterDescription.ParameterDescriptor.ParameterType;
+
+            if (resourceType == typeof(HttpRequestMessage))
+            {
+                HelpPageSampleGenerator sampleGenerator = config.GetHelpPageSampleGenerator();
+                resourceType = sampleGenerator.ResolveHttpRequestMessageType(apiDescription);
+            }
+
+            if (resourceType == null)
+            {
+                parameterDescription = null;
+                return false;
+            }
+
+            return true;
+        }
+
+        private static ModelDescriptionGenerator InitializeModelDescriptionGenerator(HttpConfiguration config)
+        {
+            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);
+            Collection<ApiDescription> apis = config.Services.GetApiExplorer().ApiDescriptions;
+            foreach (ApiDescription api in apis)
+            {
+                ApiParameterDescription parameterDescription;
+                Type parameterType;
+                if (TryGetResourceParameter(api, config, out parameterDescription, out parameterType))
+                {
+                    modelGenerator.GetOrCreateModelDescription(parameterType);
+                }
+            }
+            return modelGenerator;
+        }
+
+        private static void LogInvalidSampleAsError(HelpPageApiModel apiModel, object sample)
+        {
+            InvalidSample invalidSample = sample as InvalidSample;
+            if (invalidSample != null)
+            {
+                apiModel.ErrorMessages.Add(invalidSample.ErrorMessage);
+            }
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/CollectionModelDescription.cs

@@ -0,0 +1,7 @@
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class CollectionModelDescription : ModelDescription
+    {
+        public ModelDescription ElementDescription { get; set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/ComplexTypeModelDescription.cs

@@ -0,0 +1,14 @@
+using System.Collections.ObjectModel;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class ComplexTypeModelDescription : ModelDescription
+    {
+        public ComplexTypeModelDescription()
+        {
+            Properties = new Collection<ParameterDescription>();
+        }
+
+        public Collection<ParameterDescription> Properties { get; private set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/DictionaryModelDescription.cs

@@ -0,0 +1,6 @@
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class DictionaryModelDescription : KeyValuePairModelDescription
+    {
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/EnumTypeModelDescription.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class EnumTypeModelDescription : ModelDescription
+    {
+        public EnumTypeModelDescription()
+        {
+            Values = new Collection<EnumValueDescription>();
+        }
+
+        public Collection<EnumValueDescription> Values { get; private set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/EnumValueDescription.cs

@@ -0,0 +1,11 @@
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class EnumValueDescription
+    {
+        public string Documentation { get; set; }
+
+        public string Name { get; set; }
+
+        public string Value { get; set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/IModelDocumentationProvider.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Reflection;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public interface IModelDocumentationProvider
+    {
+        string GetDocumentation(MemberInfo member);
+
+        string GetDocumentation(Type type);
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/KeyValuePairModelDescription.cs

@@ -0,0 +1,9 @@
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class KeyValuePairModelDescription : ModelDescription
+    {
+        public ModelDescription KeyModelDescription { get; set; }
+
+        public ModelDescription ValueModelDescription { get; set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/ModelDescription.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    /// <summary>
+    /// Describes a type model.
+    /// </summary>
+    public abstract class ModelDescription
+    {
+        public string Documentation { get; set; }
+
+        public Type ModelType { get; set; }
+
+        public string Name { get; set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/ModelDescriptionGenerator.cs

@@ -0,0 +1,451 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel.DataAnnotations;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Web.Http;
+using System.Web.Http.Description;
+using System.Xml.Serialization;
+using Newtonsoft.Json;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    /// <summary>
+    /// Generates model descriptions for given types.
+    /// </summary>
+    public class ModelDescriptionGenerator
+    {
+        // Modify this to support more data annotation attributes.
+        private readonly IDictionary<Type, Func<object, string>> AnnotationTextGenerator = new Dictionary<Type, Func<object, string>>
+        {
+            { typeof(RequiredAttribute), a => "Required" },
+            { typeof(RangeAttribute), a =>
+                {
+                    RangeAttribute range = (RangeAttribute)a;
+                    return String.Format(CultureInfo.CurrentCulture, "Range: inclusive between {0} and {1}", range.Minimum, range.Maximum);
+                }
+            },
+            { typeof(MaxLengthAttribute), a =>
+                {
+                    MaxLengthAttribute maxLength = (MaxLengthAttribute)a;
+                    return String.Format(CultureInfo.CurrentCulture, "Max length: {0}", maxLength.Length);
+                }
+            },
+            { typeof(MinLengthAttribute), a =>
+                {
+                    MinLengthAttribute minLength = (MinLengthAttribute)a;
+                    return String.Format(CultureInfo.CurrentCulture, "Min length: {0}", minLength.Length);
+                }
+            },
+            { typeof(StringLengthAttribute), a =>
+                {
+                    StringLengthAttribute strLength = (StringLengthAttribute)a;
+                    return String.Format(CultureInfo.CurrentCulture, "String length: inclusive between {0} and {1}", strLength.MinimumLength, strLength.MaximumLength);
+                }
+            },
+            { typeof(DataTypeAttribute), a =>
+                {
+                    DataTypeAttribute dataType = (DataTypeAttribute)a;
+                    return String.Format(CultureInfo.CurrentCulture, "Data type: {0}", dataType.CustomDataType ?? dataType.DataType.ToString());
+                }
+            },
+            { typeof(RegularExpressionAttribute), a =>
+                {
+                    RegularExpressionAttribute regularExpression = (RegularExpressionAttribute)a;
+                    return String.Format(CultureInfo.CurrentCulture, "Matching regular expression pattern: {0}", regularExpression.Pattern);
+                }
+            },
+        };
+
+        // Modify this to add more default documentations.
+        private readonly IDictionary<Type, string> DefaultTypeDocumentation = new Dictionary<Type, string>
+        {
+            { typeof(Int16), "integer" },
+            { typeof(Int32), "integer" },
+            { typeof(Int64), "integer" },
+            { typeof(UInt16), "unsigned integer" },
+            { typeof(UInt32), "unsigned integer" },
+            { typeof(UInt64), "unsigned integer" },
+            { typeof(Byte), "byte" },
+            { typeof(Char), "character" },
+            { typeof(SByte), "signed byte" },
+            { typeof(Uri), "URI" },
+            { typeof(Single), "decimal number" },
+            { typeof(Double), "decimal number" },
+            { typeof(Decimal), "decimal number" },
+            { typeof(String), "string" },
+            { typeof(Guid), "globally unique identifier" },
+            { typeof(TimeSpan), "time interval" },
+            { typeof(DateTime), "date" },
+            { typeof(DateTimeOffset), "date" },
+            { typeof(Boolean), "boolean" },
+        };
+
+        private Lazy<IModelDocumentationProvider> _documentationProvider;
+
+        public ModelDescriptionGenerator(HttpConfiguration config)
+        {
+            if (config == null)
+            {
+                throw new ArgumentNullException("config");
+            }
+
+            _documentationProvider = new Lazy<IModelDocumentationProvider>(() => config.Services.GetDocumentationProvider() as IModelDocumentationProvider);
+            GeneratedModels = new Dictionary<string, ModelDescription>(StringComparer.OrdinalIgnoreCase);
+        }
+
+        public Dictionary<string, ModelDescription> GeneratedModels { get; private set; }
+
+        private IModelDocumentationProvider DocumentationProvider
+        {
+            get
+            {
+                return _documentationProvider.Value;
+            }
+        }
+
+        public ModelDescription GetOrCreateModelDescription(Type modelType)
+        {
+            if (modelType == null)
+            {
+                throw new ArgumentNullException("modelType");
+            }
+
+            Type underlyingType = Nullable.GetUnderlyingType(modelType);
+            if (underlyingType != null)
+            {
+                modelType = underlyingType;
+            }
+
+            ModelDescription modelDescription;
+            string modelName = ModelNameHelper.GetModelName(modelType);
+            if (GeneratedModels.TryGetValue(modelName, out modelDescription))
+            {
+                if (modelType != modelDescription.ModelType)
+                {
+                    throw new InvalidOperationException(
+                        String.Format(
+                            CultureInfo.CurrentCulture,
+                            "A model description could not be created. Duplicate model name '{0}' was found for types '{1}' and '{2}'. " +
+                            "Use the [ModelName] attribute to change the model name for at least one of the types so that it has a unique name.",
+                            modelName,
+                            modelDescription.ModelType.FullName,
+                            modelType.FullName));
+                }
+
+                return modelDescription;
+            }
+
+            if (DefaultTypeDocumentation.ContainsKey(modelType))
+            {
+                return GenerateSimpleTypeModelDescription(modelType);
+            }
+
+            if (modelType.IsEnum)
+            {
+                return GenerateEnumTypeModelDescription(modelType);
+            }
+
+            if (modelType.IsGenericType)
+            {
+                Type[] genericArguments = modelType.GetGenericArguments();
+
+                if (genericArguments.Length == 1)
+                {
+                    Type enumerableType = typeof(IEnumerable<>).MakeGenericType(genericArguments);
+                    if (enumerableType.IsAssignableFrom(modelType))
+                    {
+                        return GenerateCollectionModelDescription(modelType, genericArguments[0]);
+                    }
+                }
+                if (genericArguments.Length == 2)
+                {
+                    Type dictionaryType = typeof(IDictionary<,>).MakeGenericType(genericArguments);
+                    if (dictionaryType.IsAssignableFrom(modelType))
+                    {
+                        return GenerateDictionaryModelDescription(modelType, genericArguments[0], genericArguments[1]);
+                    }
+
+                    Type keyValuePairType = typeof(KeyValuePair<,>).MakeGenericType(genericArguments);
+                    if (keyValuePairType.IsAssignableFrom(modelType))
+                    {
+                        return GenerateKeyValuePairModelDescription(modelType, genericArguments[0], genericArguments[1]);
+                    }
+                }
+            }
+
+            if (modelType.IsArray)
+            {
+                Type elementType = modelType.GetElementType();
+                return GenerateCollectionModelDescription(modelType, elementType);
+            }
+
+            if (modelType == typeof(NameValueCollection))
+            {
+                return GenerateDictionaryModelDescription(modelType, typeof(string), typeof(string));
+            }
+
+            if (typeof(IDictionary).IsAssignableFrom(modelType))
+            {
+                return GenerateDictionaryModelDescription(modelType, typeof(object), typeof(object));
+            }
+
+            if (typeof(IEnumerable).IsAssignableFrom(modelType))
+            {
+                return GenerateCollectionModelDescription(modelType, typeof(object));
+            }
+
+            return GenerateComplexTypeModelDescription(modelType);
+        }
+
+        // Change this to provide different name for the member.
+        private static string GetMemberName(MemberInfo member, bool hasDataContractAttribute)
+        {
+            JsonPropertyAttribute jsonProperty = member.GetCustomAttribute<JsonPropertyAttribute>();
+            if (jsonProperty != null && !String.IsNullOrEmpty(jsonProperty.PropertyName))
+            {
+                return jsonProperty.PropertyName;
+            }
+
+            if (hasDataContractAttribute)
+            {
+                DataMemberAttribute dataMember = member.GetCustomAttribute<DataMemberAttribute>();
+                if (dataMember != null && !String.IsNullOrEmpty(dataMember.Name))
+                {
+                    return dataMember.Name;
+                }
+            }
+
+            return member.Name;
+        }
+
+        private static bool ShouldDisplayMember(MemberInfo member, bool hasDataContractAttribute)
+        {
+            JsonIgnoreAttribute jsonIgnore = member.GetCustomAttribute<JsonIgnoreAttribute>();
+            XmlIgnoreAttribute xmlIgnore = member.GetCustomAttribute<XmlIgnoreAttribute>();
+            IgnoreDataMemberAttribute ignoreDataMember = member.GetCustomAttribute<IgnoreDataMemberAttribute>();
+            NonSerializedAttribute nonSerialized = member.GetCustomAttribute<NonSerializedAttribute>();
+            ApiExplorerSettingsAttribute apiExplorerSetting = member.GetCustomAttribute<ApiExplorerSettingsAttribute>();
+
+            bool hasMemberAttribute = member.DeclaringType.IsEnum ?
+                member.GetCustomAttribute<EnumMemberAttribute>() != null :
+                member.GetCustomAttribute<DataMemberAttribute>() != null;
+
+            // Display member only if all the followings are true:
+            // no JsonIgnoreAttribute
+            // no XmlIgnoreAttribute
+            // no IgnoreDataMemberAttribute
+            // no NonSerializedAttribute
+            // no ApiExplorerSettingsAttribute with IgnoreApi set to true
+            // no DataContractAttribute without DataMemberAttribute or EnumMemberAttribute
+            return jsonIgnore == null &&
+                xmlIgnore == null &&
+                ignoreDataMember == null &&
+                nonSerialized == null &&
+                (apiExplorerSetting == null || !apiExplorerSetting.IgnoreApi) &&
+                (!hasDataContractAttribute || hasMemberAttribute);
+        }
+
+        private string CreateDefaultDocumentation(Type type)
+        {
+            string documentation;
+            if (DefaultTypeDocumentation.TryGetValue(type, out documentation))
+            {
+                return documentation;
+            }
+            if (DocumentationProvider != null)
+            {
+                documentation = DocumentationProvider.GetDocumentation(type);
+            }
+
+            return documentation;
+        }
+
+        private void GenerateAnnotations(MemberInfo property, ParameterDescription propertyModel)
+        {
+            List<ParameterAnnotation> annotations = new List<ParameterAnnotation>();
+
+            IEnumerable<Attribute> attributes = property.GetCustomAttributes();
+            foreach (Attribute attribute in attributes)
+            {
+                Func<object, string> textGenerator;
+                if (AnnotationTextGenerator.TryGetValue(attribute.GetType(), out textGenerator))
+                {
+                    annotations.Add(
+                        new ParameterAnnotation
+                        {
+                            AnnotationAttribute = attribute,
+                            Documentation = textGenerator(attribute)
+                        });
+                }
+            }
+
+            // Rearrange the annotations
+            annotations.Sort((x, y) =>
+            {
+                // Special-case RequiredAttribute so that it shows up on top
+                if (x.AnnotationAttribute is RequiredAttribute)
+                {
+                    return -1;
+                }
+                if (y.AnnotationAttribute is RequiredAttribute)
+                {
+                    return 1;
+                }
+
+                // Sort the rest based on alphabetic order of the documentation
+                return String.Compare(x.Documentation, y.Documentation, StringComparison.OrdinalIgnoreCase);
+            });
+
+            foreach (ParameterAnnotation annotation in annotations)
+            {
+                propertyModel.Annotations.Add(annotation);
+            }
+        }
+
+        private CollectionModelDescription GenerateCollectionModelDescription(Type modelType, Type elementType)
+        {
+            ModelDescription collectionModelDescription = GetOrCreateModelDescription(elementType);
+            if (collectionModelDescription != null)
+            {
+                return new CollectionModelDescription
+                {
+                    Name = ModelNameHelper.GetModelName(modelType),
+                    ModelType = modelType,
+                    ElementDescription = collectionModelDescription
+                };
+            }
+
+            return null;
+        }
+
+        private ModelDescription GenerateComplexTypeModelDescription(Type modelType)
+        {
+            ComplexTypeModelDescription complexModelDescription = new ComplexTypeModelDescription
+            {
+                Name = ModelNameHelper.GetModelName(modelType),
+                ModelType = modelType,
+                Documentation = CreateDefaultDocumentation(modelType)
+            };
+
+            GeneratedModels.Add(complexModelDescription.Name, complexModelDescription);
+            bool hasDataContractAttribute = modelType.GetCustomAttribute<DataContractAttribute>() != null;
+            PropertyInfo[] properties = modelType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            foreach (PropertyInfo property in properties)
+            {
+                if (ShouldDisplayMember(property, hasDataContractAttribute))
+                {
+                    ParameterDescription propertyModel = new ParameterDescription
+                    {
+                        Name = GetMemberName(property, hasDataContractAttribute)
+                    };
+
+                    if (DocumentationProvider != null)
+                    {
+                        propertyModel.Documentation = DocumentationProvider.GetDocumentation(property);
+                    }
+
+                    GenerateAnnotations(property, propertyModel);
+                    complexModelDescription.Properties.Add(propertyModel);
+                    propertyModel.TypeDescription = GetOrCreateModelDescription(property.PropertyType);
+                }
+            }
+
+            FieldInfo[] fields = modelType.GetFields(BindingFlags.Public | BindingFlags.Instance);
+            foreach (FieldInfo field in fields)
+            {
+                if (ShouldDisplayMember(field, hasDataContractAttribute))
+                {
+                    ParameterDescription propertyModel = new ParameterDescription
+                    {
+                        Name = GetMemberName(field, hasDataContractAttribute)
+                    };
+
+                    if (DocumentationProvider != null)
+                    {
+                        propertyModel.Documentation = DocumentationProvider.GetDocumentation(field);
+                    }
+
+                    complexModelDescription.Properties.Add(propertyModel);
+                    propertyModel.TypeDescription = GetOrCreateModelDescription(field.FieldType);
+                }
+            }
+
+            return complexModelDescription;
+        }
+
+        private DictionaryModelDescription GenerateDictionaryModelDescription(Type modelType, Type keyType, Type valueType)
+        {
+            ModelDescription keyModelDescription = GetOrCreateModelDescription(keyType);
+            ModelDescription valueModelDescription = GetOrCreateModelDescription(valueType);
+
+            return new DictionaryModelDescription
+            {
+                Name = ModelNameHelper.GetModelName(modelType),
+                ModelType = modelType,
+                KeyModelDescription = keyModelDescription,
+                ValueModelDescription = valueModelDescription
+            };
+        }
+
+        private EnumTypeModelDescription GenerateEnumTypeModelDescription(Type modelType)
+        {
+            EnumTypeModelDescription enumDescription = new EnumTypeModelDescription
+            {
+                Name = ModelNameHelper.GetModelName(modelType),
+                ModelType = modelType,
+                Documentation = CreateDefaultDocumentation(modelType)
+            };
+            bool hasDataContractAttribute = modelType.GetCustomAttribute<DataContractAttribute>() != null;
+            foreach (FieldInfo field in modelType.GetFields(BindingFlags.Public | BindingFlags.Static))
+            {
+                if (ShouldDisplayMember(field, hasDataContractAttribute))
+                {
+                    EnumValueDescription enumValue = new EnumValueDescription
+                    {
+                        Name = field.Name,
+                        Value = field.GetRawConstantValue().ToString()
+                    };
+                    if (DocumentationProvider != null)
+                    {
+                        enumValue.Documentation = DocumentationProvider.GetDocumentation(field);
+                    }
+                    enumDescription.Values.Add(enumValue);
+                }
+            }
+            GeneratedModels.Add(enumDescription.Name, enumDescription);
+
+            return enumDescription;
+        }
+
+        private KeyValuePairModelDescription GenerateKeyValuePairModelDescription(Type modelType, Type keyType, Type valueType)
+        {
+            ModelDescription keyModelDescription = GetOrCreateModelDescription(keyType);
+            ModelDescription valueModelDescription = GetOrCreateModelDescription(valueType);
+
+            return new KeyValuePairModelDescription
+            {
+                Name = ModelNameHelper.GetModelName(modelType),
+                ModelType = modelType,
+                KeyModelDescription = keyModelDescription,
+                ValueModelDescription = valueModelDescription
+            };
+        }
+
+        private ModelDescription GenerateSimpleTypeModelDescription(Type modelType)
+        {
+            SimpleTypeModelDescription simpleModelDescription = new SimpleTypeModelDescription
+            {
+                Name = ModelNameHelper.GetModelName(modelType),
+                ModelType = modelType,
+                Documentation = CreateDefaultDocumentation(modelType)
+            };
+            GeneratedModels.Add(simpleModelDescription.Name, simpleModelDescription);
+
+            return simpleModelDescription;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/ModelNameAttribute.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    /// <summary>
+    /// Use this attribute to change the name of the <see cref="ModelDescription"/> generated for a type.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, AllowMultiple = false, Inherited = false)]
+    public sealed class ModelNameAttribute : Attribute
+    {
+        public ModelNameAttribute(string name)
+        {
+            Name = name;
+        }
+
+        public string Name { get; private set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/ModelNameHelper.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    internal static class ModelNameHelper
+    {
+        // Modify this to provide custom model name mapping.
+        public static string GetModelName(Type type)
+        {
+            ModelNameAttribute modelNameAttribute = type.GetCustomAttribute<ModelNameAttribute>();
+            if (modelNameAttribute != null && !String.IsNullOrEmpty(modelNameAttribute.Name))
+            {
+                return modelNameAttribute.Name;
+            }
+
+            string modelName = type.Name;
+            if (type.IsGenericType)
+            {
+                // Format the generic type name to something like: GenericOfAgurment1AndArgument2
+                Type genericType = type.GetGenericTypeDefinition();
+                Type[] genericArguments = type.GetGenericArguments();
+                string genericTypeName = genericType.Name;
+
+                // Trim the generic parameter counts from the name
+                genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf('`'));
+                string[] argumentTypeNames = genericArguments.Select(t => GetModelName(t)).ToArray();
+                modelName = String.Format(CultureInfo.InvariantCulture, "{0}Of{1}", genericTypeName, String.Join("And", argumentTypeNames));
+            }
+
+            return modelName;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/ParameterAnnotation.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class ParameterAnnotation
+    {
+        public Attribute AnnotationAttribute { get; set; }
+
+        public string Documentation { get; set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/ParameterDescription.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class ParameterDescription
+    {
+        public ParameterDescription()
+        {
+            Annotations = new Collection<ParameterAnnotation>();
+        }
+
+        public Collection<ParameterAnnotation> Annotations { get; private set; }
+
+        public string Documentation { get; set; }
+
+        public string Name { get; set; }
+
+        public ModelDescription TypeDescription { get; set; }
+    }
+}

Common/TestMVC/Areas/HelpPage/ModelDescriptions/SimpleTypeModelDescription.cs

@@ -0,0 +1,6 @@
+namespace TestMVC.Areas.HelpPage.ModelDescriptions
+{
+    public class SimpleTypeModelDescription : ModelDescription
+    {
+    }
+}

Common/TestMVC/Areas/HelpPage/Models/HelpPageApiModel.cs

@@ -0,0 +1,108 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Net.Http.Headers;
+using System.Web.Http.Description;
+using TestMVC.Areas.HelpPage.ModelDescriptions;
+
+namespace TestMVC.Areas.HelpPage.Models
+{
+    /// <summary>
+    /// The model that represents an API displayed on the help page.
+    /// </summary>
+    public class HelpPageApiModel
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HelpPageApiModel"/> class.
+        /// </summary>
+        public HelpPageApiModel()
+        {
+            UriParameters = new Collection<ParameterDescription>();
+            SampleRequests = new Dictionary<MediaTypeHeaderValue, object>();
+            SampleResponses = new Dictionary<MediaTypeHeaderValue, object>();
+            ErrorMessages = new Collection<string>();
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ApiDescription"/> that describes the API.
+        /// </summary>
+        public ApiDescription ApiDescription { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ParameterDescription"/> collection that describes the URI parameters for the API.
+        /// </summary>
+        public Collection<ParameterDescription> UriParameters { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the documentation for the request.
+        /// </summary>
+        public string RequestDocumentation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ModelDescription"/> that describes the request body.
+        /// </summary>
+        public ModelDescription RequestModelDescription { get; set; }
+
+        /// <summary>
+        /// Gets the request body parameter descriptions.
+        /// </summary>
+        public IList<ParameterDescription> RequestBodyParameters
+        {
+            get
+            {
+                return GetParameterDescriptions(RequestModelDescription);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="ModelDescription"/> that describes the resource.
+        /// </summary>
+        public ModelDescription ResourceDescription { get; set; }
+
+        /// <summary>
+        /// Gets the resource property descriptions.
+        /// </summary>
+        public IList<ParameterDescription> ResourceProperties
+        {
+            get
+            {
+                return GetParameterDescriptions(ResourceDescription);
+            }
+        }
+
+        /// <summary>
+        /// Gets the sample requests associated with the API.
+        /// </summary>
+        public IDictionary<MediaTypeHeaderValue, object> SampleRequests { get; private set; }
+
+        /// <summary>
+        /// Gets the sample responses associated with the API.
+        /// </summary>
+        public IDictionary<MediaTypeHeaderValue, object> SampleResponses { get; private set; }
+
+        /// <summary>
+        /// Gets the error messages associated with this model.
+        /// </summary>
+        public Collection<string> ErrorMessages { get; private set; }
+
+        private static IList<ParameterDescription> GetParameterDescriptions(ModelDescription modelDescription)
+        {
+            ComplexTypeModelDescription complexTypeModelDescription = modelDescription as ComplexTypeModelDescription;
+            if (complexTypeModelDescription != null)
+            {
+                return complexTypeModelDescription.Properties;
+            }
+
+            CollectionModelDescription collectionModelDescription = modelDescription as CollectionModelDescription;
+            if (collectionModelDescription != null)
+            {
+                complexTypeModelDescription = collectionModelDescription.ElementDescription as ComplexTypeModelDescription;
+                if (complexTypeModelDescription != null)
+                {
+                    return complexTypeModelDescription.Properties;
+                }
+            }
+
+            return null;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/SampleGeneration/HelpPageSampleGenerator.cs

@@ -0,0 +1,444 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using System.Web.Http.Description;
+using System.Xml.Linq;
+using Newtonsoft.Json;
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// This class will generate the samples for the help page.
+    /// </summary>
+    public class HelpPageSampleGenerator
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HelpPageSampleGenerator"/> class.
+        /// </summary>
+        public HelpPageSampleGenerator()
+        {
+            ActualHttpMessageTypes = new Dictionary<HelpPageSampleKey, Type>();
+            ActionSamples = new Dictionary<HelpPageSampleKey, object>();
+            SampleObjects = new Dictionary<Type, object>();
+            SampleObjectFactories = new List<Func<HelpPageSampleGenerator, Type, object>>
+            {
+                DefaultSampleObjectFactory,
+            };
+        }
+
+        /// <summary>
+        /// Gets CLR types that are used as the content of <see cref="HttpRequestMessage"/> or <see cref="HttpResponseMessage"/>.
+        /// </summary>
+        public IDictionary<HelpPageSampleKey, Type> ActualHttpMessageTypes { get; internal set; }
+
+        /// <summary>
+        /// Gets the objects that are used directly as samples for certain actions.
+        /// </summary>
+        public IDictionary<HelpPageSampleKey, object> ActionSamples { get; internal set; }
+
+        /// <summary>
+        /// Gets the objects that are serialized as samples by the supported formatters.
+        /// </summary>
+        public IDictionary<Type, object> SampleObjects { get; internal set; }
+
+        /// <summary>
+        /// Gets factories for the objects that the supported formatters will serialize as samples. Processed in order,
+        /// stopping when the factory successfully returns a non-<see langref="null"/> object.
+        /// </summary>
+        /// <remarks>
+        /// Collection includes just <see cref="ObjectGenerator.GenerateObject(Type)"/> initially. Use
+        /// <code>SampleObjectFactories.Insert(0, func)</code> to provide an override and
+        /// <code>SampleObjectFactories.Add(func)</code> to provide a fallback.</remarks>
+        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
+            Justification = "This is an appropriate nesting of generic types")]
+        public IList<Func<HelpPageSampleGenerator, Type, object>> SampleObjectFactories { get; private set; }
+
+        /// <summary>
+        /// Gets the request body samples for a given <see cref="ApiDescription"/>.
+        /// </summary>
+        /// <param name="api">The <see cref="ApiDescription"/>.</param>
+        /// <returns>The samples keyed by media type.</returns>
+        public IDictionary<MediaTypeHeaderValue, object> GetSampleRequests(ApiDescription api)
+        {
+            return GetSample(api, SampleDirection.Request);
+        }
+
+        /// <summary>
+        /// Gets the response body samples for a given <see cref="ApiDescription"/>.
+        /// </summary>
+        /// <param name="api">The <see cref="ApiDescription"/>.</param>
+        /// <returns>The samples keyed by media type.</returns>
+        public IDictionary<MediaTypeHeaderValue, object> GetSampleResponses(ApiDescription api)
+        {
+            return GetSample(api, SampleDirection.Response);
+        }
+
+        /// <summary>
+        /// Gets the request or response body samples.
+        /// </summary>
+        /// <param name="api">The <see cref="ApiDescription"/>.</param>
+        /// <param name="sampleDirection">The value indicating whether the sample is for a request or for a response.</param>
+        /// <returns>The samples keyed by media type.</returns>
+        public virtual IDictionary<MediaTypeHeaderValue, object> GetSample(ApiDescription api, SampleDirection sampleDirection)
+        {
+            if (api == null)
+            {
+                throw new ArgumentNullException("api");
+            }
+            string controllerName = api.ActionDescriptor.ControllerDescriptor.ControllerName;
+            string actionName = api.ActionDescriptor.ActionName;
+            IEnumerable<string> parameterNames = api.ParameterDescriptions.Select(p => p.Name);
+            Collection<MediaTypeFormatter> formatters;
+            Type type = ResolveType(api, controllerName, actionName, parameterNames, sampleDirection, out formatters);
+            var samples = new Dictionary<MediaTypeHeaderValue, object>();
+
+            // Use the samples provided directly for actions
+            var actionSamples = GetAllActionSamples(controllerName, actionName, parameterNames, sampleDirection);
+            foreach (var actionSample in actionSamples)
+            {
+                samples.Add(actionSample.Key.MediaType, WrapSampleIfString(actionSample.Value));
+            }
+
+            // Do the sample generation based on formatters only if an action doesn't return an HttpResponseMessage.
+            // Here we cannot rely on formatters because we don't know what's in the HttpResponseMessage, it might not even use formatters.
+            if (type != null && !typeof(HttpResponseMessage).IsAssignableFrom(type))
+            {
+                object sampleObject = GetSampleObject(type);
+                foreach (var formatter in formatters)
+                {
+                    foreach (MediaTypeHeaderValue mediaType in formatter.SupportedMediaTypes)
+                    {
+                        if (!samples.ContainsKey(mediaType))
+                        {
+                            object sample = GetActionSample(controllerName, actionName, parameterNames, type, formatter, mediaType, sampleDirection);
+
+                            // If no sample found, try generate sample using formatter and sample object
+                            if (sample == null && sampleObject != null)
+                            {
+                                sample = WriteSampleObjectUsingFormatter(formatter, sampleObject, type, mediaType);
+                            }
+
+                            samples.Add(mediaType, WrapSampleIfString(sample));
+                        }
+                    }
+                }
+            }
+
+            return samples;
+        }
+
+        /// <summary>
+        /// Search for samples that are provided directly through <see cref="ActionSamples"/>.
+        /// </summary>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        /// <param name="type">The CLR type.</param>
+        /// <param name="formatter">The formatter.</param>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="sampleDirection">The value indicating whether the sample is for a request or for a response.</param>
+        /// <returns>The sample that matches the parameters.</returns>
+        public virtual object GetActionSample(string controllerName, string actionName, IEnumerable<string> parameterNames, Type type, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, SampleDirection sampleDirection)
+        {
+            object sample;
+
+            // First, try to get the sample provided for the specified mediaType, sampleDirection, controllerName, actionName and parameterNames.
+            // If not found, try to get the sample provided for the specified mediaType, sampleDirection, controllerName and actionName regardless of the parameterNames.
+            // If still not found, try to get the sample provided for the specified mediaType and type.
+            // Finally, try to get the sample provided for the specified mediaType.
+            if (ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType, sampleDirection, controllerName, actionName, parameterNames), out sample) ||
+                ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType, sampleDirection, controllerName, actionName, new[] { "*" }), out sample) ||
+                ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType, type), out sample) ||
+                ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType), out sample))
+            {
+                return sample;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the sample object that will be serialized by the formatters. 
+        /// First, it will look at the <see cref="SampleObjects"/>. If no sample object is found, it will try to create
+        /// one using <see cref="DefaultSampleObjectFactory"/> (which wraps an <see cref="ObjectGenerator"/>) and other
+        /// factories in <see cref="SampleObjectFactories"/>.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <returns>The sample object.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "Even if all items in SampleObjectFactories throw, problem will be visible as missing sample.")]
+        public virtual object GetSampleObject(Type type)
+        {
+            object sampleObject;
+
+            if (!SampleObjects.TryGetValue(type, out sampleObject))
+            {
+                // No specific object available, try our factories.
+                foreach (Func<HelpPageSampleGenerator, Type, object> factory in SampleObjectFactories)
+                {
+                    if (factory == null)
+                    {
+                        continue;
+                    }
+
+                    try
+                    {
+                        sampleObject = factory(this, type);
+                        if (sampleObject != null)
+                        {
+                            break;
+                        }
+                    }
+                    catch
+                    {
+                        // Ignore any problems encountered in the factory; go on to the next one (if any).
+                    }
+                }
+            }
+
+            return sampleObject;
+        }
+
+        /// <summary>
+        /// Resolves the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
+        /// </summary>
+        /// <param name="api">The <see cref="ApiDescription"/>.</param>
+        /// <returns>The type.</returns>
+        public virtual Type ResolveHttpRequestMessageType(ApiDescription api)
+        {
+            string controllerName = api.ActionDescriptor.ControllerDescriptor.ControllerName;
+            string actionName = api.ActionDescriptor.ActionName;
+            IEnumerable<string> parameterNames = api.ParameterDescriptions.Select(p => p.Name);
+            Collection<MediaTypeFormatter> formatters;
+            return ResolveType(api, controllerName, actionName, parameterNames, SampleDirection.Request, out formatters);
+        }
+
+        /// <summary>
+        /// Resolves the type of the action parameter or return value when <see cref="HttpRequestMessage"/> or <see cref="HttpResponseMessage"/> is used.
+        /// </summary>
+        /// <param name="api">The <see cref="ApiDescription"/>.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        /// <param name="sampleDirection">The value indicating whether the sample is for a request or a response.</param>
+        /// <param name="formatters">The formatters.</param>
+        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", Justification = "This is only used in advanced scenarios.")]
+        public virtual Type ResolveType(ApiDescription api, string controllerName, string actionName, IEnumerable<string> parameterNames, SampleDirection sampleDirection, out Collection<MediaTypeFormatter> formatters)
+        {
+            if (!Enum.IsDefined(typeof(SampleDirection), sampleDirection))
+            {
+                throw new InvalidEnumArgumentException("sampleDirection", (int)sampleDirection, typeof(SampleDirection));
+            }
+            if (api == null)
+            {
+                throw new ArgumentNullException("api");
+            }
+            Type type;
+            if (ActualHttpMessageTypes.TryGetValue(new HelpPageSampleKey(sampleDirection, controllerName, actionName, parameterNames), out type) ||
+                ActualHttpMessageTypes.TryGetValue(new HelpPageSampleKey(sampleDirection, controllerName, actionName, new[] { "*" }), out type))
+            {
+                // Re-compute the supported formatters based on type
+                Collection<MediaTypeFormatter> newFormatters = new Collection<MediaTypeFormatter>();
+                foreach (var formatter in api.ActionDescriptor.Configuration.Formatters)
+                {
+                    if (IsFormatSupported(sampleDirection, formatter, type))
+                    {
+                        newFormatters.Add(formatter);
+                    }
+                }
+                formatters = newFormatters;
+            }
+            else
+            {
+                switch (sampleDirection)
+                {
+                    case SampleDirection.Request:
+                        ApiParameterDescription requestBodyParameter = api.ParameterDescriptions.FirstOrDefault(p => p.Source == ApiParameterSource.FromBody);
+                        type = requestBodyParameter == null ? null : requestBodyParameter.ParameterDescriptor.ParameterType;
+                        formatters = api.SupportedRequestBodyFormatters;
+                        break;
+                    case SampleDirection.Response:
+                    default:
+                        type = api.ResponseDescription.ResponseType ?? api.ResponseDescription.DeclaredType;
+                        formatters = api.SupportedResponseFormatters;
+                        break;
+                }
+            }
+
+            return type;
+        }
+
+        /// <summary>
+        /// Writes the sample object using formatter.
+        /// </summary>
+        /// <param name="formatter">The formatter.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="type">The type.</param>
+        /// <param name="mediaType">Type of the media.</param>
+        /// <returns></returns>
+        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is recorded as InvalidSample.")]
+        public virtual object WriteSampleObjectUsingFormatter(MediaTypeFormatter formatter, object value, Type type, MediaTypeHeaderValue mediaType)
+        {
+            if (formatter == null)
+            {
+                throw new ArgumentNullException("formatter");
+            }
+            if (mediaType == null)
+            {
+                throw new ArgumentNullException("mediaType");
+            }
+
+            object sample = String.Empty;
+            MemoryStream ms = null;
+            HttpContent content = null;
+            try
+            {
+                if (formatter.CanWriteType(type))
+                {
+                    ms = new MemoryStream();
+                    content = new ObjectContent(type, value, formatter, mediaType);
+                    formatter.WriteToStreamAsync(type, value, ms, content, null).Wait();
+                    ms.Position = 0;
+                    StreamReader reader = new StreamReader(ms);
+                    string serializedSampleString = reader.ReadToEnd();
+                    if (mediaType.MediaType.ToUpperInvariant().Contains("XML"))
+                    {
+                        serializedSampleString = TryFormatXml(serializedSampleString);
+                    }
+                    else if (mediaType.MediaType.ToUpperInvariant().Contains("JSON"))
+                    {
+                        serializedSampleString = TryFormatJson(serializedSampleString);
+                    }
+
+                    sample = new TextSample(serializedSampleString);
+                }
+                else
+                {
+                    sample = new InvalidSample(String.Format(
+                        CultureInfo.CurrentCulture,
+                        "Failed to generate the sample for media type '{0}'. Cannot use formatter '{1}' to write type '{2}'.",
+                        mediaType,
+                        formatter.GetType().Name,
+                        type.Name));
+                }
+            }
+            catch (Exception e)
+            {
+                sample = new InvalidSample(String.Format(
+                    CultureInfo.CurrentCulture,
+                    "An exception has occurred while using the formatter '{0}' to generate sample for media type '{1}'. Exception message: {2}",
+                    formatter.GetType().Name,
+                    mediaType.MediaType,
+                    UnwrapException(e).Message));
+            }
+            finally
+            {
+                if (ms != null)
+                {
+                    ms.Dispose();
+                }
+                if (content != null)
+                {
+                    content.Dispose();
+                }
+            }
+
+            return sample;
+        }
+
+        internal static Exception UnwrapException(Exception exception)
+        {
+            AggregateException aggregateException = exception as AggregateException;
+            if (aggregateException != null)
+            {
+                return aggregateException.Flatten().InnerException;
+            }
+            return exception;
+        }
+
+        // Default factory for sample objects
+        private static object DefaultSampleObjectFactory(HelpPageSampleGenerator sampleGenerator, Type type)
+        {
+            // Try to create a default sample object
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            return objectGenerator.GenerateObject(type);
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Handling the failure by returning the original string.")]
+        private static string TryFormatJson(string str)
+        {
+            try
+            {
+                object parsedJson = JsonConvert.DeserializeObject(str);
+                return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
+            }
+            catch
+            {
+                // can't parse JSON, return the original string
+                return str;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Handling the failure by returning the original string.")]
+        private static string TryFormatXml(string str)
+        {
+            try
+            {
+                XDocument xml = XDocument.Parse(str);
+                return xml.ToString();
+            }
+            catch
+            {
+                // can't parse XML, return the original string
+                return str;
+            }
+        }
+
+        private static bool IsFormatSupported(SampleDirection sampleDirection, MediaTypeFormatter formatter, Type type)
+        {
+            switch (sampleDirection)
+            {
+                case SampleDirection.Request:
+                    return formatter.CanReadType(type);
+                case SampleDirection.Response:
+                    return formatter.CanWriteType(type);
+            }
+            return false;
+        }
+
+        private IEnumerable<KeyValuePair<HelpPageSampleKey, object>> GetAllActionSamples(string controllerName, string actionName, IEnumerable<string> parameterNames, SampleDirection sampleDirection)
+        {
+            HashSet<string> parameterNamesSet = new HashSet<string>(parameterNames, StringComparer.OrdinalIgnoreCase);
+            foreach (var sample in ActionSamples)
+            {
+                HelpPageSampleKey sampleKey = sample.Key;
+                if (String.Equals(controllerName, sampleKey.ControllerName, StringComparison.OrdinalIgnoreCase) &&
+                    String.Equals(actionName, sampleKey.ActionName, StringComparison.OrdinalIgnoreCase) &&
+                    (sampleKey.ParameterNames.SetEquals(new[] { "*" }) || parameterNamesSet.SetEquals(sampleKey.ParameterNames)) &&
+                    sampleDirection == sampleKey.SampleDirection)
+                {
+                    yield return sample;
+                }
+            }
+        }
+
+        private static object WrapSampleIfString(object sample)
+        {
+            string stringSample = sample as string;
+            if (stringSample != null)
+            {
+                return new TextSample(stringSample);
+            }
+
+            return sample;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/SampleGeneration/HelpPageSampleKey.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Net.Http.Headers;
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// This is used to identify the place where the sample should be applied.
+    /// </summary>
+    public class HelpPageSampleKey
+    {
+        /// <summary>
+        /// Creates a new <see cref="HelpPageSampleKey"/> based on media type.
+        /// </summary>
+        /// <param name="mediaType">The media type.</param>
+        public HelpPageSampleKey(MediaTypeHeaderValue mediaType)
+        {
+            if (mediaType == null)
+            {
+                throw new ArgumentNullException("mediaType");
+            }
+
+            ActionName = String.Empty;
+            ControllerName = String.Empty;
+            MediaType = mediaType;
+            ParameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="HelpPageSampleKey"/> based on media type and CLR type.
+        /// </summary>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="type">The CLR type.</param>
+        public HelpPageSampleKey(MediaTypeHeaderValue mediaType, Type type)
+            : this(mediaType)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException("type");
+            }
+
+            ParameterType = type;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="HelpPageSampleKey"/> based on <see cref="SampleDirection"/>, controller name, action name and parameter names.
+        /// </summary>
+        /// <param name="sampleDirection">The <see cref="SampleDirection"/>.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        public HelpPageSampleKey(SampleDirection sampleDirection, string controllerName, string actionName, IEnumerable<string> parameterNames)
+        {
+            if (!Enum.IsDefined(typeof(SampleDirection), sampleDirection))
+            {
+                throw new InvalidEnumArgumentException("sampleDirection", (int)sampleDirection, typeof(SampleDirection));
+            }
+            if (controllerName == null)
+            {
+                throw new ArgumentNullException("controllerName");
+            }
+            if (actionName == null)
+            {
+                throw new ArgumentNullException("actionName");
+            }
+            if (parameterNames == null)
+            {
+                throw new ArgumentNullException("parameterNames");
+            }
+
+            ControllerName = controllerName;
+            ActionName = actionName;
+            ParameterNames = new HashSet<string>(parameterNames, StringComparer.OrdinalIgnoreCase);
+            SampleDirection = sampleDirection;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="HelpPageSampleKey"/> based on media type, <see cref="SampleDirection"/>, controller name, action name and parameter names.
+        /// </summary>
+        /// <param name="mediaType">The media type.</param>
+        /// <param name="sampleDirection">The <see cref="SampleDirection"/>.</param>
+        /// <param name="controllerName">Name of the controller.</param>
+        /// <param name="actionName">Name of the action.</param>
+        /// <param name="parameterNames">The parameter names.</param>
+        public HelpPageSampleKey(MediaTypeHeaderValue mediaType, SampleDirection sampleDirection, string controllerName, string actionName, IEnumerable<string> parameterNames)
+            : this(sampleDirection, controllerName, actionName, parameterNames)
+        {
+            if (mediaType == null)
+            {
+                throw new ArgumentNullException("mediaType");
+            }
+
+            MediaType = mediaType;
+        }
+
+        /// <summary>
+        /// Gets the name of the controller.
+        /// </summary>
+        /// <value>
+        /// The name of the controller.
+        /// </value>
+        public string ControllerName { get; private set; }
+
+        /// <summary>
+        /// Gets the name of the action.
+        /// </summary>
+        /// <value>
+        /// The name of the action.
+        /// </value>
+        public string ActionName { get; private set; }
+
+        /// <summary>
+        /// Gets the media type.
+        /// </summary>
+        /// <value>
+        /// The media type.
+        /// </value>
+        public MediaTypeHeaderValue MediaType { get; private set; }
+
+        /// <summary>
+        /// Gets the parameter names.
+        /// </summary>
+        public HashSet<string> ParameterNames { get; private set; }
+
+        public Type ParameterType { get; private set; }
+
+        /// <summary>
+        /// Gets the <see cref="SampleDirection"/>.
+        /// </summary>
+        public SampleDirection? SampleDirection { get; private set; }
+
+        public override bool Equals(object obj)
+        {
+            HelpPageSampleKey otherKey = obj as HelpPageSampleKey;
+            if (otherKey == null)
+            {
+                return false;
+            }
+
+            return String.Equals(ControllerName, otherKey.ControllerName, StringComparison.OrdinalIgnoreCase) &&
+                String.Equals(ActionName, otherKey.ActionName, StringComparison.OrdinalIgnoreCase) &&
+                (MediaType == otherKey.MediaType || (MediaType != null && MediaType.Equals(otherKey.MediaType))) &&
+                ParameterType == otherKey.ParameterType &&
+                SampleDirection == otherKey.SampleDirection &&
+                ParameterNames.SetEquals(otherKey.ParameterNames);
+        }
+
+        public override int GetHashCode()
+        {
+            int hashCode = ControllerName.ToUpperInvariant().GetHashCode() ^ ActionName.ToUpperInvariant().GetHashCode();
+            if (MediaType != null)
+            {
+                hashCode ^= MediaType.GetHashCode();
+            }
+            if (SampleDirection != null)
+            {
+                hashCode ^= SampleDirection.GetHashCode();
+            }
+            if (ParameterType != null)
+            {
+                hashCode ^= ParameterType.GetHashCode();
+            }
+            foreach (string parameterName in ParameterNames)
+            {
+                hashCode ^= parameterName.ToUpperInvariant().GetHashCode();
+            }
+
+            return hashCode;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/SampleGeneration/ImageSample.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// This represents an image sample on the help page. There's a display template named ImageSample associated with this class.
+    /// </summary>
+    public class ImageSample
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ImageSample"/> class.
+        /// </summary>
+        /// <param name="src">The URL of an image.</param>
+        public ImageSample(string src)
+        {
+            if (src == null)
+            {
+                throw new ArgumentNullException("src");
+            }
+            Src = src;
+        }
+
+        public string Src { get; private set; }
+
+        public override bool Equals(object obj)
+        {
+            ImageSample other = obj as ImageSample;
+            return other != null && Src == other.Src;
+        }
+
+        public override int GetHashCode()
+        {
+            return Src.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return Src;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/SampleGeneration/InvalidSample.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// This represents an invalid sample on the help page. There's a display template named InvalidSample associated with this class.
+    /// </summary>
+    public class InvalidSample
+    {
+        public InvalidSample(string errorMessage)
+        {
+            if (errorMessage == null)
+            {
+                throw new ArgumentNullException("errorMessage");
+            }
+            ErrorMessage = errorMessage;
+        }
+
+        public string ErrorMessage { get; private set; }
+
+        public override bool Equals(object obj)
+        {
+            InvalidSample other = obj as InvalidSample;
+            return other != null && ErrorMessage == other.ErrorMessage;
+        }
+
+        public override int GetHashCode()
+        {
+            return ErrorMessage.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return ErrorMessage;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/SampleGeneration/ObjectGenerator.cs

@@ -0,0 +1,456 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// This class will create an object of a given type and populate it with sample data.
+    /// </summary>
+    public class ObjectGenerator
+    {
+        internal const int DefaultCollectionSize = 2;
+        private readonly SimpleTypeObjectGenerator SimpleObjectGenerator = new SimpleTypeObjectGenerator();
+
+        /// <summary>
+        /// Generates an object for a given type. The type needs to be public, have a public default constructor and settable public properties/fields. Currently it supports the following types:
+        /// Simple types: <see cref="int"/>, <see cref="string"/>, <see cref="Enum"/>, <see cref="DateTime"/>, <see cref="Uri"/>, etc.
+        /// Complex types: POCO types.
+        /// Nullables: <see cref="Nullable{T}"/>.
+        /// Arrays: arrays of simple types or complex types.
+        /// Key value pairs: <see cref="KeyValuePair{TKey,TValue}"/>
+        /// Tuples: <see cref="Tuple{T1}"/>, <see cref="Tuple{T1,T2}"/>, etc
+        /// Dictionaries: <see cref="IDictionary{TKey,TValue}"/> or anything deriving from <see cref="IDictionary{TKey,TValue}"/>.
+        /// Collections: <see cref="IList{T}"/>, <see cref="IEnumerable{T}"/>, <see cref="ICollection{T}"/>, <see cref="IList"/>, <see cref="IEnumerable"/>, <see cref="ICollection"/> or anything deriving from <see cref="ICollection{T}"/> or <see cref="IList"/>.
+        /// Queryables: <see cref="IQueryable"/>, <see cref="IQueryable{T}"/>.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <returns>An object of the given type.</returns>
+        public object GenerateObject(Type type)
+        {
+            return GenerateObject(type, new Dictionary<Type, object>());
+        }
+
+        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Here we just want to return null if anything goes wrong.")]
+        private object GenerateObject(Type type, Dictionary<Type, object> createdObjectReferences)
+        {
+            try
+            {
+                if (SimpleTypeObjectGenerator.CanGenerateObject(type))
+                {
+                    return SimpleObjectGenerator.GenerateObject(type);
+                }
+
+                if (type.IsArray)
+                {
+                    return GenerateArray(type, DefaultCollectionSize, createdObjectReferences);
+                }
+
+                if (type.IsGenericType)
+                {
+                    return GenerateGenericType(type, DefaultCollectionSize, createdObjectReferences);
+                }
+
+                if (type == typeof(IDictionary))
+                {
+                    return GenerateDictionary(typeof(Hashtable), DefaultCollectionSize, createdObjectReferences);
+                }
+
+                if (typeof(IDictionary).IsAssignableFrom(type))
+                {
+                    return GenerateDictionary(type, DefaultCollectionSize, createdObjectReferences);
+                }
+
+                if (type == typeof(IList) ||
+                    type == typeof(IEnumerable) ||
+                    type == typeof(ICollection))
+                {
+                    return GenerateCollection(typeof(ArrayList), DefaultCollectionSize, createdObjectReferences);
+                }
+
+                if (typeof(IList).IsAssignableFrom(type))
+                {
+                    return GenerateCollection(type, DefaultCollectionSize, createdObjectReferences);
+                }
+
+                if (type == typeof(IQueryable))
+                {
+                    return GenerateQueryable(type, DefaultCollectionSize, createdObjectReferences);
+                }
+
+                if (type.IsEnum)
+                {
+                    return GenerateEnum(type);
+                }
+
+                if (type.IsPublic || type.IsNestedPublic)
+                {
+                    return GenerateComplexObject(type, createdObjectReferences);
+                }
+            }
+            catch
+            {
+                // Returns null if anything fails
+                return null;
+            }
+
+            return null;
+        }
+
+        private static object GenerateGenericType(Type type, int collectionSize, Dictionary<Type, object> createdObjectReferences)
+        {
+            Type genericTypeDefinition = type.GetGenericTypeDefinition();
+            if (genericTypeDefinition == typeof(Nullable<>))
+            {
+                return GenerateNullable(type, createdObjectReferences);
+            }
+
+            if (genericTypeDefinition == typeof(KeyValuePair<,>))
+            {
+                return GenerateKeyValuePair(type, createdObjectReferences);
+            }
+
+            if (IsTuple(genericTypeDefinition))
+            {
+                return GenerateTuple(type, createdObjectReferences);
+            }
+
+            Type[] genericArguments = type.GetGenericArguments();
+            if (genericArguments.Length == 1)
+            {
+                if (genericTypeDefinition == typeof(IList<>) ||
+                    genericTypeDefinition == typeof(IEnumerable<>) ||
+                    genericTypeDefinition == typeof(ICollection<>))
+                {
+                    Type collectionType = typeof(List<>).MakeGenericType(genericArguments);
+                    return GenerateCollection(collectionType, collectionSize, createdObjectReferences);
+                }
+
+                if (genericTypeDefinition == typeof(IQueryable<>))
+                {
+                    return GenerateQueryable(type, collectionSize, createdObjectReferences);
+                }
+
+                Type closedCollectionType = typeof(ICollection<>).MakeGenericType(genericArguments[0]);
+                if (closedCollectionType.IsAssignableFrom(type))
+                {
+                    return GenerateCollection(type, collectionSize, createdObjectReferences);
+                }
+            }
+
+            if (genericArguments.Length == 2)
+            {
+                if (genericTypeDefinition == typeof(IDictionary<,>))
+                {
+                    Type dictionaryType = typeof(Dictionary<,>).MakeGenericType(genericArguments);
+                    return GenerateDictionary(dictionaryType, collectionSize, createdObjectReferences);
+                }
+
+                Type closedDictionaryType = typeof(IDictionary<,>).MakeGenericType(genericArguments[0], genericArguments[1]);
+                if (closedDictionaryType.IsAssignableFrom(type))
+                {
+                    return GenerateDictionary(type, collectionSize, createdObjectReferences);
+                }
+            }
+
+            if (type.IsPublic || type.IsNestedPublic)
+            {
+                return GenerateComplexObject(type, createdObjectReferences);
+            }
+
+            return null;
+        }
+
+        private static object GenerateTuple(Type type, Dictionary<Type, object> createdObjectReferences)
+        {
+            Type[] genericArgs = type.GetGenericArguments();
+            object[] parameterValues = new object[genericArgs.Length];
+            bool failedToCreateTuple = true;
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            for (int i = 0; i < genericArgs.Length; i++)
+            {
+                parameterValues[i] = objectGenerator.GenerateObject(genericArgs[i], createdObjectReferences);
+                failedToCreateTuple &= parameterValues[i] == null;
+            }
+            if (failedToCreateTuple)
+            {
+                return null;
+            }
+            object result = Activator.CreateInstance(type, parameterValues);
+            return result;
+        }
+
+        private static bool IsTuple(Type genericTypeDefinition)
+        {
+            return genericTypeDefinition == typeof(Tuple<>) ||
+                genericTypeDefinition == typeof(Tuple<,>) ||
+                genericTypeDefinition == typeof(Tuple<,,>) ||
+                genericTypeDefinition == typeof(Tuple<,,,>) ||
+                genericTypeDefinition == typeof(Tuple<,,,,>) ||
+                genericTypeDefinition == typeof(Tuple<,,,,,>) ||
+                genericTypeDefinition == typeof(Tuple<,,,,,,>) ||
+                genericTypeDefinition == typeof(Tuple<,,,,,,,>);
+        }
+
+        private static object GenerateKeyValuePair(Type keyValuePairType, Dictionary<Type, object> createdObjectReferences)
+        {
+            Type[] genericArgs = keyValuePairType.GetGenericArguments();
+            Type typeK = genericArgs[0];
+            Type typeV = genericArgs[1];
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            object keyObject = objectGenerator.GenerateObject(typeK, createdObjectReferences);
+            object valueObject = objectGenerator.GenerateObject(typeV, createdObjectReferences);
+            if (keyObject == null && valueObject == null)
+            {
+                // Failed to create key and values
+                return null;
+            }
+            object result = Activator.CreateInstance(keyValuePairType, keyObject, valueObject);
+            return result;
+        }
+
+        private static object GenerateArray(Type arrayType, int size, Dictionary<Type, object> createdObjectReferences)
+        {
+            Type type = arrayType.GetElementType();
+            Array result = Array.CreateInstance(type, size);
+            bool areAllElementsNull = true;
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            for (int i = 0; i < size; i++)
+            {
+                object element = objectGenerator.GenerateObject(type, createdObjectReferences);
+                result.SetValue(element, i);
+                areAllElementsNull &= element == null;
+            }
+
+            if (areAllElementsNull)
+            {
+                return null;
+            }
+
+            return result;
+        }
+
+        private static object GenerateDictionary(Type dictionaryType, int size, Dictionary<Type, object> createdObjectReferences)
+        {
+            Type typeK = typeof(object);
+            Type typeV = typeof(object);
+            if (dictionaryType.IsGenericType)
+            {
+                Type[] genericArgs = dictionaryType.GetGenericArguments();
+                typeK = genericArgs[0];
+                typeV = genericArgs[1];
+            }
+
+            object result = Activator.CreateInstance(dictionaryType);
+            MethodInfo addMethod = dictionaryType.GetMethod("Add") ?? dictionaryType.GetMethod("TryAdd");
+            MethodInfo containsMethod = dictionaryType.GetMethod("Contains") ?? dictionaryType.GetMethod("ContainsKey");
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            for (int i = 0; i < size; i++)
+            {
+                object newKey = objectGenerator.GenerateObject(typeK, createdObjectReferences);
+                if (newKey == null)
+                {
+                    // Cannot generate a valid key
+                    return null;
+                }
+
+                bool containsKey = (bool)containsMethod.Invoke(result, new object[] { newKey });
+                if (!containsKey)
+                {
+                    object newValue = objectGenerator.GenerateObject(typeV, createdObjectReferences);
+                    addMethod.Invoke(result, new object[] { newKey, newValue });
+                }
+            }
+
+            return result;
+        }
+
+        private static object GenerateEnum(Type enumType)
+        {
+            Array possibleValues = Enum.GetValues(enumType);
+            if (possibleValues.Length > 0)
+            {
+                return possibleValues.GetValue(0);
+            }
+            return null;
+        }
+
+        private static object GenerateQueryable(Type queryableType, int size, Dictionary<Type, object> createdObjectReferences)
+        {
+            bool isGeneric = queryableType.IsGenericType;
+            object list;
+            if (isGeneric)
+            {
+                Type listType = typeof(List<>).MakeGenericType(queryableType.GetGenericArguments());
+                list = GenerateCollection(listType, size, createdObjectReferences);
+            }
+            else
+            {
+                list = GenerateArray(typeof(object[]), size, createdObjectReferences);
+            }
+            if (list == null)
+            {
+                return null;
+            }
+            if (isGeneric)
+            {
+                Type argumentType = typeof(IEnumerable<>).MakeGenericType(queryableType.GetGenericArguments());
+                MethodInfo asQueryableMethod = typeof(Queryable).GetMethod("AsQueryable", new[] { argumentType });
+                return asQueryableMethod.Invoke(null, new[] { list });
+            }
+
+            return Queryable.AsQueryable((IEnumerable)list);
+        }
+
+        private static object GenerateCollection(Type collectionType, int size, Dictionary<Type, object> createdObjectReferences)
+        {
+            Type type = collectionType.IsGenericType ?
+                collectionType.GetGenericArguments()[0] :
+                typeof(object);
+            object result = Activator.CreateInstance(collectionType);
+            MethodInfo addMethod = collectionType.GetMethod("Add");
+            bool areAllElementsNull = true;
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            for (int i = 0; i < size; i++)
+            {
+                object element = objectGenerator.GenerateObject(type, createdObjectReferences);
+                addMethod.Invoke(result, new object[] { element });
+                areAllElementsNull &= element == null;
+            }
+
+            if (areAllElementsNull)
+            {
+                return null;
+            }
+
+            return result;
+        }
+
+        private static object GenerateNullable(Type nullableType, Dictionary<Type, object> createdObjectReferences)
+        {
+            Type type = nullableType.GetGenericArguments()[0];
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            return objectGenerator.GenerateObject(type, createdObjectReferences);
+        }
+
+        private static object GenerateComplexObject(Type type, Dictionary<Type, object> createdObjectReferences)
+        {
+            object result = null;
+
+            if (createdObjectReferences.TryGetValue(type, out result))
+            {
+                // The object has been created already, just return it. This will handle the circular reference case.
+                return result;
+            }
+
+            if (type.IsValueType)
+            {
+                result = Activator.CreateInstance(type);
+            }
+            else
+            {
+                ConstructorInfo defaultCtor = type.GetConstructor(Type.EmptyTypes);
+                if (defaultCtor == null)
+                {
+                    // Cannot instantiate the type because it doesn't have a default constructor
+                    return null;
+                }
+
+                result = defaultCtor.Invoke(new object[0]);
+            }
+            createdObjectReferences.Add(type, result);
+            SetPublicProperties(type, result, createdObjectReferences);
+            SetPublicFields(type, result, createdObjectReferences);
+            return result;
+        }
+
+        private static void SetPublicProperties(Type type, object obj, Dictionary<Type, object> createdObjectReferences)
+        {
+            PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            foreach (PropertyInfo property in properties)
+            {
+                if (property.CanWrite)
+                {
+                    object propertyValue = objectGenerator.GenerateObject(property.PropertyType, createdObjectReferences);
+                    property.SetValue(obj, propertyValue, null);
+                }
+            }
+        }
+
+        private static void SetPublicFields(Type type, object obj, Dictionary<Type, object> createdObjectReferences)
+        {
+            FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
+            ObjectGenerator objectGenerator = new ObjectGenerator();
+            foreach (FieldInfo field in fields)
+            {
+                object fieldValue = objectGenerator.GenerateObject(field.FieldType, createdObjectReferences);
+                field.SetValue(obj, fieldValue);
+            }
+        }
+
+        private class SimpleTypeObjectGenerator
+        {
+            private long _index = 0;
+            private static readonly Dictionary<Type, Func<long, object>> DefaultGenerators = InitializeGenerators();
+
+            [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These are simple type factories and cannot be split up.")]
+            private static Dictionary<Type, Func<long, object>> InitializeGenerators()
+            {
+                return new Dictionary<Type, Func<long, object>>
+                {
+                    { typeof(Boolean), index => true },
+                    { typeof(Byte), index => (Byte)64 },
+                    { typeof(Char), index => (Char)65 },
+                    { typeof(DateTime), index => DateTime.Now },
+                    { typeof(DateTimeOffset), index => new DateTimeOffset(DateTime.Now) },
+                    { typeof(DBNull), index => DBNull.Value },
+                    { typeof(Decimal), index => (Decimal)index },
+                    { typeof(Double), index => (Double)(index + 0.1) },
+                    { typeof(Guid), index => Guid.NewGuid() },
+                    { typeof(Int16), index => (Int16)(index % Int16.MaxValue) },
+                    { typeof(Int32), index => (Int32)(index % Int32.MaxValue) },
+                    { typeof(Int64), index => (Int64)index },
+                    { typeof(Object), index => new object() },
+                    { typeof(SByte), index => (SByte)64 },
+                    { typeof(Single), index => (Single)(index + 0.1) },
+                    { 
+                        typeof(String), index =>
+                        {
+                            return String.Format(CultureInfo.CurrentCulture, "sample string {0}", index);
+                        }
+                    },
+                    { 
+                        typeof(TimeSpan), index =>
+                        {
+                            return TimeSpan.FromTicks(1234567);
+                        }
+                    },
+                    { typeof(UInt16), index => (UInt16)(index % UInt16.MaxValue) },
+                    { typeof(UInt32), index => (UInt32)(index % UInt32.MaxValue) },
+                    { typeof(UInt64), index => (UInt64)index },
+                    { 
+                        typeof(Uri), index =>
+                        {
+                            return new Uri(String.Format(CultureInfo.CurrentCulture, "http://webapihelppage{0}.com", index));
+                        }
+                    },
+                };
+            }
+
+            public static bool CanGenerateObject(Type type)
+            {
+                return DefaultGenerators.ContainsKey(type);
+            }
+
+            public object GenerateObject(Type type)
+            {
+                return DefaultGenerators[type](++_index);
+            }
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/SampleGeneration/SampleDirection.cs

@@ -0,0 +1,11 @@
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// Indicates whether the sample is used for request or response
+    /// </summary>
+    public enum SampleDirection
+    {
+        Request = 0,
+        Response
+    }
+}

Common/TestMVC/Areas/HelpPage/SampleGeneration/TextSample.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// This represents a preformatted text sample on the help page. There's a display template named TextSample associated with this class.
+    /// </summary>
+    public class TextSample
+    {
+        public TextSample(string text)
+        {
+            if (text == null)
+            {
+                throw new ArgumentNullException("text");
+            }
+            Text = text;
+        }
+
+        public string Text { get; private set; }
+
+        public override bool Equals(object obj)
+        {
+            TextSample other = obj as TextSample;
+            return other != null && Text == other.Text;
+        }
+
+        public override int GetHashCode()
+        {
+            return Text.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return Text;
+        }
+    }
+}

Common/TestMVC/Areas/HelpPage/Views/Help/Api.cshtml

@@ -0,0 +1,22 @@
+@using System.Web.Http
+@using TestMVC.Areas.HelpPage.Models
+@model HelpPageApiModel
+
+@{
+    var description = Model.ApiDescription;
+    ViewBag.Title = description.HttpMethod.Method + " " + description.RelativePath;
+}
+
+<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
+<div id="body" class="help-page">
+    <section class="featured">
+        <div class="content-wrapper">
+            <p>
+                @Html.ActionLink("Help Page Home", "Index")
+            </p>
+        </div>
+    </section>
+    <section class="content-wrapper main-content clear-fix">
+        @Html.DisplayForModel()
+    </section>
+</div>

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/ApiGroup.cshtml

@@ -0,0 +1,41 @@
+@using System.Web.Http
+@using System.Web.Http.Controllers
+@using System.Web.Http.Description
+@using TestMVC.Areas.HelpPage
+@using TestMVC.Areas.HelpPage.Models
+@model IGrouping<HttpControllerDescriptor, ApiDescription>
+
+@{
+    var controllerDocumentation = ViewBag.DocumentationProvider != null ? 
+        ViewBag.DocumentationProvider.GetDocumentation(Model.Key) : 
+        null;
+}
+
+<h2 id="@Model.Key.ControllerName">@Model.Key.ControllerName</h2>
+@if (!String.IsNullOrEmpty(controllerDocumentation))
+{
+    <p>@controllerDocumentation</p>
+}
+<table class="help-page-table">
+    <thead>
+        <tr><th>API</th><th>Description</th></tr>
+    </thead>
+    <tbody>
+    @foreach (var api in Model)
+    {
+        <tr>
+            <td class="api-name"><a href="@Url.Action("Api", "Help", new { apiId = api.GetFriendlyId() })">@api.HttpMethod.Method @api.RelativePath</a></td>
+            <td class="api-documentation">
+            @if (api.Documentation != null)
+            {
+                <p>@api.Documentation</p>
+            }
+            else
+            {
+                <p>No documentation available.</p>
+            }
+            </td>
+        </tr>
+    }
+    </tbody>
+</table>

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/CollectionModelDescription.cshtml

@@ -0,0 +1,6 @@
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model CollectionModelDescription
+@if (Model.ElementDescription is ComplexTypeModelDescription)
+{
+    @Html.DisplayFor(m => m.ElementDescription)
+}

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/ComplexTypeModelDescription.cshtml

@@ -0,0 +1,3 @@
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model ComplexTypeModelDescription
+@Html.DisplayFor(m => m.Properties, "Parameters")

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/DictionaryModelDescription.cshtml

@@ -0,0 +1,4 @@
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model DictionaryModelDescription
+Dictionary of @Html.DisplayFor(m => Model.KeyModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.KeyModelDescription }) [key]
+and @Html.DisplayFor(m => Model.ValueModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.ValueModelDescription }) [value]

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/EnumTypeModelDescription.cshtml

@@ -0,0 +1,24 @@
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model EnumTypeModelDescription
+
+<p>Possible enumeration values:</p>
+
+<table class="help-page-table">
+    <thead>
+        <tr><th>Name</th><th>Value</th><th>Description</th></tr>
+    </thead>
+    <tbody>
+        @foreach (EnumValueDescription value in Model.Values)
+        {
+            <tr>
+                <td class="enum-name"><b>@value.Name</b></td>
+                <td class="enum-value">
+                    <p>@value.Value</p>
+                </td>
+                <td class="enum-description">
+                    <p>@value.Documentation</p>
+                </td>
+            </tr>
+        }
+    </tbody>
+</table>

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/HelpPageApiModel.cshtml

@@ -0,0 +1,67 @@
+@using System.Web.Http
+@using System.Web.Http.Description
+@using TestMVC.Areas.HelpPage.Models
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model HelpPageApiModel
+
+@{
+    ApiDescription description = Model.ApiDescription;
+}
+<h1>@description.HttpMethod.Method @description.RelativePath</h1>
+<div>
+    <p>@description.Documentation</p>
+
+    <h2>Request Information</h2>
+
+    <h3>URI Parameters</h3>
+    @Html.DisplayFor(m => m.UriParameters, "Parameters")
+
+    <h3>Body Parameters</h3>
+
+    <p>@Model.RequestDocumentation</p>
+
+    @if (Model.RequestModelDescription != null)
+    {
+        @Html.DisplayFor(m => m.RequestModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.RequestModelDescription })
+        if (Model.RequestBodyParameters != null)
+        {
+            @Html.DisplayFor(m => m.RequestBodyParameters, "Parameters")
+        }
+    }
+    else
+    {
+        <p>None.</p>
+    }
+
+    @if (Model.SampleRequests.Count > 0)
+    {
+        <h3>Request Formats</h3>
+        @Html.DisplayFor(m => m.SampleRequests, "Samples")
+    }
+
+    <h2>Response Information</h2>
+
+    <h3>Resource Description</h3>
+
+    <p>@description.ResponseDescription.Documentation</p>
+
+    @if (Model.ResourceDescription != null)
+    {
+        @Html.DisplayFor(m => m.ResourceDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.ResourceDescription })
+        if (Model.ResourceProperties != null)
+        {
+            @Html.DisplayFor(m => m.ResourceProperties, "Parameters")
+        }
+    }
+    else
+    {
+        <p>None.</p>
+    }
+
+    @if (Model.SampleResponses.Count > 0)
+    {
+        <h3>Response Formats</h3>
+        @Html.DisplayFor(m => m.SampleResponses, "Samples")
+    }
+
+</div>

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/ImageSample.cshtml

@@ -0,0 +1,4 @@
+@using TestMVC.Areas.HelpPage
+@model ImageSample
+
+<img src="@Model.Src" />

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/InvalidSample.cshtml

@@ -0,0 +1,13 @@
+@using TestMVC.Areas.HelpPage
+@model InvalidSample
+
+@if (HttpContext.Current.IsDebuggingEnabled)
+{
+    <div class="warning-message-container">
+        <p>@Model.ErrorMessage</p>
+    </div>
+}
+else
+{
+    <p>Sample not available.</p>
+}

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/KeyValuePairModelDescription.cshtml

@@ -0,0 +1,4 @@
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model KeyValuePairModelDescription
+Pair of @Html.DisplayFor(m => Model.KeyModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.KeyModelDescription }) [key]
+and @Html.DisplayFor(m => Model.ValueModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.ValueModelDescription }) [value]

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/ModelDescriptionLink.cshtml

@@ -0,0 +1,26 @@
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model Type
+@{
+    ModelDescription modelDescription = ViewBag.modelDescription;
+    if (modelDescription is ComplexTypeModelDescription || modelDescription is EnumTypeModelDescription)
+    {
+        if (Model == typeof(Object))
+        {
+            @:Object
+        }
+        else
+        {
+            @Html.ActionLink(modelDescription.Name, "ResourceModel", "Help", new { modelName = modelDescription.Name }, null)
+        }
+    }
+    else if (modelDescription is CollectionModelDescription)
+    {
+        var collectionDescription = modelDescription as CollectionModelDescription;
+        var elementDescription = collectionDescription.ElementDescription;
+        @:Collection of @Html.DisplayFor(m => elementDescription.ModelType, "ModelDescriptionLink", new { modelDescription = elementDescription })
+    }
+    else
+    {
+        @Html.DisplayFor(m => modelDescription)
+    }
+}

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/Parameters.cshtml

@@ -0,0 +1,48 @@
+@using System.Collections.Generic
+@using System.Collections.ObjectModel
+@using System.Web.Http.Description
+@using System.Threading
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model IList<ParameterDescription>
+
+@if (Model.Count > 0)
+{
+    <table class="help-page-table">
+        <thead>
+            <tr><th>Name</th><th>Description</th><th>Type</th><th>Additional information</th></tr>
+        </thead>
+        <tbody>
+            @foreach (ParameterDescription parameter in Model)
+            {
+                ModelDescription modelDescription = parameter.TypeDescription;
+                <tr>
+                    <td class="parameter-name">@parameter.Name</td>
+                    <td class="parameter-documentation">
+                        <p>@parameter.Documentation</p>
+                    </td>
+                    <td class="parameter-type">
+                        @Html.DisplayFor(m => modelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = modelDescription })
+                    </td>
+                    <td class="parameter-annotations">
+                        @if (parameter.Annotations.Count > 0)
+                        {
+                            foreach (var annotation in parameter.Annotations)
+                            {
+                                <p>@annotation.Documentation</p>
+                            }
+                        }
+                        else
+                        {
+                            <p>None.</p>
+                        }
+                    </td>
+                </tr>
+            }
+        </tbody>
+    </table>
+}
+else
+{
+    <p>None.</p>
+}
+

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/Samples.cshtml

@@ -0,0 +1,30 @@
+@using System.Net.Http.Headers
+@model Dictionary<MediaTypeHeaderValue, object>
+
+@{
+    // Group the samples into a single tab if they are the same.
+    Dictionary<string, object> samples = Model.GroupBy(pair => pair.Value).ToDictionary(
+        pair => String.Join(", ", pair.Select(m => m.Key.ToString()).ToArray()), 
+        pair => pair.Key);
+    var mediaTypes = samples.Keys;
+}
+<div>
+    @foreach (var mediaType in mediaTypes)
+    {
+        <h4 class="sample-header">@mediaType</h4>
+        <div class="sample-content">
+            <span><b>Sample:</b></span>
+            @{
+                var sample = samples[mediaType];
+                if (sample == null)
+                {
+                    <p>Sample not available.</p>
+                }
+                else
+                {
+                    @Html.DisplayFor(s => sample);
+                }
+            }
+        </div>
+    }
+</div>

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/SimpleTypeModelDescription.cshtml

@@ -0,0 +1,3 @@
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model SimpleTypeModelDescription
+@Model.Documentation

Common/TestMVC/Areas/HelpPage/Views/Help/DisplayTemplates/TextSample.cshtml

@@ -0,0 +1,6 @@
+@using TestMVC.Areas.HelpPage
+@model TextSample
+
+<pre class="wrapped">
+@Model.Text
+</pre>

Common/TestMVC/Areas/HelpPage/Views/Help/Index.cshtml

@@ -0,0 +1,38 @@
+@using System.Web.Http
+@using System.Web.Http.Controllers
+@using System.Web.Http.Description
+@using System.Collections.ObjectModel
+@using TestMVC.Areas.HelpPage.Models
+@model Collection<ApiDescription>
+
+@{
+    ViewBag.Title = "ASP.NET Web API Help Page";
+
+    // Group APIs by controller
+    ILookup<HttpControllerDescriptor, ApiDescription> apiGroups = Model.ToLookup(api => api.ActionDescriptor.ControllerDescriptor);
+}
+
+<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
+<header class="help-page">
+    <div class="content-wrapper">
+        <div class="float-left">
+            <h1>@ViewBag.Title</h1>
+        </div>
+    </div>
+</header>
+<div id="body" class="help-page">
+    <section class="featured">
+        <div class="content-wrapper">
+            <h2>Introduction</h2>
+            <p>
+                Provide a general description of your APIs here.
+            </p>
+        </div>
+    </section>
+    <section class="content-wrapper main-content clear-fix">
+        @foreach (var group in apiGroups)
+        {
+            @Html.DisplayFor(m => group, "ApiGroup")
+        }
+    </section>
+</div>

Common/TestMVC/Areas/HelpPage/Views/Help/ResourceModel.cshtml

@@ -0,0 +1,19 @@
+@using System.Web.Http
+@using TestMVC.Areas.HelpPage.ModelDescriptions
+@model ModelDescription
+
+<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
+<div id="body" class="help-page">
+    <section class="featured">
+        <div class="content-wrapper">
+            <p>
+                @Html.ActionLink("Help Page Home", "Index")
+            </p>
+        </div>
+    </section>
+    <h1>@Model.Name</h1>
+    <p>@Model.Documentation</p>
+    <section class="content-wrapper main-content clear-fix">
+        @Html.DisplayFor(m => Model)
+    </section>
+</div>

Common/TestMVC/Areas/HelpPage/Views/Shared/_Layout.cshtml

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+    <title>@ViewBag.Title</title>
+    @RenderSection("scripts", required: false)
+</head>
+<body>
+    @RenderBody()
+</body>
+</html>

Common/TestMVC/Areas/HelpPage/Views/Web.config

@@ -0,0 +1,41 @@
+<?xml version="1.0"?>
+
+<configuration>
+  <configSections>
+    <sectionGroup name="system.web.webPages.razor" type="System.Web.WebPages.Razor.Configuration.RazorWebSectionGroup, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
+      <section name="host" type="System.Web.WebPages.Razor.Configuration.HostSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
+      <section name="pages" type="System.Web.WebPages.Razor.Configuration.RazorPagesSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
+    </sectionGroup>
+  </configSections>
+
+  <system.web.webPages.razor>
+    <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=5.2.4.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
+    <pages pageBaseType="System.Web.Mvc.WebViewPage">
+      <namespaces>
+        <add namespace="System.Web.Mvc" />
+        <add namespace="System.Web.Mvc.Ajax" />
+        <add namespace="System.Web.Mvc.Html" />
+        <add namespace="System.Web.Routing" />
+      </namespaces>
+    </pages>
+  </system.web.webPages.razor>
+
+  <appSettings>
+    <add key="webpages:Enabled" value="false" />
+  </appSettings>
+
+  <system.web>
+    <compilation debug="true">
+      <assemblies>
+        <add assembly="System.Net.Http, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+      </assemblies>
+    </compilation>
+  </system.web>
+
+  <system.webServer>
+    <handlers>
+      <remove name="BlockViewHandler"/>
+      <add name="BlockViewHandler" path="*" verb="*" preCondition="integratedMode" type="System.Web.HttpNotFoundHandler" />
+    </handlers>
+  </system.webServer>
+</configuration>

Common/TestMVC/Areas/HelpPage/Views/_ViewStart.cshtml

@@ -0,0 +1,4 @@
+@{
+    // Change the Layout path below to blend the look and feel of the help page with your existing web pages
+    Layout = "~/Views/Shared/_Layout.cshtml";
+}

Common/TestMVC/Areas/HelpPage/XmlDocumentationProvider.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Web.Http.Controllers;
+using System.Web.Http.Description;
+using System.Xml.XPath;
+using TestMVC.Areas.HelpPage.ModelDescriptions;
+
+namespace TestMVC.Areas.HelpPage
+{
+    /// <summary>
+    /// A custom <see cref="IDocumentationProvider"/> that reads the API documentation from an XML documentation file.
+    /// </summary>
+    public class XmlDocumentationProvider : IDocumentationProvider, IModelDocumentationProvider
+    {
+        private XPathNavigator _documentNavigator;
+        private const string TypeExpression = "/doc/members/member[@name='T:{0}']";
+        private const string MethodExpression = "/doc/members/member[@name='M:{0}']";
+        private const string PropertyExpression = "/doc/members/member[@name='P:{0}']";
+        private const string FieldExpression = "/doc/members/member[@name='F:{0}']";
+        private const string ParameterExpression = "param[@name='{0}']";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XmlDocumentationProvider"/> class.
+        /// </summary>
+        /// <param name="documentPath">The physical path to XML document.</param>
+        public XmlDocumentationProvider(string documentPath)
+        {
+            if (documentPath == null)
+            {
+                throw new ArgumentNullException("documentPath");
+            }
+            XPathDocument xpath = new XPathDocument(documentPath);
+            _documentNavigator = xpath.CreateNavigator();
+        }
+
+        public string GetDocumentation(HttpControllerDescriptor controllerDescriptor)
+        {
+            XPathNavigator typeNode = GetTypeNode(controllerDescriptor.ControllerType);
+            return GetTagValue(typeNode, "summary");
+        }
+
+        public virtual string GetDocumentation(HttpActionDescriptor actionDescriptor)
+        {
+            XPathNavigator methodNode = GetMethodNode(actionDescriptor);
+            return GetTagValue(methodNode, "summary");
+        }
+
+        public virtual string GetDocumentation(HttpParameterDescriptor parameterDescriptor)
+        {
+            ReflectedHttpParameterDescriptor reflectedParameterDescriptor = parameterDescriptor as ReflectedHttpParameterDescriptor;
+            if (reflectedParameterDescriptor != null)
+            {
+                XPathNavigator methodNode = GetMethodNode(reflectedParameterDescriptor.ActionDescriptor);
+                if (methodNode != null)
+                {
+                    string parameterName = reflectedParameterDescriptor.ParameterInfo.Name;
+                    XPathNavigator parameterNode = methodNode.SelectSingleNode(String.Format(CultureInfo.InvariantCulture, ParameterExpression, parameterName));
+                    if (parameterNode != null)
+                    {
+                        return parameterNode.Value.Trim();
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        public string GetResponseDocumentation(HttpActionDescriptor actionDescriptor)
+        {
+            XPathNavigator methodNode = GetMethodNode(actionDescriptor);
+            return GetTagValue(methodNode, "returns");
+        }
+
+        public string GetDocumentation(MemberInfo member)
+        {
+            string memberName = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", GetTypeName(member.DeclaringType), member.Name);
+            string expression = member.MemberType == MemberTypes.Field ? FieldExpression : PropertyExpression;
+            string selectExpression = String.Format(CultureInfo.InvariantCulture, expression, memberName);
+            XPathNavigator propertyNode = _documentNavigator.SelectSingleNode(selectExpression);
+            return GetTagValue(propertyNode, "summary");
+        }
+
+        public string GetDocumentation(Type type)
+        {
+            XPathNavigator typeNode = GetTypeNode(type);
+            return GetTagValue(typeNode, "summary");
+        }
+
+        private XPathNavigator GetMethodNode(HttpActionDescriptor actionDescriptor)
+        {
+            ReflectedHttpActionDescriptor reflectedActionDescriptor = actionDescriptor as ReflectedHttpActionDescriptor;
+            if (reflectedActionDescriptor != null)
+            {
+                string selectExpression = String.Format(CultureInfo.InvariantCulture, MethodExpression, GetMemberName(reflectedActionDescriptor.MethodInfo));
+                return _documentNavigator.SelectSingleNode(selectExpression);
+            }
+
+            return null;
+        }
+
+        private static string GetMemberName(MethodInfo method)
+        {
+            string name = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", GetTypeName(method.DeclaringType), method.Name);
+            ParameterInfo[] parameters = method.GetParameters();
+            if (parameters.Length != 0)
+            {
+                string[] parameterTypeNames = parameters.Select(param => GetTypeName(param.ParameterType)).ToArray();
+                name += String.Format(CultureInfo.InvariantCulture, "({0})", String.Join(",", parameterTypeNames));
+            }
+
+            return name;
+        }
+
+        private static string GetTagValue(XPathNavigator parentNode, string tagName)
+        {
+            if (parentNode != null)
+            {
+                XPathNavigator node = parentNode.SelectSingleNode(tagName);
+                if (node != null)
+                {
+                    return node.Value.Trim();
+                }
+            }
+
+            return null;
+        }
+
+        private XPathNavigator GetTypeNode(Type type)
+        {
+            string controllerTypeName = GetTypeName(type);
+            string selectExpression = String.Format(CultureInfo.InvariantCulture, TypeExpression, controllerTypeName);
+            return _documentNavigator.SelectSingleNode(selectExpression);
+        }
+
+        private static string GetTypeName(Type type)
+        {
+            string name = type.FullName;
+            if (type.IsGenericType)
+            {
+                // Format the generic type name to something like: Generic{System.Int32,System.String}
+                Type genericType = type.GetGenericTypeDefinition();
+                Type[] genericArguments = type.GetGenericArguments();
+                string genericTypeName = genericType.FullName;
+
+                // Trim the generic parameter counts from the name
+                genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf('`'));
+                string[] argumentTypeNames = genericArguments.Select(t => GetTypeName(t)).ToArray();
+                name = String.Format(CultureInfo.InvariantCulture, "{0}{{{1}}}", genericTypeName, String.Join(",", argumentTypeNames));
+            }
+            if (type.IsNested)
+            {
+                // Changing the nested type name from OuterType+InnerType to OuterType.InnerType to match the XML documentation syntax.
+                name = name.Replace("+", ".");
+            }
+
+            return name;
+        }
+    }
+}

Common/TestMVC/Content/Site.css

@@ -0,0 +1,17 @@
+body {
+    padding-top: 50px;
+    padding-bottom: 20px;
+}
+
+/* Set padding to keep content from hitting the edges */
+.body-content {
+    padding-left: 15px;
+    padding-right: 15px;
+}
+
+/* Set width on the form input elements since they're 100% wide by default */
+input,
+select,
+textarea {
+    max-width: 280px;
+}

Common/TestMVC/Content/bootstrap-theme.css

@@ -0,0 +1,587 @@
+/*!
+ * Bootstrap v3.3.7 (http://getbootstrap.com)
+ * Copyright 2011-2016 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ */
+.btn-default,
+.btn-primary,
+.btn-success,
+.btn-info,
+.btn-warning,
+.btn-danger {
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, .2);
+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);
+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 1px rgba(0, 0, 0, .075);
+}
+.btn-default:active,
+.btn-primary:active,
+.btn-success:active,
+.btn-info:active,
+.btn-warning:active,
+.btn-danger:active,
+.btn-default.active,
+.btn-primary.active,
+.btn-success.active,
+.btn-info.active,
+.btn-warning.active,
+.btn-danger.active {
+  -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
+          box-shadow: inset 0 3px 5px rgba(0, 0, 0, .125);
+}
+.btn-default.disabled,
+.btn-primary.disabled,
+.btn-success.disabled,
+.btn-info.disabled,
+.btn-warning.disabled,
+.btn-danger.disabled,
+.btn-default[disabled],
+.btn-primary[disabled],
+.btn-success[disabled],
+.btn-info[disabled],
+.btn-warning[disabled],
+.btn-danger[disabled],
+fieldset[disabled] .btn-default,
+fieldset[disabled] .btn-primary,
+fieldset[disabled] .btn-success,
+fieldset[disabled] .btn-info,
+fieldset[disabled] .btn-warning,
+fieldset[disabled] .btn-danger {
+  -webkit-box-shadow: none;
+          box-shadow: none;
+}
+.btn-default .badge,
+.btn-primary .badge,
+.btn-success .badge,
+.btn-info .badge,
+.btn-warning .badge,
+.btn-danger .badge {
+  text-shadow: none;
+}
+.btn:active,
+.btn.active {
+  background-image: none;
+}
+.btn-default {
+  text-shadow: 0 1px 0 #fff;
+  background-image: -webkit-linear-gradient(top, #fff 0%, #e0e0e0 100%);
+  background-image:      -o-linear-gradient(top, #fff 0%, #e0e0e0 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#fff), to(#e0e0e0));
+  background-image:         linear-gradient(to bottom, #fff 0%, #e0e0e0 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe0e0e0', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-color: #dbdbdb;
+  border-color: #ccc;
+}
+.btn-default:hover,
+.btn-default:focus {
+  background-color: #e0e0e0;
+  background-position: 0 -15px;
+}
+.btn-default:active,
+.btn-default.active {
+  background-color: #e0e0e0;
+  border-color: #dbdbdb;
+}
+.btn-default.disabled,
+.btn-default[disabled],
+fieldset[disabled] .btn-default,
+.btn-default.disabled:hover,
+.btn-default[disabled]:hover,
+fieldset[disabled] .btn-default:hover,
+.btn-default.disabled:focus,
+.btn-default[disabled]:focus,
+fieldset[disabled] .btn-default:focus,
+.btn-default.disabled.focus,
+.btn-default[disabled].focus,
+fieldset[disabled] .btn-default.focus,
+.btn-default.disabled:active,
+.btn-default[disabled]:active,
+fieldset[disabled] .btn-default:active,
+.btn-default.disabled.active,
+.btn-default[disabled].active,
+fieldset[disabled] .btn-default.active {
+  background-color: #e0e0e0;
+  background-image: none;
+}
+.btn-primary {
+  background-image: -webkit-linear-gradient(top, #337ab7 0%, #265a88 100%);
+  background-image:      -o-linear-gradient(top, #337ab7 0%, #265a88 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#265a88));
+  background-image:         linear-gradient(to bottom, #337ab7 0%, #265a88 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff265a88', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-color: #245580;
+}
+.btn-primary:hover,
+.btn-primary:focus {
+  background-color: #265a88;
+  background-position: 0 -15px;
+}
+.btn-primary:active,
+.btn-primary.active {
+  background-color: #265a88;
+  border-color: #245580;
+}
+.btn-primary.disabled,
+.btn-primary[disabled],
+fieldset[disabled] .btn-primary,
+.btn-primary.disabled:hover,
+.btn-primary[disabled]:hover,
+fieldset[disabled] .btn-primary:hover,
+.btn-primary.disabled:focus,
+.btn-primary[disabled]:focus,
+fieldset[disabled] .btn-primary:focus,
+.btn-primary.disabled.focus,
+.btn-primary[disabled].focus,
+fieldset[disabled] .btn-primary.focus,
+.btn-primary.disabled:active,
+.btn-primary[disabled]:active,
+fieldset[disabled] .btn-primary:active,
+.btn-primary.disabled.active,
+.btn-primary[disabled].active,
+fieldset[disabled] .btn-primary.active {
+  background-color: #265a88;
+  background-image: none;
+}
+.btn-success {
+  background-image: -webkit-linear-gradient(top, #5cb85c 0%, #419641 100%);
+  background-image:      -o-linear-gradient(top, #5cb85c 0%, #419641 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#5cb85c), to(#419641));
+  background-image:         linear-gradient(to bottom, #5cb85c 0%, #419641 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff419641', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-color: #3e8f3e;
+}
+.btn-success:hover,
+.btn-success:focus {
+  background-color: #419641;
+  background-position: 0 -15px;
+}
+.btn-success:active,
+.btn-success.active {
+  background-color: #419641;
+  border-color: #3e8f3e;
+}
+.btn-success.disabled,
+.btn-success[disabled],
+fieldset[disabled] .btn-success,
+.btn-success.disabled:hover,
+.btn-success[disabled]:hover,
+fieldset[disabled] .btn-success:hover,
+.btn-success.disabled:focus,
+.btn-success[disabled]:focus,
+fieldset[disabled] .btn-success:focus,
+.btn-success.disabled.focus,
+.btn-success[disabled].focus,
+fieldset[disabled] .btn-success.focus,
+.btn-success.disabled:active,
+.btn-success[disabled]:active,
+fieldset[disabled] .btn-success:active,
+.btn-success.disabled.active,
+.btn-success[disabled].active,
+fieldset[disabled] .btn-success.active {
+  background-color: #419641;
+  background-image: none;
+}
+.btn-info {
+  background-image: -webkit-linear-gradient(top, #5bc0de 0%, #2aabd2 100%);
+  background-image:      -o-linear-gradient(top, #5bc0de 0%, #2aabd2 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#5bc0de), to(#2aabd2));
+  background-image:         linear-gradient(to bottom, #5bc0de 0%, #2aabd2 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2aabd2', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-color: #28a4c9;
+}
+.btn-info:hover,
+.btn-info:focus {
+  background-color: #2aabd2;
+  background-position: 0 -15px;
+}
+.btn-info:active,
+.btn-info.active {
+  background-color: #2aabd2;
+  border-color: #28a4c9;
+}
+.btn-info.disabled,
+.btn-info[disabled],
+fieldset[disabled] .btn-info,
+.btn-info.disabled:hover,
+.btn-info[disabled]:hover,
+fieldset[disabled] .btn-info:hover,
+.btn-info.disabled:focus,
+.btn-info[disabled]:focus,
+fieldset[disabled] .btn-info:focus,
+.btn-info.disabled.focus,
+.btn-info[disabled].focus,
+fieldset[disabled] .btn-info.focus,
+.btn-info.disabled:active,
+.btn-info[disabled]:active,
+fieldset[disabled] .btn-info:active,
+.btn-info.disabled.active,
+.btn-info[disabled].active,
+fieldset[disabled] .btn-info.active {
+  background-color: #2aabd2;
+  background-image: none;
+}
+.btn-warning {
+  background-image: -webkit-linear-gradient(top, #f0ad4e 0%, #eb9316 100%);
+  background-image:      -o-linear-gradient(top, #f0ad4e 0%, #eb9316 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#f0ad4e), to(#eb9316));
+  background-image:         linear-gradient(to bottom, #f0ad4e 0%, #eb9316 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffeb9316', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-color: #e38d13;
+}
+.btn-warning:hover,
+.btn-warning:focus {
+  background-color: #eb9316;
+  background-position: 0 -15px;
+}
+.btn-warning:active,
+.btn-warning.active {
+  background-color: #eb9316;
+  border-color: #e38d13;
+}
+.btn-warning.disabled,
+.btn-warning[disabled],
+fieldset[disabled] .btn-warning,
+.btn-warning.disabled:hover,
+.btn-warning[disabled]:hover,
+fieldset[disabled] .btn-warning:hover,
+.btn-warning.disabled:focus,
+.btn-warning[disabled]:focus,
+fieldset[disabled] .btn-warning:focus,
+.btn-warning.disabled.focus,
+.btn-warning[disabled].focus,
+fieldset[disabled] .btn-warning.focus,
+.btn-warning.disabled:active,
+.btn-warning[disabled]:active,
+fieldset[disabled] .btn-warning:active,
+.btn-warning.disabled.active,
+.btn-warning[disabled].active,
+fieldset[disabled] .btn-warning.active {
+  background-color: #eb9316;
+  background-image: none;
+}
+.btn-danger {
+  background-image: -webkit-linear-gradient(top, #d9534f 0%, #c12e2a 100%);
+  background-image:      -o-linear-gradient(top, #d9534f 0%, #c12e2a 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9534f), to(#c12e2a));
+  background-image:         linear-gradient(to bottom, #d9534f 0%, #c12e2a 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc12e2a', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-color: #b92c28;
+}
+.btn-danger:hover,
+.btn-danger:focus {
+  background-color: #c12e2a;
+  background-position: 0 -15px;
+}
+.btn-danger:active,
+.btn-danger.active {
+  background-color: #c12e2a;
+  border-color: #b92c28;
+}
+.btn-danger.disabled,
+.btn-danger[disabled],
+fieldset[disabled] .btn-danger,
+.btn-danger.disabled:hover,
+.btn-danger[disabled]:hover,
+fieldset[disabled] .btn-danger:hover,
+.btn-danger.disabled:focus,
+.btn-danger[disabled]:focus,
+fieldset[disabled] .btn-danger:focus,
+.btn-danger.disabled.focus,
+.btn-danger[disabled].focus,
+fieldset[disabled] .btn-danger.focus,
+.btn-danger.disabled:active,
+.btn-danger[disabled]:active,
+fieldset[disabled] .btn-danger:active,
+.btn-danger.disabled.active,
+.btn-danger[disabled].active,
+fieldset[disabled] .btn-danger.active {
+  background-color: #c12e2a;
+  background-image: none;
+}
+.thumbnail,
+.img-thumbnail {
+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
+          box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
+}
+.dropdown-menu > li > a:hover,
+.dropdown-menu > li > a:focus {
+  background-color: #e8e8e8;
+  background-image: -webkit-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
+  background-image:      -o-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#f5f5f5), to(#e8e8e8));
+  background-image:         linear-gradient(to bottom, #f5f5f5 0%, #e8e8e8 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);
+  background-repeat: repeat-x;
+}
+.dropdown-menu > .active > a,
+.dropdown-menu > .active > a:hover,
+.dropdown-menu > .active > a:focus {
+  background-color: #2e6da4;
+  background-image: -webkit-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
+  background-image:      -o-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2e6da4));
+  background-image:         linear-gradient(to bottom, #337ab7 0%, #2e6da4 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);
+  background-repeat: repeat-x;
+}
+.navbar-default {
+  background-image: -webkit-linear-gradient(top, #fff 0%, #f8f8f8 100%);
+  background-image:      -o-linear-gradient(top, #fff 0%, #f8f8f8 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#fff), to(#f8f8f8));
+  background-image:         linear-gradient(to bottom, #fff 0%, #f8f8f8 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff8f8f8', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-radius: 4px;
+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 5px rgba(0, 0, 0, .075);
+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .15), 0 1px 5px rgba(0, 0, 0, .075);
+}
+.navbar-default .navbar-nav > .open > a,
+.navbar-default .navbar-nav > .active > a {
+  background-image: -webkit-linear-gradient(top, #dbdbdb 0%, #e2e2e2 100%);
+  background-image:      -o-linear-gradient(top, #dbdbdb 0%, #e2e2e2 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#dbdbdb), to(#e2e2e2));
+  background-image:         linear-gradient(to bottom, #dbdbdb 0%, #e2e2e2 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdbdbdb', endColorstr='#ffe2e2e2', GradientType=0);
+  background-repeat: repeat-x;
+  -webkit-box-shadow: inset 0 3px 9px rgba(0, 0, 0, .075);
+          box-shadow: inset 0 3px 9px rgba(0, 0, 0, .075);
+}
+.navbar-brand,
+.navbar-nav > li > a {
+  text-shadow: 0 1px 0 rgba(255, 255, 255, .25);
+}
+.navbar-inverse {
+  background-image: -webkit-linear-gradient(top, #3c3c3c 0%, #222 100%);
+  background-image:      -o-linear-gradient(top, #3c3c3c 0%, #222 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#3c3c3c), to(#222));
+  background-image:         linear-gradient(to bottom, #3c3c3c 0%, #222 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff3c3c3c', endColorstr='#ff222222', GradientType=0);
+  filter: progid:DXImageTransform.Microsoft.gradient(enabled = false);
+  background-repeat: repeat-x;
+  border-radius: 4px;
+}
+.navbar-inverse .navbar-nav > .open > a,
+.navbar-inverse .navbar-nav > .active > a {
+  background-image: -webkit-linear-gradient(top, #080808 0%, #0f0f0f 100%);
+  background-image:      -o-linear-gradient(top, #080808 0%, #0f0f0f 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#080808), to(#0f0f0f));
+  background-image:         linear-gradient(to bottom, #080808 0%, #0f0f0f 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff080808', endColorstr='#ff0f0f0f', GradientType=0);
+  background-repeat: repeat-x;
+  -webkit-box-shadow: inset 0 3px 9px rgba(0, 0, 0, .25);
+          box-shadow: inset 0 3px 9px rgba(0, 0, 0, .25);
+}
+.navbar-inverse .navbar-brand,
+.navbar-inverse .navbar-nav > li > a {
+  text-shadow: 0 -1px 0 rgba(0, 0, 0, .25);
+}
+.navbar-static-top,
+.navbar-fixed-top,
+.navbar-fixed-bottom {
+  border-radius: 0;
+}
+@media (max-width: 767px) {
+  .navbar .navbar-nav .open .dropdown-menu > .active > a,
+  .navbar .navbar-nav .open .dropdown-menu > .active > a:hover,
+  .navbar .navbar-nav .open .dropdown-menu > .active > a:focus {
+    color: #fff;
+    background-image: -webkit-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
+    background-image:      -o-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
+    background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2e6da4));
+    background-image:         linear-gradient(to bottom, #337ab7 0%, #2e6da4 100%);
+    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);
+    background-repeat: repeat-x;
+  }
+}
+.alert {
+  text-shadow: 0 1px 0 rgba(255, 255, 255, .2);
+  -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, .25), 0 1px 2px rgba(0, 0, 0, .05);
+          box-shadow: inset 0 1px 0 rgba(255, 255, 255, .25), 0 1px 2px rgba(0, 0, 0, .05);
+}
+.alert-success {
+  background-image: -webkit-linear-gradient(top, #dff0d8 0%, #c8e5bc 100%);
+  background-image:      -o-linear-gradient(top, #dff0d8 0%, #c8e5bc 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#dff0d8), to(#c8e5bc));
+  background-image:         linear-gradient(to bottom, #dff0d8 0%, #c8e5bc 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffc8e5bc', GradientType=0);
+  background-repeat: repeat-x;
+  border-color: #b2dba1;
+}
+.alert-info {
+  background-image: -webkit-linear-gradient(top, #d9edf7 0%, #b9def0 100%);
+  background-image:      -o-linear-gradient(top, #d9edf7 0%, #b9def0 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9edf7), to(#b9def0));
+  background-image:         linear-gradient(to bottom, #d9edf7 0%, #b9def0 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffb9def0', GradientType=0);
+  background-repeat: repeat-x;
+  border-color: #9acfea;
+}
+.alert-warning {
+  background-image: -webkit-linear-gradient(top, #fcf8e3 0%, #f8efc0 100%);
+  background-image:      -o-linear-gradient(top, #fcf8e3 0%, #f8efc0 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#fcf8e3), to(#f8efc0));
+  background-image:         linear-gradient(to bottom, #fcf8e3 0%, #f8efc0 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fff8efc0', GradientType=0);
+  background-repeat: repeat-x;
+  border-color: #f5e79e;
+}
+.alert-danger {
+  background-image: -webkit-linear-gradient(top, #f2dede 0%, #e7c3c3 100%);
+  background-image:      -o-linear-gradient(top, #f2dede 0%, #e7c3c3 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#f2dede), to(#e7c3c3));
+  background-image:         linear-gradient(to bottom, #f2dede 0%, #e7c3c3 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffe7c3c3', GradientType=0);
+  background-repeat: repeat-x;
+  border-color: #dca7a7;
+}
+.progress {
+  background-image: -webkit-linear-gradient(top, #ebebeb 0%, #f5f5f5 100%);
+  background-image:      -o-linear-gradient(top, #ebebeb 0%, #f5f5f5 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#ebebeb), to(#f5f5f5));
+  background-image:         linear-gradient(to bottom, #ebebeb 0%, #f5f5f5 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffebebeb', endColorstr='#fff5f5f5', GradientType=0);
+  background-repeat: repeat-x;
+}
+.progress-bar {
+  background-image: -webkit-linear-gradient(top, #337ab7 0%, #286090 100%);
+  background-image:      -o-linear-gradient(top, #337ab7 0%, #286090 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#286090));
+  background-image:         linear-gradient(to bottom, #337ab7 0%, #286090 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff286090', GradientType=0);
+  background-repeat: repeat-x;
+}
+.progress-bar-success {
+  background-image: -webkit-linear-gradient(top, #5cb85c 0%, #449d44 100%);
+  background-image:      -o-linear-gradient(top, #5cb85c 0%, #449d44 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#5cb85c), to(#449d44));
+  background-image:         linear-gradient(to bottom, #5cb85c 0%, #449d44 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5cb85c', endColorstr='#ff449d44', GradientType=0);
+  background-repeat: repeat-x;
+}
+.progress-bar-info {
+  background-image: -webkit-linear-gradient(top, #5bc0de 0%, #31b0d5 100%);
+  background-image:      -o-linear-gradient(top, #5bc0de 0%, #31b0d5 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#5bc0de), to(#31b0d5));
+  background-image:         linear-gradient(to bottom, #5bc0de 0%, #31b0d5 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff31b0d5', GradientType=0);
+  background-repeat: repeat-x;
+}
+.progress-bar-warning {
+  background-image: -webkit-linear-gradient(top, #f0ad4e 0%, #ec971f 100%);
+  background-image:      -o-linear-gradient(top, #f0ad4e 0%, #ec971f 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#f0ad4e), to(#ec971f));
+  background-image:         linear-gradient(to bottom, #f0ad4e 0%, #ec971f 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff0ad4e', endColorstr='#ffec971f', GradientType=0);
+  background-repeat: repeat-x;
+}
+.progress-bar-danger {
+  background-image: -webkit-linear-gradient(top, #d9534f 0%, #c9302c 100%);
+  background-image:      -o-linear-gradient(top, #d9534f 0%, #c9302c 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9534f), to(#c9302c));
+  background-image:         linear-gradient(to bottom, #d9534f 0%, #c9302c 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9534f', endColorstr='#ffc9302c', GradientType=0);
+  background-repeat: repeat-x;
+}
+.progress-bar-striped {
+  background-image: -webkit-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
+  background-image:      -o-linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
+  background-image:         linear-gradient(45deg, rgba(255, 255, 255, .15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, .15) 50%, rgba(255, 255, 255, .15) 75%, transparent 75%, transparent);
+}
+.list-group {
+  border-radius: 4px;
+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
+          box-shadow: 0 1px 2px rgba(0, 0, 0, .075);
+}
+.list-group-item.active,
+.list-group-item.active:hover,
+.list-group-item.active:focus {
+  text-shadow: 0 -1px 0 #286090;
+  background-image: -webkit-linear-gradient(top, #337ab7 0%, #2b669a 100%);
+  background-image:      -o-linear-gradient(top, #337ab7 0%, #2b669a 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2b669a));
+  background-image:         linear-gradient(to bottom, #337ab7 0%, #2b669a 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2b669a', GradientType=0);
+  background-repeat: repeat-x;
+  border-color: #2b669a;
+}
+.list-group-item.active .badge,
+.list-group-item.active:hover .badge,
+.list-group-item.active:focus .badge {
+  text-shadow: none;
+}
+.panel {
+  -webkit-box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
+          box-shadow: 0 1px 2px rgba(0, 0, 0, .05);
+}
+.panel-default > .panel-heading {
+  background-image: -webkit-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
+  background-image:      -o-linear-gradient(top, #f5f5f5 0%, #e8e8e8 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#f5f5f5), to(#e8e8e8));
+  background-image:         linear-gradient(to bottom, #f5f5f5 0%, #e8e8e8 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#ffe8e8e8', GradientType=0);
+  background-repeat: repeat-x;
+}
+.panel-primary > .panel-heading {
+  background-image: -webkit-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
+  background-image:      -o-linear-gradient(top, #337ab7 0%, #2e6da4 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#337ab7), to(#2e6da4));
+  background-image:         linear-gradient(to bottom, #337ab7 0%, #2e6da4 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff337ab7', endColorstr='#ff2e6da4', GradientType=0);
+  background-repeat: repeat-x;
+}
+.panel-success > .panel-heading {
+  background-image: -webkit-linear-gradient(top, #dff0d8 0%, #d0e9c6 100%);
+  background-image:      -o-linear-gradient(top, #dff0d8 0%, #d0e9c6 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#dff0d8), to(#d0e9c6));
+  background-image:         linear-gradient(to bottom, #dff0d8 0%, #d0e9c6 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffdff0d8', endColorstr='#ffd0e9c6', GradientType=0);
+  background-repeat: repeat-x;
+}
+.panel-info > .panel-heading {
+  background-image: -webkit-linear-gradient(top, #d9edf7 0%, #c4e3f3 100%);
+  background-image:      -o-linear-gradient(top, #d9edf7 0%, #c4e3f3 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#d9edf7), to(#c4e3f3));
+  background-image:         linear-gradient(to bottom, #d9edf7 0%, #c4e3f3 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffd9edf7', endColorstr='#ffc4e3f3', GradientType=0);
+  background-repeat: repeat-x;
+}
+.panel-warning > .panel-heading {
+  background-image: -webkit-linear-gradient(top, #fcf8e3 0%, #faf2cc 100%);
+  background-image:      -o-linear-gradient(top, #fcf8e3 0%, #faf2cc 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#fcf8e3), to(#faf2cc));
+  background-image:         linear-gradient(to bottom, #fcf8e3 0%, #faf2cc 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffcf8e3', endColorstr='#fffaf2cc', GradientType=0);
+  background-repeat: repeat-x;
+}
+.panel-danger > .panel-heading {
+  background-image: -webkit-linear-gradient(top, #f2dede 0%, #ebcccc 100%);
+  background-image:      -o-linear-gradient(top, #f2dede 0%, #ebcccc 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#f2dede), to(#ebcccc));
+  background-image:         linear-gradient(to bottom, #f2dede 0%, #ebcccc 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2dede', endColorstr='#ffebcccc', GradientType=0);
+  background-repeat: repeat-x;
+}
+.well {
+  background-image: -webkit-linear-gradient(top, #e8e8e8 0%, #f5f5f5 100%);
+  background-image:      -o-linear-gradient(top, #e8e8e8 0%, #f5f5f5 100%);
+  background-image: -webkit-gradient(linear, left top, left bottom, from(#e8e8e8), to(#f5f5f5));
+  background-image:         linear-gradient(to bottom, #e8e8e8 0%, #f5f5f5 100%);
+  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffe8e8e8', endColorstr='#fff5f5f5', GradientType=0);
+  background-repeat: repeat-x;
+  border-color: #dcdcdc;
+  -webkit-box-shadow: inset 0 1px 3px rgba(0, 0, 0, .05), 0 1px 0 rgba(255, 255, 255, .1);
+          box-shadow: inset 0 1px 3px rgba(0, 0, 0, .05), 0 1px 0 rgba(255, 255, 255, .1);
+}
+/*# sourceMappingURL=bootstrap-theme.css.map */

Common/TestMVC/Controllers/HomeController.cs

@@ -0,0 +1,17 @@
+namespace TestMVC.Controllers
+{
+    using System.Web.Mvc;
+
+    public class HomeController : Controller
+    {
+        public ActionResult Index()
+        {
+            return this.View();
+        }
+    }
+
+    public class register
+    {
+
+    }
+}

Common/TestMVC/Controllers/ValuesController.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Web.Http;
+
+namespace TestMVC.Controllers
+{
+    public class ValuesController : ApiController
+    {
+        // GET api/values
+        public IEnumerable<string> Get()
+        {
+            return new string[] { "value1", "value2" };
+        }
+
+        // GET api/values/5
+        public string Get(int id)
+        {
+            return "value";
+        }
+
+        // POST api/values
+        public void Post([FromBody]string value)
+        {
+        }
+
+        // PUT api/values/5
+        public void Put(int id, [FromBody]string value)
+        {
+        }
+
+        // DELETE api/values/5
+        public void Delete(int id)
+        {
+        }
+    }
+}

Common/TestMVC/Global.asax

@@ -0,0 +1 @@
+<%@ Application Codebehind="Global.asax.cs" Inherits="TestMVC.WebApiApplication" Language="C#" %>

Common/TestMVC/Global.asax.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Web.Http;
+using System.Web.Mvc;
+using System.Web.Optimization;
+using System.Web.Routing;
+
+namespace TestMVC
+{
+    public class WebApiApplication : System.Web.HttpApplication
+    {
+        protected void Application_Start()
+        {
+            AreaRegistration.RegisterAllAreas();
+            GlobalConfiguration.Configure(WebApiConfig.Register);
+            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
+            RouteConfig.RegisterRoutes(RouteTable.Routes);
+            BundleConfig.RegisterBundles(BundleTable.Bundles);
+        }
+    }
+}

Common/TestMVC/Properties/AssemblyInfo.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("TestMVC")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TestMVC")]
+[assembly: AssemblyCopyright("Copyright ©  2023")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("dfeeba77-96a3-44ab-bea9-5ca21fdcd446")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]