From af9c6a582f4f0acd185af9f413b30ae5fd30d3c4 Mon Sep 17 00:00:00 2001
From: mkochanowski <m.kochanowski@telemetria.eu>
Date: Tue, 26 Jul 2016 13:56:29 +0200
Subject: [PATCH] performance improvement

---
 Jil/Deserialize/InlineDeserializer.cs |   12 +-
 Jil/Deserialize/TypeCaches.cs         |  102 +-
 Jil/JSON.cs                           | 3037 ++++---------------------
 Jil/Options.cs                        |   55 +-
 Jil/Serialize/InlineSerializer.cs     |   12 +-
 Jil/Serialize/TypeCaches.cs           |  103 +-
 JilTests/SpeedProofTests.cs           |    5 +-
 7 files changed, 574 insertions(+), 2752 deletions(-)

diff --git a/Jil/Deserialize/InlineDeserializer.cs b/Jil/Deserialize/InlineDeserializer.cs
index 4b5849b6..f466bc18 100644
--- a/Jil/Deserialize/InlineDeserializer.cs
+++ b/Jil/Deserialize/InlineDeserializer.cs
@@ -27,6 +27,7 @@ class InlineDeserializer<ForType>
         const string CharBufferName = "char_buffer";
         const string StringBuilderName = "string_builder";
         
+        
         readonly Type OptionsType;
         readonly DateTimeFormat DateFormat;
         readonly SerializationNameFormat SerializationNameFormat;
