private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContract collectionValueContract)
{
TypeNameHandling?typeNameHandling = member?.TypeNameHandling;
if (HasFlag((!typeNameHandling.HasValue) ? base.Serializer.TypeNameHandling : typeNameHandling.Value, typeNameHandlingFlag))
{
return(true);
}
if (member != null)
{
TypeNameHandling?typeNameHandling2 = member.TypeNameHandling;
if (((!typeNameHandling2.HasValue) ? base.Serializer.TypeNameHandling : typeNameHandling2.Value) == TypeNameHandling.Auto && contract.UnderlyingType != member.PropertyType)
{
JsonContract jsonContract = base.Serializer.ContractResolver.ResolveContract(member.PropertyType);
if (contract.UnderlyingType != jsonContract.CreatedType)
{
return(true);
}
}
}
else if (collectionValueContract != null && base.Serializer.TypeNameHandling == TypeNameHandling.Auto && contract.UnderlyingType != collectionValueContract.UnderlyingType)
{
return(true);
}
return(false);
}
private static void ConfigureJson(JsonSerializerSettings settings, TypeNameHandling typeNameHandling)
{
settings.SerializationBinder = new TypeNameSerializationBinder(TypeNameRegistry);
settings.ContractResolver = new ConverterContractResolver(
new AppClientsConverter(),
new AppContributorsConverter(),
new AppPatternsConverter(),
new ClaimsPrincipalConverter(),
new EnvelopeHeadersConverter(),
new InstantConverter(),
new JsonValueConverter(),
new LanguageConverter(),
new LanguagesConfigConverter(),
new NamedGuidIdConverter(),
new NamedLongIdConverter(),
new NamedStringIdConverter(),
new RefTokenConverter(),
new RolesConverter(),
new RuleConverter(),
new SchemaConverter(),
new StringEnumConverter());
settings.NullValueHandling = NullValueHandling.Ignore;
settings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
settings.DateParseHandling = DateParseHandling.None;
settings.TypeNameHandling = typeNameHandling;
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling resolvedTypeNameHandling =
((member != null) ? member.TypeNameHandling : null)
?? ((containerProperty != null) ? containerProperty.ItemTypeNameHandling : null)
?? ((containerContract != null) ? containerContract.ItemTypeNameHandling : null)
?? Serializer.TypeNameHandling;
if (HasFlag(resolvedTypeNameHandling, typeNameHandlingFlag))
{
return(true);
}
// instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
{
return(true);
}
}
else if (containerContract != null && containerContract.ItemContract != null)
{
if (contract.UnderlyingType != containerContract.ItemContract.CreatedType)
{
return(true);
}
}
}
return(false);
}
public static string ToJsonString(this object obj, TypeNameHandling handling = TypeNameHandling.All)
{
return(JsonConvert.SerializeObject(obj,
new JsonSerializerSettings {
TypeNameHandling = handling
}));
}
public static T ReadObject <T>(string str, TypeNameHandling nameHandling = TypeNameHandling.Auto)
{
return(JsonConvert.DeserializeObject <T>(str, new JsonSerializerSettings()
{
TypeNameHandling = nameHandling
}));
}
private static void ConfigureJson(JsonSerializerSettings settings, TypeNameHandling typeNameHandling)
{
RuleElementRegistry.RegisterTypes(TypeNameRegistry);
settings.SerializationBinder = new TypeNameSerializationBinder(TypeNameRegistry);
settings.ContractResolver = new ConverterContractResolver(
new AppClientsConverter(),
new AppContributorsConverter(),
new AppPatternsConverter(),
new ClaimsPrincipalConverter(),
new InstantConverter(),
new LanguageConverter(),
new LanguagesConfigConverter(),
new NamedGuidIdConverter(),
new NamedLongIdConverter(),
new NamedStringIdConverter(),
new PropertiesBagConverter <EnvelopeHeaders>(),
new PropertiesBagConverter <PropertiesBag>(),
new RefTokenConverter(),
new RolesConverter(),
new RuleConverter(),
new SchemaConverter(FieldRegistry),
new StringEnumConverter());
settings.NullValueHandling = NullValueHandling.Ignore;
settings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
settings.DateParseHandling = DateParseHandling.None;
settings.TypeNameHandling = typeNameHandling;
settings.ConfigureForNodaTime(DateTimeZoneProviders.Tzdb);
}
public static IJsonSerializer CreateSerializer(TypeNameHandling typeNameHandling = TypeNameHandling.Auto)
{
var typeNameRegistry = new TypeNameRegistry();
var serializerSettings = new JsonSerializerSettings
{
SerializationBinder = new TypeNameSerializationBinder(typeNameRegistry),
ContractResolver = new ConverterContractResolver(
new AppClientsConverter(),
new AppContributorsConverter(),
new AppPatternsConverter(),
new ClaimsPrincipalConverter(),
new EnvelopeHeadersConverter(),
new InstantConverter(),
new JsonValueConverter(),
new LanguageConverter(),
new LanguagesConfigConverter(),
new NamedGuidIdConverter(),
new NamedLongIdConverter(),
new NamedStringIdConverter(),
new RefTokenConverter(),
new RolesConverter(),
new RuleConverter(),
new SchemaConverter(),
new StringEnumConverter()),
TypeNameHandling = typeNameHandling
};
return(new NewtonsoftJsonSerializer(serializerSettings));
}
// Token: 0x060009A8 RID: 2472 RVA: 0x00037FF0 File Offset: 0x000361F0
private bool method_36(TypeNameHandling typeNameHandling_0, JsonContract jsonContract_0, JsonProperty jsonProperty_0, JsonContainerContract jsonContainerContract_0, JsonProperty jsonProperty_1)
{
TypeNameHandling typeNameHandling_ = ((jsonProperty_0 != null) ? jsonProperty_0.TypeNameHandling : null) ?? (((jsonProperty_1 != null) ? jsonProperty_1.ItemTypeNameHandling : null) ?? (((jsonContainerContract_0 != null) ? jsonContainerContract_0.ItemTypeNameHandling : null) ?? this.jsonSerializer_0.typeNameHandling_0));
if (this.method_27(typeNameHandling_, typeNameHandling_0))
{
return(true);
}
if (this.method_27(typeNameHandling_, TypeNameHandling.Auto))
{
if (jsonProperty_0 != null)
{
if (jsonContract_0.type_0 != jsonProperty_0.method_0().CreatedType)
{
return(true);
}
}
else if (jsonContainerContract_0 != null)
{
if (jsonContainerContract_0.EwhtYgWttB() == null || jsonContract_0.type_0 != jsonContainerContract_0.EwhtYgWttB().CreatedType)
{
return(true);
}
}
else if (this.type_0 != null && this.list_0.Count == this.int_0)
{
JsonContract jsonContract = this.jsonSerializer_0.icontractResolver_0.ResolveContract(this.type_0);
if (jsonContract_0.type_0 != jsonContract.CreatedType)
{
return(true);
}
}
}
return(false);
}
private bool ShouldWriteType(
TypeNameHandling typeNameHandlingFlag,
JsonContract contract,
JsonProperty member,
JsonContainerContract containerContract,
JsonProperty containerProperty)
{
TypeNameHandling?typeNameHandling1 = (TypeNameHandling?)member?.TypeNameHandling;
int num;
if (!typeNameHandling1.HasValue)
{
TypeNameHandling?typeNameHandling2 = (TypeNameHandling?)containerProperty?.ItemTypeNameHandling;
if (!typeNameHandling2.HasValue)
{
TypeNameHandling?typeNameHandling3 = (TypeNameHandling?)containerContract?.ItemTypeNameHandling;
num = typeNameHandling3.HasValue ? (int)typeNameHandling3.GetValueOrDefault() : (int)this.Serializer._typeNameHandling;
}
else
{
num = (int)typeNameHandling2.GetValueOrDefault();
}
}
else
{
num = (int)typeNameHandling1.GetValueOrDefault();
}
TypeNameHandling typeNameHandling4 = (TypeNameHandling)num;
if (this.HasFlag(typeNameHandling4, typeNameHandlingFlag))
{
return(true);
}
if (this.HasFlag(typeNameHandling4, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
{
return(true);
}
}
else if (containerContract != null)
{
if (containerContract.ItemContract == null || contract.UnderlyingType != containerContract.ItemContract.CreatedType)
{
return(true);
}
}
else if (this._rootType != null && this._serializeStack.Count == this._rootLevel)
{
JsonContract jsonContract = this.Serializer._contractResolver.ResolveContract(this._rootType);
if (contract.UnderlyingType != jsonContract.CreatedType)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Customises the given serializer settings using provider configuration.
/// Can be used by any provider, allowing the users to use a standard set of configuration attributes.
/// </summary>
/// <param name="settings">The settings to update.</param>
/// <param name="config">The provider config.</param>
/// <returns>The updated <see cref="JsonSerializerSettings" />.</returns>
public static JsonSerializerSettings UpdateSerializerSettings(JsonSerializerSettings settings, IProviderConfiguration config)
{
bool useFullAssemblyNames = config.GetBoolProperty(UseFullAssemblyNamesProperty, false);
bool indentJson = config.GetBoolProperty(IndentJsonProperty, false);
TypeNameHandling typeNameHandling = config.GetEnumProperty(TypeNameHandlingProperty, settings.TypeNameHandling);
return UpdateSerializerSettings(settings, useFullAssemblyNames, indentJson, typeNameHandling);
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling value = ((member != null) ? member.TypeNameHandling : null) ?? (((containerProperty != null) ? containerProperty.ItemTypeNameHandling : null) ?? (((containerContract != null) ? containerContract.ItemTypeNameHandling : null) ?? this.Serializer._typeNameHandling));
if (this.HasFlag(value, typeNameHandlingFlag))
{
return(true);
}
if (this.HasFlag(value, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
{
return(true);
}
}
else if (containerContract != null)
{
if (containerContract.ItemContract == null || contract.UnderlyingType != containerContract.ItemContract.CreatedType)
{
return(true);
}
}
else if (this._rootContract != null && this._serializeStack.Count == this._rootLevel && contract.UnderlyingType != this._rootContract.CreatedType)
{
return(true);
}
}
return(false);
}
private static JsonSerializerSettings ConfigureJson(TypeNameHandling typeNameHandling, JsonSerializerSettings?settings = null)
{
settings ??= new JsonSerializerSettings();
settings.Converters.Add(new StringEnumConverter());
settings.ContractResolver = new ConverterContractResolver(
new ContentFieldDataConverter(),
new EnvelopeHeadersConverter(),
new ExecutionResultJsonConverter(new ErrorInfoProvider()),
new JsonValueConverter(),
new StringEnumConverter(),
new SurrogateConverter <ClaimsPrincipal, ClaimsPrinicpalSurrogate>(),
new SurrogateConverter <FilterNode <IJsonValue>, JsonFilterSurrogate>(),
new SurrogateConverter <LanguageConfig, LanguageConfigSurrogate>(),
new SurrogateConverter <LanguagesConfig, LanguagesConfigSurrogate>(),
new SurrogateConverter <Roles, RolesSurrogate>(),
new SurrogateConverter <Rule, RuleSorrgate>(),
new SurrogateConverter <Schema, SchemaSurrogate>(),
new SurrogateConverter <WorkflowStep, WorkflowStepSurrogate>(),
new SurrogateConverter <WorkflowTransition, WorkflowTransitionSurrogate>(),
new WriteonlyGeoJsonConverter());
settings.NullValueHandling = NullValueHandling.Ignore;
settings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
settings.DateParseHandling = DateParseHandling.None;
settings.TypeNameHandling = typeNameHandling;
return(settings);
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContract collectionValueContract)
{
if (HasFlag(((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling, typeNameHandlingFlag))
{
return(true);
}
if (member != null)
{
if ((member.TypeNameHandling ?? Serializer.TypeNameHandling) == TypeNameHandling.Auto
// instance and property type are different
&& contract.UnderlyingType != member.PropertyType)
{
JsonContract memberTypeContract = Serializer.ContractResolver.ResolveContract(member.PropertyType);
// instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
if (contract.UnderlyingType != memberTypeContract.CreatedType)
{
return(true);
}
}
}
else if (collectionValueContract != null)
{
if (Serializer.TypeNameHandling == TypeNameHandling.Auto && contract.UnderlyingType != collectionValueContract.UnderlyingType)
{
return(true);
}
}
return(false);
}
public object ReadObject(string str, Type objType, TypeNameHandling nameHandling = TypeNameHandling.Auto)
{
return(JsonConvert.DeserializeObject(str, objType, new JsonSerializerSettings()
{
TypeNameHandling = nameHandling
}));
}
public WebApiInstaller TypeNameHandling(TypeNameHandling handling = Newtonsoft.Json.TypeNameHandling.Auto)
{
var jsonFormatter = _configuration.Formatters.JsonFormatter;
jsonFormatter.SerializerSettings.TypeNameHandling = handling;
jsonFormatter.SerializerSettings.TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple;
return(this);
}
public TJsonArray(TypeNameHandling typeNameHandling = TypeNameHandling.None)
{
if (typeNameHandling != TypeNameHandling.None)
{
serializerSettings = new JsonSerializerSettings();
serializerSettings.TypeNameHandling = typeNameHandling;// TypeNameHandling.All;
}
}
public static T To <T>(this string json, TypeNameHandling typeNameHandling = TypeNameHandling.All)
{
var settings = new JsonSerializerSettings();
settings.TypeNameHandling = typeNameHandling;
return(JsonConvert.DeserializeObject <T>(json, settings));
}
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 static T FromBSON<T>(this string filename, bool root_is_array = false)
* {
* using (var fo = File.OpenRead(filename))
* using (var br = new BsonDataReader(fo, root_is_array, DateTimeKind.Local))
* {
* var serializer = JsonSerializer.Create(new JsonSerializerSettings
* {TypeNameHandling = TypeNameHandling.Auto});
* return serializer.Deserialize<T>(br);
* }
* }*/
public static T FromJSONString <T>(this string data,
TypeNameHandling handling = TypeNameHandling.All,
TypeNameAssemblyFormatHandling format = TypeNameAssemblyFormatHandling.Full)
{
return(JsonConvert.DeserializeObject <T>(data,
new JsonSerializerSettings {
TypeNameHandling = handling, TypeNameAssemblyFormatHandling = format
}));
}
public static string ToJson <T>(this T obj, TypeNameHandling typeNameHandling = TypeNameHandling.None)
{
var settings = new JsonSerializerSettings();
settings.TypeNameHandling = typeNameHandling;
settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
return(JsonConvert.SerializeObject(obj, settings));
}
public static T FromJSON <T>(this string filename,
TypeNameHandling handling = TypeNameHandling.All,
TypeNameAssemblyFormatHandling format = TypeNameAssemblyFormatHandling.Full)
{
return(JsonConvert.DeserializeObject <T>(File.ReadAllText(filename),
new JsonSerializerSettings {
TypeNameHandling = handling, TypeNameAssemblyFormatHandling = format
}));
}
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));
}
public static string ToJSON <T>(this T obj,
TypeNameHandling handling = TypeNameHandling.All,
TypeNameAssemblyFormatHandling format = TypeNameAssemblyFormatHandling.Full)
{
return(JsonConvert.SerializeObject(obj, Formatting.Indented,
new JsonSerializerSettings {
TypeNameHandling = handling, TypeNameAssemblyFormatHandling = format
}));
}
private string ConvertJson <T>(T value, TypeNameHandling typeNameHandling)
{
string result = value is string?value.ToString() : JsonConvert.SerializeObject(value, new JsonSerializerSettings()
{
TypeNameHandling = typeNameHandling
});
return(result);
}
public static string Serialize <T>(object value, TypeNameHandling typeNameHandling)
{
var jsonSettings = new JsonSerializerSettings {
TypeNameHandling = (Newtonsoft.Json.TypeNameHandling)typeNameHandling
};
var serialized = JsonConvert.SerializeObject(value, typeof(T), jsonSettings);
return(serialized);
}
public JsonSerializer(TypeNameHandling typeNameHandling, ReferenceLoopHandling referenceLoopHandling)
{
JsonConvert.DefaultSettings = JsonConvert.DefaultSettings ?? new Func <JsonSerializerSettings>(() =>
new JsonSerializerSettings()
{
TypeNameHandling = typeNameHandling,
ReferenceLoopHandling = referenceLoopHandling
});
}
public JsonSerializer(TypeNameHandling typeNameHandling, ReferenceLoopHandling referenceLoopHandling, bool ignoreNulls = true)
{
JsonConvert.DefaultSettings = JsonConvert.DefaultSettings ?? new Func <JsonSerializerSettings>(() =>
new JsonSerializerSettings()
{
TypeNameHandling = typeNameHandling,
ReferenceLoopHandling = referenceLoopHandling,
NullValueHandling = ignoreNulls ? NullValueHandling.Ignore : NullValueHandling.Include
});
}
public BeetleApiConfig(NullValueHandling nullValueHandling,
TypeNameHandling typeNameHandling = TypeNameHandling.Objects,
Formatting formatting = Formatting.Indented,
ReferenceLoopHandling referenceLoopHandling = ReferenceLoopHandling.Ignore,
PreserveReferencesHandling preserveReferencesHandling = PreserveReferencesHandling.Objects,
DateTimeZoneHandling dateTimeZoneHandling = DateTimeZoneHandling.Local)
: base(nullValueHandling, typeNameHandling, formatting, referenceLoopHandling,
preserveReferencesHandling, dateTimeZoneHandling)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
/// <param name="typeNameHandling">The type name handling.</param>
/// <param name="referenceLoopHandling">The reference loop handling.</param>
/// <param name="ignoreNulls">if set to <c>true</c> [ignore nulls].</param>
/// <param name="contractResolver">The contract resolver.</param>
public JsonSerializer(TypeNameHandling typeNameHandling, ReferenceLoopHandling referenceLoopHandling, bool ignoreNulls = true, IContractResolver contractResolver = null)
{
this.Settings = new JsonSerializerSettings()
{
TypeNameHandling = typeNameHandling,
ReferenceLoopHandling = referenceLoopHandling,
NullValueHandling = ignoreNulls ? NullValueHandling.Ignore : NullValueHandling.Include,
ContractResolver = contractResolver
};
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
_preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
_typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
_binder = DefaultSerializationBinder.Instance;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonSerializer"/> class.
/// </summary>
public JsonSerializer()
{
_referenceLoopHandling = JsonSerializerSettings.DefaultReferenceLoopHandling;
_missingMemberHandling = JsonSerializerSettings.DefaultMissingMemberHandling;
_nullValueHandling = JsonSerializerSettings.DefaultNullValueHandling;
_defaultValueHandling = JsonSerializerSettings.DefaultDefaultValueHandling;
_objectCreationHandling = JsonSerializerSettings.DefaultObjectCreationHandling;
_preserveReferencesHandling = JsonSerializerSettings.DefaultPreserveReferencesHandling;
_typeNameHandling = JsonSerializerSettings.DefaultTypeNameHandling;
_binder = DefaultSerializationBinder.Instance;
}
private T ConvertObj <T>(string value, TypeNameHandling typeNameHandling)
{
if (string.IsNullOrEmpty(value))
{
return(default(T));
}
return(JsonConvert.DeserializeObject <T>(value, new JsonSerializerSettings()
{
TypeNameHandling = typeNameHandling
}));
}
private List <T> ConvetList <T>(RedisValue[] values, TypeNameHandling typeNameHandling)
{
List <T> result = new List <T>();
foreach (var item in values)
{
var model = ConvertObj <T>(item, typeNameHandling);
result.Add(model);
}
return(result);
}
/// <summary>
/// Creates the settings instance.
/// </summary>
/// <param name="nullValueHandling">The null value handling.</param>
/// <param name="typeNameHandling">The type name handling.</param>
/// <returns></returns>
private static JsonSerializerSettings CreateSettings(NullValueHandling nullValueHandling, TypeNameHandling typeNameHandling) {
var jsonSerializerSettings = new JsonSerializerSettings {
NullValueHandling = nullValueHandling,
PreserveReferencesHandling = PreserveReferencesHandling.Objects,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = typeNameHandling,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple
};
jsonSerializerSettings.Converters.Add(new BeetleDateTimeConverter { DateTimeFormat = "yyyy-MM-dd\\THH:mm:ss.fffK" });
jsonSerializerSettings.Converters.Add(new TimeSpanConverter());
jsonSerializerSettings.Converters.Add(new StringEnumConverter());
jsonSerializerSettings.Converters.Add(new ByteArrayConverter());
jsonSerializerSettings.Converters.Add(new DbGeometryConverter());
jsonSerializerSettings.Converters.Add(new DbGeographyConverter());
return jsonSerializerSettings;
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling resolvedTypeNameHandling =
((member != null) ? member.TypeNameHandling : null)
?? ((containerProperty != null) ? containerProperty.ItemTypeNameHandling : null)
?? ((containerContract != null) ? containerContract.ItemTypeNameHandling : null)
?? Serializer.TypeNameHandling;
if (HasFlag(resolvedTypeNameHandling, typeNameHandlingFlag))
return true;
// instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
return true;
}
else if (containerContract != null && containerContract.ItemContract != null)
{
if (contract.UnderlyingType != containerContract.ItemContract.CreatedType)
return true;
}
}
return false;
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContract collectionValueContract)
{
if (HasFlag(((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling, typeNameHandlingFlag))
return true;
if (member != null)
{
if ((member.TypeNameHandling ?? Serializer.TypeNameHandling) == TypeNameHandling.Auto
// instance and property type are different
&& contract.UnderlyingType != member.PropertyType)
{
JsonContract memberTypeContract = Serializer.ContractResolver.ResolveContract(member.PropertyType);
// instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
if (contract.UnderlyingType != memberTypeContract.CreatedType)
return true;
}
}
else if (collectionValueContract != null)
{
if (Serializer.TypeNameHandling == TypeNameHandling.Auto && contract.UnderlyingType != collectionValueContract.UnderlyingType)
return true;
}
return false;
}
// Token: 0x06000C09 RID: 3081
// RVA: 0x000478E4 File Offset: 0x00045AE4
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling value = ((member != null) ? member.TypeNameHandling : null) ?? (((containerProperty != null) ? containerProperty.ItemTypeNameHandling : null) ?? (((containerContract != null) ? containerContract.ItemTypeNameHandling : null) ?? this.Serializer._typeNameHandling));
if (this.HasFlag(value, typeNameHandlingFlag))
{
return true;
}
if (this.HasFlag(value, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
{
return true;
}
}
else if (containerContract != null)
{
if (containerContract.ItemContract == null || contract.UnderlyingType != containerContract.ItemContract.CreatedType)
{
return true;
}
}
else if (this._rootContract != null && this._serializeStack.Count == this._rootLevel && contract.UnderlyingType != this._rootContract.CreatedType)
{
return true;
}
}
return false;
}
//private bool ShouldWriteTypeProperty(JsonProperty member, JsonContract contract, TypeNameHandling typeFlag)
//{
// if (HasFlag(((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling, typeFlag))
// return true;
// if ((((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling) == TypeNameHandling.Auto)
// || (member != null
// && (member.TypeNameHandling ?? Serializer.TypeNameHandling) == TypeNameHandling.Auto
// && contract.UnderlyingType != member.PropertyType)
// )
//}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContract collectionValueContract)
{
if (HasFlag(((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling, typeNameHandlingFlag))
return true;
if (member != null)
{
if ((member.TypeNameHandling ?? Serializer.TypeNameHandling) == TypeNameHandling.Auto && contract.UnderlyingType != member.PropertyType)
return true;
}
else if (collectionValueContract != null)
{
if (Serializer.TypeNameHandling == TypeNameHandling.Auto && contract.UnderlyingType != collectionValueContract.UnderlyingType)
return true;
}
return false;
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling? nullable1 = member != null ? member.TypeNameHandling : new TypeNameHandling?();
int num;
if (!nullable1.HasValue)
{
TypeNameHandling? nullable2 = containerProperty != null ? containerProperty.ItemTypeNameHandling : new TypeNameHandling?();
if (!nullable2.HasValue)
{
TypeNameHandling? nullable3 = containerContract != null ? containerContract.ItemTypeNameHandling : new TypeNameHandling?();
num = nullable3.HasValue ? (int) nullable3.GetValueOrDefault() : (int) this.Serializer.TypeNameHandling;
}
else
num = (int) nullable2.GetValueOrDefault();
}
else
num = (int) nullable1.GetValueOrDefault();
TypeNameHandling typeNameHandling = (TypeNameHandling) num;
if (this.HasFlag(typeNameHandling, typeNameHandlingFlag))
return true;
if (this.HasFlag(typeNameHandling, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
return true;
}
else if (containerContract != null && containerContract.ItemContract != null && contract.UnderlyingType != containerContract.ItemContract.CreatedType)
return true;
}
return false;
}
public object OpenFromFile(Type objType, string file, TypeNameHandling nameHandling = TypeNameHandling.Auto)
{
return ReadObject(File.ReadAllText(file), objType);
}
public object ReadObject(string str, Type objType, TypeNameHandling nameHandling = TypeNameHandling.Auto)
{
return JsonConvert.DeserializeObject(str, objType, new JsonSerializerSettings() { TypeNameHandling = nameHandling });
}
public byte[] WriteObject(object obj, Formatting formatting = Formatting.None, TypeNameHandling nameHandling = TypeNameHandling.Auto)
{
return Util.Str.GetBytes(WriteObjectAsString(obj, formatting, nameHandling));
}
/// <summary>
/// Initializes a new instance of the <see cref="BeetleConfig" /> class.
/// </summary>
/// <param name="nullValueHandling">The null value handling.</param>
/// <param name="typeNameHandling">The type name handling.</param>
public BeetleConfig(NullValueHandling nullValueHandling, TypeNameHandling typeNameHandling)
: this(CreateSettings(nullValueHandling, typeNameHandling)) {
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling resolvedTypeNameHandling =
((member != null) ? member.TypeNameHandling : null)
?? ((containerProperty != null) ? containerProperty.ItemTypeNameHandling : null)
?? ((containerContract != null) ? containerContract.ItemTypeNameHandling : null)
?? Serializer._typeNameHandling;
if (HasFlag(resolvedTypeNameHandling, typeNameHandlingFlag))
{
return true;
}
// instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.NonNullableUnderlyingType != member.PropertyContract.CreatedType)
{
return true;
}
}
else if (containerContract != null)
{
if (containerContract.ItemContract == null || contract.NonNullableUnderlyingType != containerContract.ItemContract.CreatedType)
{
return true;
}
}
else if (_rootType != null && _serializeStack.Count == _rootLevel)
{
JsonContract rootContract = Serializer._contractResolver.ResolveContract(_rootType);
if (contract.NonNullableUnderlyingType != rootContract.CreatedType)
{
return true;
}
}
}
return false;
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling resolvedTypeNameHandling =
((member != null) ? member.TypeNameHandling : null)
?? ((containerProperty != null) ? containerProperty.ItemTypeNameHandling : null)
?? ((containerContract != null) ? containerContract.ItemTypeNameHandling : null)
?? Serializer.TypeNameHandling;
if (HasFlag(resolvedTypeNameHandling, typeNameHandlingFlag))
return true;
// instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
return true;
}
else if (containerContract != null && containerContract.ItemContract != null)
{
if (contract.UnderlyingType != containerContract.ItemContract.CreatedType)
return true;
}
}
#if !(NET35 || NET20 || WINDOWS_PHONE)
if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Auto))
{
if (contract.CreatedType == typeof(ExpandoObject))
{
//Add $type for ExpandoObject when called as root by default
return true;
}
if (member == null && containerContract != null && containerContract.UnderlyingType == typeof(object))
{
//We handling a dynamic ExpandoObject
if (containerProperty != null && contract.UnderlyingType != containerProperty.PropertyType)
{
//An IEnumerable of String (property name), Object (value) is a ExpandoObject
return true;
}
}
}
if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Objects))
{
if (member != null && member.TypeNameHandling != TypeNameHandling.None && contract.CreatedType == typeof(ExpandoObject))
{
//Add $type for ExpandoObject when called as a property by default
return true;
}
}
#endif
return false;
}
private bool HasFlag(TypeNameHandling value, TypeNameHandling flag)
{
return ((value & flag) == flag);
}
