public string ToJson(Formatting format = Formatting.None)
 {
     JsonSerializerSettings setting = new JsonSerializerSettings();
     setting.NullValueHandling = NullValueHandling.Ignore;
     string json = JsonConvert.SerializeObject(this, format, setting);
     return json;
 }

        private static string GetTagName(Formatting formatting)
        {
            switch (formatting)
            {
                case Formatting.Bold:
                    return "b";

                case Formatting.Italic:
                    return "i";

                case Formatting.Underline:
                    return "u";

                case Formatting.Strikethrough:
                    return "del";

                case Formatting.Subscript:
                    return "sub";
                
                case Formatting.Superscript:
                    return "sup";
                
                default:
                    throw new ArgumentOutOfRangeException("formatting");
            }
        }

        public void ForTypesWithoutInterfacesCustomSerializerSerializesTheSameAsDefaultSerializer(
            object instance,
            string defaultNamespace,
            Type[] extraTypes,
            string rootElementName,
            Encoding encoding,
            Formatting formatting,
            XmlSerializerNamespaces namespaces)
        {
            var defaultSerializer =
                (IXmlSerializer)Activator.CreateInstance(
                    typeof(DefaultSerializer<>).MakeGenericType(instance.GetType()),
                    defaultNamespace,
                    extraTypes,
                    rootElementName);
            var customSerializer =
                (IXmlSerializer)Activator.CreateInstance(
                    typeof(CustomSerializer<>).MakeGenericType(instance.GetType()),
                    defaultNamespace,
                    extraTypes,
                    rootElementName);

            var defaultXml = defaultSerializer.SerializeObject(instance, namespaces, encoding, formatting);
            var customXml = customSerializer.SerializeObject(instance, namespaces, encoding, formatting);

            Console.WriteLine("Default XML:");
            Console.WriteLine(defaultXml);
            Console.WriteLine();
            Console.WriteLine("Custom XML:");
            Console.WriteLine(customXml);

            Assert.That(customXml, Is.EqualTo(defaultXml));
        }

 public DocumentWriter(Formatting formatting)
     : this(formatting,
         new JsonSerializerSettings
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver()
         })
 {
 }

 public JsonNetResult(object data, 
     Formatting formatting = Formatting.None, 
     JsonSerializerSettings settings = null)
 {
     Data = data; 
     SerializerSettings = settings ?? new JsonSerializerSettings();
     Formatting = formatting;                         
 }

 /// <summary>
 ///     To provide custom serialization using the <see cref="Newtonsoft.Json.JsonSerializer" />.
 /// </summary>
 /// <param name="configuration">The bus configuration to apply the serializer to.</param>
 /// <param name="settings">To configure serialization settings.</param>
 /// <param name="formatting">To configure serialization formatting.</param>
 /// <param name="fallbackSerializer">To add a fallback serializer (if i.e you want to support both XML and Json)</param>
 /// <returns>Bus configuration.</returns>
 public static BusBuilderConfiguration.Config WithJsonSerializer(
     this BusBuilderConfiguration.Config configuration,
     JsonSerializerSettings settings,
     Formatting formatting = Formatting.None,
     ISerializer fallbackSerializer = null)
 {
     return configuration.WithSerializer(new JsonSerializer(settings, formatting, fallbackSerializer));
 }

 public string WriteObjectAsString(object obj, Formatting formatting = Formatting.None, TypeNameHandling nameHandling = TypeNameHandling.Auto)
 {
     return JsonConvert.SerializeObject(obj, formatting,
             new JsonSerializerSettings
             {
                 NullValueHandling = NullValueHandling.Ignore,
                 TypeNameHandling = nameHandling
             });
 }

 public void SaveToFile(object obj, string file, Formatting formatting = Formatting.Indented, TypeNameHandling nameHandling = TypeNameHandling.Auto)
 {
     var path = Util.Str.getFolder(file);
     if (!Directory.Exists(path))
     {
         Directory.CreateDirectory(path);
     }
     File.WriteAllText(file, WriteObjectAsString(obj, formatting, nameHandling));
 }

		internal override string InternalToString(Formatting format, int depth)
		{
			if (Value != null && Value.Length > 0)
				return string.Concat("\"base64:",
					Convert.ToBase64String(this.Value),
				"\"");
			else
				return "\"base64:\"";
		}

 public JsonNetResult(object data)
 {
     this.data = data;
     formatting = Formatting.None;
     serializerSettings = new JsonSerializerSettings
     {
         ContractResolver = new CamelCasePropertyNamesContractResolver()
     };
 }

 public static string Serialize(LanguageDefinition definition, Formatting formatting, bool serializeAsArrays = false)
 {
     //var json = JsonConvert.SerializeObject(definition, formatting, new InlineDefinitionJsonConverter(), new StringDefinitionJsonConverter(serializeAsArrays));
     var settings = new JsonSerializerSettings();// {TypeNameHandling = TypeNameHandling.All};
     settings.Converters.Add(new InlineDefinitionJsonConverter(serializeAsArrays));
     settings.Converters.Add(new StringDefinitionJsonConverter(serializeAsArrays));
     var json = JsonConvert.SerializeObject(definition, formatting, settings);
     return json;
 }

 public static string SinglePage(Formatting.FormattedHtml htmlContent)
 {
     var m = new Models.SingleFileModel()
     {
         Stylesheets = new[] { htmlContent.Stylesheet },
         PreformattedHtml = htmlContent.Html,
         Javascript = new[] { htmlContent.Javascript }
     };
     return RenderSingleFile(m);
 }

        public JsonNetResult()
        {
            SerializerSettings = new JsonSerializerSettings();

            //SerializerSettings.Converters.Add(new JavaScriptDateTimeConverter());
            SerializerSettings.Converters.Add(new IsoDateTimeConverter());
            SerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
            SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
            Formatting = Formatting.None;
        }

        public static string ObjectToJson(this IHtmlHelper helper, object input, Formatting jsonFormatting, params JsonConverter[] converters)
        {
            JsonSerializerSettings settings = new JsonSerializerSettings();
            if (converters != null) {
                foreach (JsonConverter converter in converters) {
                    settings.Converters.Add(converter);
                }
            }

            return JsonConvert.SerializeObject(input, jsonFormatting, settings);
        }

 public DocumentWriter(Formatting formatting)
     : this(
         formatting,
         new JsonSerializerSettings
         {
             ContractResolver = new CamelCasePropertyNamesContractResolver(),
             DateFormatHandling = DateFormatHandling.IsoDateFormat,
             DateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFF'Z'",
         })
 {
 }

        public JsonNetResult()
        {
            SerializerSettings = new JsonSerializerSettings();

            //SerializerSettings.Converters.Add(new JavaScriptDateTimeConverter());
            SerializerSettings.Converters.Add(new IsoDateTimeConverter());
            Formatting = Formatting.Indented;
            SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
           
               
        }

 public PlayerSaveData()
 {
     PlayerName = typeof( PlayerSaveData ).Name;
     PlayerColor = Color.green;
     EnemyColor = Color.red;
     Modules = new List<BaseUnitModule>();
     UnitDefinitions = new List<UnitDefinition>();
     Money = 1000;
     m_serializerSettings = new JsonSerializerSettings();
     m_serializerFormatting = Formatting.None;
     m_onSaveDataChanged = null;
 }

 public CustomJsonResult()
 {
     JsonRequestBehavior = JsonRequestBehavior.AllowGet;
     JsonSerializer = new JsonSerializerSettings
     {
         Converters = new List<JsonConverter>
         {
             new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd HH:mm" }
         }
     };
     Formatting = Formatting.None;
 }

 public LayoutOptions()
 {
     this.ContainerHeaderHeight = 0.25;
     this.Padding = 0.125;
     this.ItemVerticalSpacing = 0.125;
     this.ItemHeight = 0.25;
     this.ContainerHorizontalDistance = 1.0;
     this.ItemWidth = 2.0;
     this.ContainerFormatting = new Formatting();
     this.ContainerItemFormatting = new Formatting();
     this.ContainerFormatting.TextBlockCells.VerticalAlign = "0";
 }

        /// <summary>
        /// Serializes the object in simple mode.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="formatting">The formatting.</param>
        /// <param name="jsonSettings">The json settings.</param>
        /// <returns></returns>
        public static string SerializeObjectInSimpleMode( object value, Formatting formatting, JsonSerializerSettings jsonSettings )
        {
            JsonSerializer jsonSerializer = JsonSerializer.CreateDefault( jsonSettings );
            jsonSerializer.Formatting = formatting;

            var stringWriter = new StringWriter( new StringBuilder( 256 ), CultureInfo.InvariantCulture );
            using ( var jsonTextWriter = new Rock.Utility.RockJsonTextWriter( stringWriter, true ) )
            {
                jsonTextWriter.Formatting = jsonSerializer.Formatting;
                jsonSerializer.Serialize( jsonTextWriter, value, null );
            }
            return stringWriter.ToString();
        }