public static void Register(HttpConfiguration config)
{
// Web API configuration and services
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);
var jsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
var enumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
jsonFormatter.SerializerSettings.Converters.Add(enumConverter);
var settings = jsonFormatter.SerializerSettings;
settings.Formatting = Formatting.Indented;
settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
// Web API routes
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
}
static Extensions()
{
// Force Enums to be converted as strings
_converter = new Newtonsoft.Json.Converters.StringEnumConverter();
_serializer = new JsonSerializer();
_serializer.Converters.Add(_converter);
}
public void Initialize(InitializationEngine context)
{
// Enable Web API routing
GlobalConfiguration.Configure(config =>
{
// Attribute routing
config.MapHttpAttributeRoutes();
var formatters = GlobalConfiguration.Configuration.Formatters;
var jsonFormatter = formatters.JsonFormatter;
var settings = jsonFormatter.SerializerSettings;
var enumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
jsonFormatter.SerializerSettings.Converters.Add(enumConverter);
settings.Formatting = Formatting.Indented;
config.Formatters.Remove(config.Formatters.XmlFormatter);
// config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultEpiApi",
routeTemplate: ApiRoute + "/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
});
}
static JsonSerializerTest()
{
systemTextJsonOptions = new System.Text.Json.JsonSerializerOptions();
systemTextJsonOptions.Converters.Add(new System.Text.Json.Serialization.JsonStringEnumConverter());
newtonsoftConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
obj = GetTestObject();
json = JsonSerializer.Serialize(obj);
jsonnameless = JsonSerializer.SerializeNameless(obj);
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if (value is Enum)
{
var ConvEnumToString = new Newtonsoft.Json.Converters.StringEnumConverter();
ConvEnumToString.WriteJson(writer, value, serializer);
ConvEnumToString = null;
return;
}
//else
serializer.Serialize(writer, value);
} // End Sub WriteJson
public static string Searilize(string format, Type type, object value, Type extendType)
{
string str = "";
if (format == "xml")
{
StringWriter sw = new StringWriter();
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
//ns.Add("", "");
System.IO.Stream stream = new System.IO.MemoryStream();
System.Xml.Serialization.XmlSerializer serializer = null;
if (extendType == null)
{
serializer = new System.Xml.Serialization.XmlSerializer(type);
}
else
{
serializer = new System.Xml.Serialization.XmlSerializer(type, new Type[] { extendType });
}
serializer.Serialize(stream, value, ns);
stream.Seek(0, System.IO.SeekOrigin.Begin);
System.IO.StreamReader reader = new System.IO.StreamReader(stream, Encoding.UTF8);
str = reader.ReadToEnd();
}
else
{
var enumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
var settings = new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
};
settings.Converters.Add(enumConverter);
str = JsonConvert.SerializeObject(value, settings);
}
return(str);
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.EnableCors();
config.MapHttpAttributeRoutes();
// GlobalConfiguration.Configuration.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = System.Web.Http.RouteParameter.Optional }
//);
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.EnableSystemDiagnosticsTracing();
var jsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
var enumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
jsonFormatter.SerializerSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
jsonFormatter.SerializerSettings.Converters.Add(enumConverter);
jsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);
var jsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
var enumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
jsonFormatter.SerializerSettings.Converters.Add(enumConverter);
var settings = jsonFormatter.SerializerSettings;
settings.Formatting = Formatting.Indented;
settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
}
public static BSMATMaterialFile Import(string text)
{
var conv = new Newtonsoft.Json.Converters.StringEnumConverter();
var bsmat = JsonConvert.DeserializeObject <BSMATMaterialFile>(text, conv);
foreach (var stage in bsmat.ShaderStages)
{
List <UniformParam> uniformList = new List <UniformParam>();
foreach (var uniform in stage.UniformData)
{
var uniformParam = new UniformParam();
uniformList.Add(uniformParam);
uniformParam.Name = uniform.Key;
//Basic type define via the start of uniform name.
//All params have starting characters (f float, i int, v vec, etc)
uniformParam.DataType = ParamType.Float;
if (uniform.Key.StartsWith("i"))
{
uniformParam.DataType = ParamType.Int;
}
//Turn the data into normal array objects
if (uniformParam.DataType == ParamType.Float)
{
uniformParam.Data = ((Newtonsoft.Json.Linq.JArray)uniform.Value).ToObject <float[]>();
}
if (uniformParam.DataType == ParamType.Int)
{
uniformParam.Data = ((Newtonsoft.Json.Linq.JArray)uniform.Value).ToObject <int[]>();
}
}
stage.Uniforms = uniformList.ToArray();
}
return(bsmat);
}
public void Initialize(InitializationEngine context)
{
GlobalConfiguration.Configure(config =>
{
var cors = new EnableCorsAttribute("*", "*", "*");
config.EnableCors(cors);
var formatters = GlobalConfiguration.Configuration.Formatters;
var jsonFormatter = formatters.JsonFormatter;
var settings = jsonFormatter.SerializerSettings;
var enumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
jsonFormatter.SerializerSettings.Converters.Add(enumConverter);
settings.Formatting = Formatting.Indented;
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Routes.MapHttpRoute(
name: "DefaultEpiApi",
routeTemplate: "api/epi/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
});
}
public void TryEnumLookup()
{
var enumTypes = new[]
{
typeof(Skippy),
typeof(Sparse),
typeof(Negatives),
typeof(DayOfWeek),
typeof(FakeStatusCodes),
typeof(Empty),
typeof(FunWithFlags0),
typeof(FunWithFlags1),
typeof(FunWithFlags2),
typeof(FunWithFlags3),
typeof(FunWithFlags4),
typeof(FunWithFlags5),
typeof(FunWithFlags6),
}
.Concat(typeof(Util.CorEnums).GetNestedTypes())
.ToList();
var buffer = new byte[256];
var tiny2 = new byte[2];
var tiny4 = new byte[4];
var newtEnumConverter = new Newtonsoft.Json.Converters.StringEnumConverter();
var values = Enumerable.Range(0, 256).Select(i => (ulong)i).ToArray();
foreach (var enumType in enumTypes)
{
var lookup = StringEnum.GetCachedLookup(enumType);
foreach (var value in values)
{
var count = GetStringEnum(lookup, value, buffer, enumType);
Assert.True(count > 0, "Positive count expected");
if (count > tiny2.Length)
{
// just make sure it doesn't throw
GetStringEnum(lookup, value, tiny2, enumType);
}
if (count > tiny4.Length)
{
// just make sure it doesn't throw
GetStringEnum(lookup, value, tiny4, enumType);
}
if (buffer[0] == (byte)'"')
{
// string
Assert.True(count > 2, "Count > 2 expected");
var name = Encoding.UTF8.GetString(buffer, 1, count - 2);
var parsedValue = Enum.Parse(enumType, name, ignoreCase: false);
Assert.Equal(value, ToUInt64(enumType, parsedValue));
}
else
{
var number = Encoding.UTF8.GetString(buffer, 0, count);
bool signed = IsSigned(enumType);
ulong parsedValue = signed ?
(ulong)long.Parse(number, CultureInfo.InvariantCulture) :
ulong.Parse(number, CultureInfo.InvariantCulture);
Assert.Equal(value, parsedValue);
}
}
}
Assert.True(StringEnum.CachedLookups.Length >= enumTypes.Count, "All tested enum types should be cached");
Assert.Equal(2, StringEnum.PagesAllocated);
}
public void GetDecision(MessageEventArgs e, SendMessage send)
{
JsonConverter[] c = new JsonConverter[1];
c[0] = new Newtonsoft.Json.Converters.StringEnumConverter();
string data = e.Data;
IMessage m = Deserialize <IMessage>(data, c);
switch (m.Type)
{
case MessageType.AddBookRequest:
HandleAddBookRequest(send, Deserialize <AddBookRequest>(data, c));
break;
case MessageType.CheckoutRequest:
HandleCheckoutRequest(send, Deserialize <CheckoutRequest>(data, c));
break;
case MessageType.CreateUserRequest:
HandleCreateUserRequest(send, Deserialize <CreateUserRequest>(data, c));
break;
case MessageType.GetBookRequest:
HandleGetBookRequest(send, Deserialize <GetBookRequest>(data, c));
break;
case MessageType.LoginRequest:
HandleLoginRequest(send, Deserialize <LoginRequest>(data, c));
break;
case MessageType.RenewalRequest:
HandleRenewalRequest(send, Deserialize <RenewalRequest>(data, c));
break;
case MessageType.ResetPasswordRequest:
HandleResetPasswordRequest(send, Deserialize <ResetPasswordRequest>(data, c));
break;
case MessageType.RetireBookRequest:
HandleRetireBookRequest(send, Deserialize <RetireBookRequest>(data, c));
break;
case MessageType.ReturnRequest:
HandleReturnRequest(send, Deserialize <ReturnRequest>(data, c));
break;
case MessageType.SearchBookRequest:
DecideSearchBookRequest(send, Deserialize <SearchBookRequest>(data, c));
break;
case MessageType.UpdateBookConditionRequest:
HandleUpdateBookConditionRequest(send, Deserialize <UpdateBookConditionRequest>(data, c));
break;
case MessageType.ViewCheckedoutRequest:
HandleViewCheckedoutRequest(send, Deserialize <ViewCheckedoutRequest>(data, c));
break;
default:
break;
}
}
private static JsonSerializerSettings GetZendeskSerializer()
{
// this method creates a Newtonsoft JSON converter compatible with the .NET to Zendesk naming conventions.
var stringEnumConverter = new Newtonsoft.Json.Converters.StringEnumConverter() { CamelCaseText = true };
var jsonSettings = new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() };
jsonSettings.Converters.Add(stringEnumConverter);
return jsonSettings;
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if (value is Enum)
{
var ConvEnumToString = new Newtonsoft.Json.Converters.StringEnumConverter();
ConvEnumToString.WriteJson(writer, value, serializer);
ConvEnumToString = null;
return;
}
//else
serializer.Serialize(writer, value);
}
public string ToJson()
{
var conv = new Newtonsoft.Json.Converters.StringEnumConverter();
return(JsonConvert.SerializeObject(this, Formatting.Indented, conv));
}