@@ -1435,7 +1436,8 @@ void SkipObjectMember()
 
         void LoadRecursiveTypeDelegate(Type recursiveType)
         {
-            var typeCache = typeof(TypeCache<,>).MakeGenericType(OptionsType, recursiveType);
+   
+            var typeCache = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(OptionsType, recursiveType);
 
             FieldInfo thunk;
             if(ReadingFromString)
@@ -2639,11 +2641,11 @@ HashSet<Type> FindAndPrimeRecursiveOrReusedTypes(Type forType)
                 MethodInfo loadMtd;
                 if(ReadingFromString)
                 {
-                    loadMtd = typeof(TypeCache<,>).MakeGenericType(OptionsType, primeType).GetMethod("LoadFromString", BindingFlags.Public | BindingFlags.Static);
+                    loadMtd = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(OptionsType, primeType).GetMethod("LoadFromString", BindingFlags.Public | BindingFlags.Static);
                 }
                 else
                 {
-                    loadMtd = typeof(TypeCache<,>).MakeGenericType(OptionsType, primeType).GetMethod("Load", BindingFlags.Public | BindingFlags.Static);
+                    loadMtd = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(OptionsType, primeType).GetMethod("Load", BindingFlags.Public | BindingFlags.Static);
                 }
 
                 loadMtd.Invoke(null, new object[0]);
@@ -2700,7 +2702,7 @@ static class InlineDeserializerHelper
     {
         static Func<TextReader, int, ReturnType> BuildAlwaysFailsWithFromStream<ReturnType>(Type optionsType)
         {
-            var specificTypeCache = typeof(TypeCache<,>).MakeGenericType(optionsType, typeof(ReturnType));
+            var specificTypeCache = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(optionsType, typeof(ReturnType));
             var stashField = specificTypeCache.GetField("ExceptionDuringBuildFromStream", BindingFlags.Static | BindingFlags.Public);
 
             var emit = Emit.NewDynamicMethod(typeof(ReturnType), new[] { typeof(TextReader), typeof(int) });
@@ -2715,7 +2717,7 @@ static Func<TextReader, int, ReturnType> BuildAlwaysFailsWithFromStream<ReturnTy
 
         static StringThunkDelegate<ReturnType> BuildAlwaysFailsWithFromString<ReturnType>(Type optionsType)
         {
-            var specificTypeCache = typeof(TypeCache<,>).MakeGenericType(optionsType, typeof(ReturnType));
+            var specificTypeCache = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(optionsType, typeof(ReturnType));
             var stashField = specificTypeCache.GetField("ExceptionDuringBuildFromString", BindingFlags.Static | BindingFlags.Public);
 
             var emit = Emit.NewDynamicMethod(typeof(ReturnType), new[] { typeof(ThunkReader).MakeByRefType(), typeof(int) });
diff --git a/Jil/Deserialize/TypeCaches.cs b/Jil/Deserialize/TypeCaches.cs
index 72146438..9477e55b 100644
--- a/Jil/Deserialize/TypeCaches.cs
+++ b/Jil/Deserialize/TypeCaches.cs
@@ -1,74 +1,94 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+
 
 namespace Jil.Deserialize
 {
+    
     interface IDeserializeOptions
     {
         DateTimeFormat DateFormat { get; }
         SerializationNameFormat SerializationNameFormat { get; }
     }
 
-    static class TypeCache<TOptions, T>
+
+    internal interface IDeserializeTypeCache
+    {
+        Func<TextReader, int, T> Get<T>();
+        StringThunkDelegate<T> GetFromString<T>();
+    }
+
+     class TypeCache<TOptions> : IDeserializeTypeCache
         where TOptions : IDeserializeOptions, new()
     {
-        static readonly object ThunkInitLock = new object();
-        static volatile bool ThunkBeingBuilt = false;
-        public static volatile Func<TextReader, int, T> Thunk;
-        public static Exception ExceptionDuringBuildFromStream;
+        internal static class InnerTypeCache<T>
+        {
+            static readonly object ThunkInitLock = new object();
+            static volatile bool ThunkBeingBuilt = false;
+            public static volatile Func<TextReader, int, T> Thunk;
+            public static Exception ExceptionDuringBuildFromStream;
 
-        static readonly object StringThunkInitLock = new object();
-        static volatile bool StringThunkBeingBuilt = false;
-        public static volatile StringThunkDelegate<T> StringThunk;
-        public static Exception ExceptionDuringBuildFromString;
+            static readonly object StringThunkInitLock = new object();
+            static volatile bool StringThunkBeingBuilt = false;
+            public static volatile StringThunkDelegate<T> StringThunk;
+            public static Exception ExceptionDuringBuildFromString;
 
-        public static Func<TextReader, int, T> Get()
-        {
-            Load();
-            return Thunk;
-        }
+            public static Func<TextReader, int, T> Get()
+            {
+                Load();
+                return Thunk;
+            }
 
-        public static void Load()
-        {
-            if (Thunk != null) return;
+            public static void Load()
+            {
+                if (Thunk != null) return;
+
+                lock (ThunkInitLock)
+                {
+                    if (Thunk != null || ThunkBeingBuilt) return;
+                    ThunkBeingBuilt = true;
 
-            lock (ThunkInitLock)
+                    var options = new TOptions();
+
+                    Thunk = InlineDeserializerHelper.BuildFromStream<T>(typeof(TOptions), options.DateFormat, options.SerializationNameFormat, exceptionDuringBuild: out ExceptionDuringBuildFromStream);
+                }
+            }
+
+            public static StringThunkDelegate<T> GetFromString()
             {
-                if (Thunk != null || ThunkBeingBuilt) return;
-                ThunkBeingBuilt = true;
+                LoadFromString();
+                return StringThunk;
+            }
+
+            public static void LoadFromString()
+            {
+                if (StringThunk != null) return;
+
+                lock (StringThunkInitLock)
+                {
+                    if (StringThunk != null || StringThunkBeingBuilt) return;
+                    StringThunkBeingBuilt = true;
 
-                var options = new TOptions();
+                    var options = new TOptions();
 
-                Thunk = InlineDeserializerHelper.BuildFromStream<T>(typeof(TOptions), options.DateFormat, options.SerializationNameFormat, exceptionDuringBuild: out ExceptionDuringBuildFromStream);
+                    StringThunk = InlineDeserializerHelper.BuildFromString<T>(typeof(TOptions), options.DateFormat, options.SerializationNameFormat, exceptionDuringBuild: out ExceptionDuringBuildFromString);
+                }
             }
         }
 
-        public static StringThunkDelegate<T> GetFromString()
+        public Func<TextReader, int, T> Get<T>()
         {
-            LoadFromString();
-            return StringThunk;
+            return InnerTypeCache<T>.Get();
         }
 
-        public static void LoadFromString()
+        public StringThunkDelegate<T> GetFromString<T>()
         {
-            if (StringThunk != null) return;
-
-            lock (StringThunkInitLock)
-            {
-                if (StringThunk != null || StringThunkBeingBuilt) return;
-                StringThunkBeingBuilt = true;
-
-                var options = new TOptions();
-
-                StringThunk = InlineDeserializerHelper.BuildFromString<T>(typeof(TOptions), options.DateFormat, options.SerializationNameFormat, exceptionDuringBuild: out ExceptionDuringBuildFromString);
-            }
+            return InnerTypeCache<T>.GetFromString();
         }
     }
 
+  
+
     class MicrosoftStyle : IDeserializeOptions
     {
         public DateTimeFormat DateFormat { get { return DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch; } }
diff --git a/Jil/JSON.cs b/Jil/JSON.cs
index b4a3bf3a..3314f66f 100644
--- a/Jil/JSON.cs
+++ b/Jil/JSON.cs
@@ -111,2243 +111,12 @@ public static void Serialize<T>(T data, TextWriter output, Options options = nul
             GetWriterAction<T>(options)(output, data, 0);
         }
 
-        /// <summary>
-        /// Generated giant switch of option finding via OptionsGeneration.linq
-        /// </summary>
-        static Action<TextWriter, T, int> GetWriterAction<T>(Options options)
-        {
-            // Start OptionsGeneration.linq generated content: GetWriterAction
-            switch (options.UseDateTimeFormat)
-            {
-                case DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch:
-                    switch (options.ShouldPrettyPrint)
-                    {
-                        case false:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyle, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                        case true:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrint, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                    }
-                    break;
-                case DateTimeFormat.MillisecondsSinceUnixEpoch:
-                    switch (options.ShouldPrettyPrint)
-                    {
-                        case false:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<Milliseconds, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                        case true:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrint, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                    }
-                    break;
-                case DateTimeFormat.SecondsSinceUnixEpoch:
-                    switch (options.ShouldPrettyPrint)
-                    {
-                        case false:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<Seconds, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                        case true:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrint, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                    }
-                    break;
-                case DateTimeFormat.ISO8601:
-                    switch (options.ShouldPrettyPrint)
-                    {
-                        case false:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601CamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601Utc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601UtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601Inherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601InheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601InheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601InheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                        case true:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrint, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                    }
-                    break;
-                case DateTimeFormat.RFC1123:
-                    switch (options.ShouldPrettyPrint)
-                    {
-                        case false:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123CamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123Utc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123UtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123Inherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123InheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123InheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123InheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                        case true:
-                            switch (options.ShouldExcludeNulls)
-                            {
-                                case false:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrint, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                                case true:
-                                    switch (options.IsJSONP)
-                                    {
-                                        case false:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNulls, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                        case true:
-                                            switch (options.ShouldIncludeInherited)
-                                            {
-                                                case false:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONP, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                                case true:
-                                                    switch (options.UseUnspecifiedDateTimeKindBehavior)
-                                                    {
-                                                        case UnspecifiedDateTimeKindBehavior.IsLocal:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInherited, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                        case UnspecifiedDateTimeKindBehavior.IsUTC:
-                                                            switch (options.SerializationNameFormat)
-                                                            {
-                                                                case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedUtc, T>.Get();
-                                                                case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.Get();
-                                                            }
-                                                            break;
-                                                    }
-                                                    break;
-                                            }
-                                            break;
-                                    }
-                                    break;
-                            }
-                            break;
-                    }
-                    break;
-            }
-            // End OptionsGeneration.linq generated content: GetWriterAction
-
-            throw new InvalidOperationException("Unexpected Options: " + options);
-        }
 
 
-        /// <summary>
-        /// Generated giant switch of option finding via OptionsGeneration.linq
-        /// </summary>
-        static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
+        internal static Serialize.ISerializeTypeCache CreateSerializeTypeCache(Options options)
         {
-            // Start OptionsGeneration.linq generated content: GetThunkerDelegate 
-switch (options.UseDateTimeFormat)
+            // Start OptionsGeneration.linq generated content: GetWriterAction
+            switch (options.UseDateTimeFormat)
             {
                 case DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch:
                     switch (options.ShouldPrettyPrint)
@@ -2368,18 +137,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyle, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyle>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2391,18 +160,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2419,18 +188,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONP, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2442,18 +211,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2475,18 +244,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2498,18 +267,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2526,18 +295,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2549,18 +318,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStyleExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2587,18 +356,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrint, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrint>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2610,18 +379,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2638,18 +407,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONP, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2661,18 +430,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2694,18 +463,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2717,18 +486,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2745,18 +514,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2768,18 +537,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MicrosoftStylePrettyPrintExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2811,18 +580,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<Milliseconds, T>.GetToString();
+                                                                    return new TypeCache<Milliseconds>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2834,18 +603,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2862,18 +631,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONP, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2885,18 +654,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2918,18 +687,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2941,18 +710,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2969,18 +738,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -2992,18 +761,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3030,18 +799,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrint, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrint>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3053,18 +822,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3081,18 +850,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONP, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3104,18 +873,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3137,18 +906,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3160,18 +929,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3188,18 +957,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3211,18 +980,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<MillisecondsPrettyPrintExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3254,18 +1023,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<Seconds, T>.GetToString();
+                                                                    return new TypeCache<Seconds>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3277,18 +1046,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3305,18 +1074,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONP, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3328,18 +1097,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3361,18 +1130,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3384,18 +1153,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3412,18 +1181,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3435,18 +1204,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3473,18 +1242,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrint, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrint>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3496,18 +1265,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3524,18 +1293,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONP, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3547,18 +1316,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3580,18 +1349,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3603,18 +1372,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3631,18 +1400,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3654,18 +1423,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<SecondsPrettyPrintExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3697,18 +1466,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601, T>.GetToString();
+                                                                    return new TypeCache<ISO8601>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601CamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601CamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601Utc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601Utc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601UtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601UtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3720,18 +1489,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601Inherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601Inherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601InheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601InheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601InheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601InheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601InheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601InheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3748,18 +1517,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONP, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3771,18 +1540,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601JSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601JSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601JSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3804,18 +1573,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3827,18 +1596,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3855,18 +1624,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3878,18 +1647,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601ExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601ExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3916,18 +1685,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrint, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrint>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3939,18 +1708,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintInherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3967,18 +1736,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONP, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -3990,18 +1759,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4023,18 +1792,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4046,18 +1815,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4074,18 +1843,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4097,18 +1866,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<ISO8601PrettyPrintExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4140,18 +1909,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123, T>.GetToString();
+                                                                    return new TypeCache<RFC1123>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123CamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123CamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123Utc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123Utc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123UtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123UtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4163,18 +1932,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123Inherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123Inherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123InheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123InheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123InheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123InheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123InheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123InheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4191,18 +1960,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONP, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4214,18 +1983,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123JSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123JSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123JSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4247,18 +2016,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4270,18 +2039,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4298,18 +2067,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4321,18 +2090,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123ExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123ExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4359,18 +2128,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrint, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrint>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4382,18 +2151,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintInherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4410,18 +2179,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONP, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4433,18 +2202,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4466,18 +2235,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNulls, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNulls>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4489,18 +2258,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4517,18 +2286,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONP, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONP>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONPCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONPUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONPUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4540,18 +2309,18 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInherited, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInherited>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedCamelCase>();
                                                             }
                                                             break;
                                                         case UnspecifiedDateTimeKindBehavior.IsUTC:
                                                             switch (options.SerializationNameFormat)
                                                             {
                                                                 case SerializationNameFormat.Verbatim:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedUtc, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedUtc>();
                                                                 case SerializationNameFormat.CamelCase:
-                                                                    return TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedUtcCamelCase, T>.GetToString();
+                                                                    return new TypeCache<RFC1123PrettyPrintExcludeNullsJSONPInheritedUtcCamelCase>();
                                                             }
                                                             break;
                                                     }
@@ -4564,10 +2333,29 @@ static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
                             break;
                     }
                     break;
-            }
-            // End OptionsGeneration.linq generated content: GetThunkerDelegate
+            }
+            // End OptionsGeneration.linq generated content: GetWriterAction
 
             throw new InvalidOperationException("Unexpected Options: " + options);
+        }
+
+
+        /// <summary>
+        /// Generated giant switch of option finding via OptionsGeneration.linq
+        /// </summary>
+        static Action<TextWriter, T, int> GetWriterAction<T>(Options options)
+        {
+            return options.SerializeTypeCache.Get<T>();
+        }
+
+        
+
+        /// <summary>
+        /// Generated giant switch of option finding via OptionsGeneration.linq
+        /// </summary>
+        static StringThunkDelegate<T> GetThunkerDelegate<T>(Options options)
+        {
+            return options.SerializeTypeCache.GetToString<T>();
         }
 
         /// <summary>
@@ -4653,77 +2441,57 @@ public static object Deserialize(string text, Type type, Options options = null)
             }
 
             return Jil.Deserialize.DeserializeIndirect.DeserializeFromString(text, type, options);
-        }
-
-        /// <summary>
-        /// Deserializes JSON from the given TextReader.
-        /// 
-        /// Pass an Options object to specify the particulars (such as DateTime formats) of
-        /// the JSON being deserialized.  If omitted Options.Default is used, unless JSON.SetDefaultOptions(Options) has been
-        /// called with a different Options object.
-        /// </summary>
-        public static T Deserialize<T>(TextReader reader, Options options = null)
-        {
-            if (reader == null)
-            {
-                throw new ArgumentNullException("reader");
-            }
-
-            if (typeof(T) == typeof(object))
-            {
-                return DeserializeDynamic(reader, options);
-            }
+        }
 
+        internal static Deserialize.IDeserializeTypeCache CreateDeserializeTypeCache(Options options)
+        {
             try
             {
-                options = options ?? DefaultOptions;
-                reader = reader.MakeSupportPeek();
-
                 switch (options.UseDateTimeFormat)
                 {
                     case DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch:
                         switch (options.SerializationNameFormat)
                         {
                             case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyle, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyle>();
                             case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyleCamelCase, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyleCamelCase>();
                         }
                         break;
                     case DateTimeFormat.MillisecondsSinceUnixEpoch:
                         switch (options.SerializationNameFormat)
                         {
                             case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MillisecondStyle, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.MillisecondStyle>();
                             case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MillisecondStyleCamelCase, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.MillisecondStyleCamelCase>();
                         }
                         break;
                     case DateTimeFormat.SecondsSinceUnixEpoch:
                         switch (options.SerializationNameFormat)
                         {
                             case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.SecondStyle, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.SecondStyle>();
                             case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.SecondStyleCamelCase, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.SecondStyleCamelCase>();
                         }
                         break;
                     case DateTimeFormat.ISO8601:
                         switch (options.SerializationNameFormat)
                         {
                             case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.ISO8601Style, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.ISO8601Style>();
                             case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.ISO8601StyleCamelCase, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.ISO8601StyleCamelCase>();
                         }
                         break;
                     case DateTimeFormat.RFC1123:
                         switch (options.SerializationNameFormat)
                         {
                             case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.RFC1123Style, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.RFC1123Style>();
                             case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.RFC1123StyleCamelCase, T>.Get()(reader, 0);
+                                return new Jil.Deserialize.TypeCache<Jil.Deserialize.RFC1123StyleCamelCase>();
                         }
                         break;
                 }
@@ -4733,6 +2501,44 @@ public static T Deserialize<T>(TextReader reader, Options options = null)
             {
                 if (e is DeserializationException) throw;
 
+                throw new DeserializationException(e, false);
+            }
+        }
+
+        /// <summary>
+        /// Deserializes JSON from the given TextReader.
+        /// 
+        /// Pass an Options object to specify the particulars (such as DateTime formats) of
+        /// the JSON being deserialized.  If omitted Options.Default is used, unless JSON.SetDefaultOptions(Options) has been
+        /// called with a different Options object.
+        /// </summary>
+        public static T Deserialize<T>(TextReader reader, Options options = null)
+        {
+            if (reader == null)
+            {
+                throw new ArgumentNullException("reader");
+            }
+
+            if (typeof(T) == typeof(object))
+            {
+                return DeserializeDynamic(reader, options);
+            }
+
+            try
+            {
+                options = options ?? DefaultOptions;
+                reader = reader.MakeSupportPeek();
+
+
+                options = options ?? DefaultOptions;
+
+
+                return options.DeserializeTypeCache.Get<T>()(reader, 0);
+            }
+            catch (Exception e)
+            {
+                if (e is DeserializationException) throw;
+
                 throw new DeserializationException(e, reader, false);
             }
         }
@@ -4760,57 +2566,10 @@ public static T Deserialize<T>(string text, Options options = null)
             {
                 options = options ?? DefaultOptions;
 
-                var thunk = new Jil.Deserialize.ThunkReader(text);
+                var thunk = new Deserialize.ThunkReader(text);
 
-                switch (options.UseDateTimeFormat)
-                {
-                    case DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch:
-                        switch (options.SerializationNameFormat)
-                        {
-                            case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyle, T>.GetFromString()(ref thunk, 0);
-                            case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyleCamelCase, T>.GetFromString()(ref thunk, 0);
-                        }
-                        break;
-                    case DateTimeFormat.MillisecondsSinceUnixEpoch:
-                        switch (options.SerializationNameFormat)
-                        {
-                            case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MillisecondStyle, T>.GetFromString()(ref thunk, 0);
-                            case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.MillisecondStyleCamelCase, T>.GetFromString()(ref thunk, 0);
-                        }
-                        break;
-                    case DateTimeFormat.SecondsSinceUnixEpoch:
-                        switch (options.SerializationNameFormat)
-                        {
-                            case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.SecondStyle, T>.GetFromString()(ref thunk, 0);
-                            case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.SecondStyleCamelCase, T>.GetFromString()(ref thunk, 0);
-                        }
-                        break;
-                    case DateTimeFormat.ISO8601:
-                        switch (options.SerializationNameFormat)
-                        {
-                            case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.ISO8601Style, T>.GetFromString()(ref thunk, 0);
-                            case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.ISO8601StyleCamelCase, T>.GetFromString()(ref thunk, 0);
-                        }
-                        break;
-                    case DateTimeFormat.RFC1123:
-                        switch (options.SerializationNameFormat)
-                        {
-                            case SerializationNameFormat.Verbatim:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.RFC1123Style, T>.GetFromString()(ref thunk, 0);
-                            case SerializationNameFormat.CamelCase:
-                                return Jil.Deserialize.TypeCache<Jil.Deserialize.RFC1123StyleCamelCase, T>.GetFromString()(ref thunk, 0);
-                        }
-                        break;
-                }
-                throw new InvalidOperationException("Unexpected Options: " + options);
+               return options.DeserializeTypeCache.GetFromString<T>()(ref thunk, 0);
+              
             }
             catch (Exception e)
             {
diff --git a/Jil/Options.cs b/Jil/Options.cs
index 1f2117bf..39930547 100644
--- a/Jil/Options.cs
+++ b/Jil/Options.cs
@@ -10,6 +10,11 @@ namespace Jil
     /// </summary>
     public sealed class Options
     {
+        #region  Defined Options
+
+
+
+
 #pragma warning disable 1591
         // Start OptionsGeneration.linq generated content
         public static readonly Options Default = new Options(dateFormat: DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch);
@@ -335,6 +340,9 @@ public sealed class Options
         // End OptionsGeneration.linq generated content
 #pragma warning restore 1591
 
+
+        #endregion
+
         internal bool ShouldPrettyPrint { get; private set; }
         internal bool ShouldExcludeNulls { get; private set; }
         internal DateTimeFormat UseDateTimeFormat { get; private set; }
@@ -467,22 +475,37 @@ public override int GetHashCode()
                 unspecifiedMask;
         }
 
-        /// <summary>
-        /// Returns true if two Options are equal, and false otherwise
-        /// </summary>
-        public override bool Equals(object obj)
-        {
-            var other = obj as Options;
-            if (other == null) return false;
-
-            return
-                other.UseDateTimeFormat == this.UseDateTimeFormat &&
-                other.ShouldPrettyPrint == this.ShouldPrettyPrint &&
-                other.ShouldExcludeNulls == this.ShouldExcludeNulls &&
-                other.IsJSONP == this.IsJSONP &&
-                other.ShouldIncludeInherited == this.ShouldIncludeInherited &&
-                other.UseUnspecifiedDateTimeKindBehavior == this.UseUnspecifiedDateTimeKindBehavior &&
-                other.SerializationNameFormat == this.SerializationNameFormat;
+        /// <summary>
+        /// Returns true if two Options are equal, and false otherwise
+        /// </summary>
+        public override bool Equals(object obj)
+        {
+            var other = obj as Options;
+            if (other == null) return false;
+
+            return
+                other.UseDateTimeFormat == this.UseDateTimeFormat &&
+                other.ShouldPrettyPrint == this.ShouldPrettyPrint &&
+                other.ShouldExcludeNulls == this.ShouldExcludeNulls &&
+                other.IsJSONP == this.IsJSONP &&
+                other.ShouldIncludeInherited == this.ShouldIncludeInherited &&
+                other.UseUnspecifiedDateTimeKindBehavior == this.UseUnspecifiedDateTimeKindBehavior &&
+                other.SerializationNameFormat == this.SerializationNameFormat;
+        }
+
+        private Deserialize.IDeserializeTypeCache _deserializeTypeCache;
+
+        internal Deserialize.IDeserializeTypeCache DeserializeTypeCache
+        {
+            get { return _deserializeTypeCache ?? (_deserializeTypeCache = JSON.CreateDeserializeTypeCache(this)); }
         }
+
+
+        private Serialize.ISerializeTypeCache _serializeTypeCache;
+
+        internal Serialize.ISerializeTypeCache SerializeTypeCache
+        {
+            get { return _serializeTypeCache ?? (_serializeTypeCache = JSON.CreateSerializeTypeCache(this)); }
+        }
     }
 }
\ No newline at end of file
diff --git a/Jil/Serialize/InlineSerializer.cs b/Jil/Serialize/InlineSerializer.cs
index 4d2b6ac7..5c994f79 100644
--- a/Jil/Serialize/InlineSerializer.cs
+++ b/Jil/Serialize/InlineSerializer.cs
@@ -3867,8 +3867,10 @@ void WriteEnum(Type enumType, bool popTextWriter, bool containedInNullable)
                 }
                 else
                 {
+
+
                     // static case
-                    var cacheType = typeof(TypeCache<,>).MakeGenericType(RecursionLookupOptionsType, type);
+                    var cacheType = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(RecursionLookupOptionsType, type);
                     FieldInfo thunk;
 
                     if (BuildingToString)
@@ -3985,11 +3987,11 @@ HashSet<Type> FindAndPrimeRecursiveOrReusedTypes(Type forType)
                 MethodInfo loadMtd;
                 if (BuildingToString)
                 {
-                    loadMtd = typeof(TypeCache<,>).MakeGenericType(RecursionLookupOptionsType, primeType).GetMethod("LoadToString", BindingFlags.Public | BindingFlags.Static);
+                    loadMtd = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(RecursionLookupOptionsType, primeType).GetMethod("LoadToString", BindingFlags.Public | BindingFlags.Static);
                 }
                 else
                 {
-                    loadMtd = typeof(TypeCache<,>).MakeGenericType(RecursionLookupOptionsType, primeType).GetMethod("Load", BindingFlags.Public | BindingFlags.Static);
+                    loadMtd = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(RecursionLookupOptionsType, primeType).GetMethod("Load", BindingFlags.Public | BindingFlags.Static);
                 }
 
                 loadMtd.Invoke(null, new object[0]);
@@ -4292,7 +4294,7 @@ static class InlineSerializerHelper
     {
         static Action<TextWriter, BuildForType, int> BuildAlwaysFailsWith<BuildForType>(Type optionsType)
         {
-            var specificTypeCache = typeof(TypeCache<,>).MakeGenericType(optionsType, typeof(BuildForType));
+            var specificTypeCache = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(optionsType, typeof(BuildForType));
             var stashField = specificTypeCache.GetField("ThunkExceptionDuringBuild", BindingFlags.Static | BindingFlags.Public);
 
             var emit = Emit.NewDynamicMethod(typeof(void), new[] { typeof(TextWriter), typeof(BuildForType), typeof(int) });
@@ -4306,7 +4308,7 @@ static Action<TextWriter, BuildForType, int> BuildAlwaysFailsWith<BuildForType>(
 
         static StringThunkDelegate<BuildForType> BuildAlwaysFailsWithToString<BuildForType>(Type optionsType)
         {
-            var specificTypeCache = typeof(TypeCache<,>).MakeGenericType(optionsType, typeof(BuildForType));
+            var specificTypeCache = typeof(TypeCache<>.InnerTypeCache<>).MakeGenericType(optionsType, typeof(BuildForType));
             var stashField = specificTypeCache.GetField("StringThunkExceptionDuringBuild", BindingFlags.Static | BindingFlags.Public);
 
             var emit = Emit.NewDynamicMethod(typeof(void), new[] { typeof(ThunkWriter).MakeByRefType(), typeof(BuildForType), typeof(int) });
diff --git a/Jil/Serialize/TypeCaches.cs b/Jil/Serialize/TypeCaches.cs
index 538380f7..a7e63d12 100644
--- a/Jil/Serialize/TypeCaches.cs
+++ b/Jil/Serialize/TypeCaches.cs
@@ -1,12 +1,7 @@
 using Sigil;
 using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Reflection.Emit;
-using System.Text;
-using System.Threading.Tasks;
+
 
 namespace Jil.Serialize
 {
@@ -21,61 +16,83 @@ interface ISerializeOptions
         SerializationNameFormat SerializationNameFormat { get; }
     }
 
-    static class TypeCache<TOptions, T>
-        where TOptions : ISerializeOptions, new()
+
+    internal interface ISerializeTypeCache
     {
-        static readonly object ThunkInitLock = new object();
-        static volatile bool ThunkBeingBuilt = false;
-        public static volatile Action<TextWriter, T, int> Thunk;
-        public static Exception ThunkExceptionDuringBuild;
+        Action<TextWriter, T, int> Get<T>();
+        StringThunkDelegate<T> GetToString<T>();
+    }
 
-        static readonly object StringThunkInitLock = new object();
-        static volatile bool StringThunkBeingBuilt = false;
-        public static volatile StringThunkDelegate<T> StringThunk;
-        public static Exception StringThunkExceptionDuringBuild;
+    class TypeCache<TOptions> : ISerializeTypeCache
+                where TOptions : ISerializeOptions, new()
 
-        public static Action<TextWriter, T, int> Get()
+    {
+        public static class InnerTypeCache<T>
         {
-            Load();
-            return Thunk;
-        }
+            static readonly object ThunkInitLock = new object();
+            static volatile bool ThunkBeingBuilt = false;
+            public static volatile Action<TextWriter, T, int> Thunk;
+            public static Exception ThunkExceptionDuringBuild;
 
-        public static void Load()
-        {
-            if (Thunk != null) return;
+            static readonly object StringThunkInitLock = new object();
+            static volatile bool StringThunkBeingBuilt = false;
+            public static volatile StringThunkDelegate<T> StringThunk;
+            public static Exception StringThunkExceptionDuringBuild;
 
-            lock (ThunkInitLock)
+            public static Action<TextWriter, T, int> Get()
             {
-                if (Thunk != null || ThunkBeingBuilt) return;
-                ThunkBeingBuilt = true;
+                Load();
+                return Thunk;
+            }
 
-                var opts = new TOptions();
+            public static void Load()
+            {
+                if (Thunk != null) return;
 
-                Thunk = InlineSerializerHelper.Build<T>(typeof(TOptions), pretty: opts.PrettyPrint, excludeNulls: opts.ExcludeNulls, dateFormat: opts.DateFormat, jsonp: opts.JSONP, includeInherited: opts.IncludeInherited, dateTimeBehavior: opts.DateTimeKindBehavior, serializationNameFormat: opts.SerializationNameFormat, exceptionDuringBuild: out ThunkExceptionDuringBuild);
-            }
-        }
+                lock (ThunkInitLock)
+                {
+                    if (Thunk != null || ThunkBeingBuilt) return;
+                    ThunkBeingBuilt = true;
 
-        public static StringThunkDelegate<T> GetToString()
-        {
-            LoadToString();
-            return StringThunk;
-        }
+                    var opts = new TOptions();
 
-        public static void LoadToString()
-        {
-            if (StringThunk != null) return;
+                    Thunk = InlineSerializerHelper.Build<T>(typeof(TOptions), pretty: opts.PrettyPrint, excludeNulls: opts.ExcludeNulls, dateFormat: opts.DateFormat, jsonp: opts.JSONP, includeInherited: opts.IncludeInherited, dateTimeBehavior: opts.DateTimeKindBehavior, serializationNameFormat: opts.SerializationNameFormat, exceptionDuringBuild: out ThunkExceptionDuringBuild);
+                }
+            }
+
+            public static StringThunkDelegate<T> GetToString()
+            {
+                LoadToString();
+                return StringThunk;
+            }
 
-            lock (StringThunkInitLock)
+            public static void LoadToString()
             {
-                if (StringThunk != null || StringThunkBeingBuilt) return;
-                StringThunkBeingBuilt = true;
+                if (StringThunk != null) return;
+
+                lock (StringThunkInitLock)
+                {
+                    if (StringThunk != null || StringThunkBeingBuilt) return;
+                    StringThunkBeingBuilt = true;
 
-                var opts = new TOptions();
+                    var opts = new TOptions();
 
-                StringThunk = InlineSerializerHelper.BuildToString<T>(typeof(TOptions), pretty: opts.PrettyPrint, excludeNulls: opts.ExcludeNulls, dateFormat: opts.DateFormat, jsonp: opts.JSONP, includeInherited: opts.IncludeInherited, dateTimeBehavior: opts.DateTimeKindBehavior, serializationNameFormat: opts.SerializationNameFormat, exceptionDuringBuild: out StringThunkExceptionDuringBuild);
+                    StringThunk = InlineSerializerHelper.BuildToString<T>(typeof(TOptions), pretty: opts.PrettyPrint, excludeNulls: opts.ExcludeNulls, dateFormat: opts.DateFormat, jsonp: opts.JSONP, includeInherited: opts.IncludeInherited, dateTimeBehavior: opts.DateTimeKindBehavior, serializationNameFormat: opts.SerializationNameFormat, exceptionDuringBuild: out StringThunkExceptionDuringBuild);
+                }
             }
         }
+
+        public Action<TextWriter, T, int> Get<T>()
+        {
+            return InnerTypeCache<T>.Get();
+        }
+
+        public StringThunkDelegate<T> GetToString<T>()
+        {
+            return InnerTypeCache<T>.GetToString();
+        }
     }
+    
 
     // Start OptionsGeneration.linq generated content
     class MicrosoftStyle : ISerializeOptions
diff --git a/JilTests/SpeedProofTests.cs b/JilTests/SpeedProofTests.cs
index ea501d3d..88a99634 100644
--- a/JilTests/SpeedProofTests.cs
+++ b/JilTests/SpeedProofTests.cs
@@ -970,9 +970,8 @@ public void UseNameAutomataWhenMatchingEnums()
                 {
                     InlineDeserializer<_UseNameAutomataWhenMatchingEnums>.UseNameAutomataForEnums = true;
                     Exception ignored;
-
                     // Build the *actual* deserializer method
-                    automata = InlineDeserializerHelper.BuildFromStream<_UseNameAutomataWhenMatchingEnums>(typeof(Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyle, _UseNameAutomataWhenMatchingEnums>), dateFormat: Jil.DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch, serializationNameFormat: SerializationNameFormat.Verbatim, exceptionDuringBuild: out ignored);
+                    automata = InlineDeserializerHelper.BuildFromStream<_UseNameAutomataWhenMatchingEnums>(typeof(Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyle>.InnerTypeCache<_UseNameAutomataWhenMatchingEnums>), dateFormat: Jil.DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch, serializationNameFormat: SerializationNameFormat.Verbatim, exceptionDuringBuild: out ignored);
                 }
 
                 {
@@ -980,7 +979,7 @@ public void UseNameAutomataWhenMatchingEnums()
                     Exception ignored;
 
                     // Build the *actual* deserializer method
-                    method = InlineDeserializerHelper.BuildFromStream<_UseNameAutomataWhenMatchingEnums>(typeof(Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyle, _UseHashWhenMatchingMembers>), dateFormat: Jil.DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch, serializationNameFormat: SerializationNameFormat.Verbatim, exceptionDuringBuild: out ignored);
+                    method = InlineDeserializerHelper.BuildFromStream<_UseNameAutomataWhenMatchingEnums>(typeof(Jil.Deserialize.TypeCache<Jil.Deserialize.MicrosoftStyle>.InnerTypeCache<_UseHashWhenMatchingMembers>), dateFormat: Jil.DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch, serializationNameFormat: SerializationNameFormat.Verbatim, exceptionDuringBuild: out ignored);
                 }
             }
             finally