private string GetTypeId(Type type, bool explicitOnly)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(type);
if (containerAttribute != null && !string.IsNullOrEmpty(containerAttribute.Id))
{
return(containerAttribute.Id);
}
if (explicitOnly)
{
return(null);
}
switch (UndefinedSchemaIdHandling)
{
case UndefinedSchemaIdHandling.UseTypeName:
return(type.FullName);
case UndefinedSchemaIdHandling.UseAssemblyQualifiedName:
return(type.AssemblyQualifiedName);
default:
return(null);
}
}
private string GetTypeId(Type type, bool explicitOnly)
{
string id;
JsonContainerAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (cachedAttribute != null)
{
id = cachedAttribute.Id;
}
else
{
id = null;
}
if (!string.IsNullOrEmpty(id))
{
return(cachedAttribute.Id);
}
if (explicitOnly)
{
return(null);
}
Newtonsoft.Json.Schema.UndefinedSchemaIdHandling undefinedSchemaIdHandling = this.UndefinedSchemaIdHandling;
if (undefinedSchemaIdHandling == Newtonsoft.Json.Schema.UndefinedSchemaIdHandling.UseTypeName)
{
return(type.FullName);
}
if (undefinedSchemaIdHandling != Newtonsoft.Json.Schema.UndefinedSchemaIdHandling.UseAssemblyQualifiedName)
{
return(null);
}
return(type.AssemblyQualifiedName);
}
private void InitializeContract(JsonContract contract)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.UnderlyingType);
if (containerAttribute != null)
{
contract.IsReference = containerAttribute._isReference;
}
#if !PocketPC && !SILVERLIGHT
foreach (MethodInfo method in contract.UnderlyingType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
Type prevAttributeType = null;
ParameterInfo[] parameters = method.GetParameters();
if (IsValidCallback(method, parameters, typeof(OnSerializingAttribute), contract.OnSerializing, ref prevAttributeType))
{
contract.OnSerializing = method;
}
if (IsValidCallback(method, parameters, typeof(OnSerializedAttribute), contract.OnSerialized, ref prevAttributeType))
{
contract.OnSerialized = method;
}
if (IsValidCallback(method, parameters, typeof(OnDeserializingAttribute), contract.OnDeserializing, ref prevAttributeType))
{
contract.OnDeserializing = method;
}
if (IsValidCallback(method, parameters, typeof(OnDeserializedAttribute), contract.OnDeserialized, ref prevAttributeType))
{
contract.OnDeserialized = method;
}
}
#endif
}
private string GetDescription(Type type)
{
string description;
JsonContainerAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (cachedAttribute != null)
{
description = cachedAttribute.Description;
}
else
{
description = null;
}
if (!string.IsNullOrEmpty(description))
{
return(cachedAttribute.Description);
}
DescriptionAttribute attribute = ReflectionUtils.GetAttribute <DescriptionAttribute>(type);
if (attribute != null)
{
return(attribute.Description);
}
return(null);
}
private void method_7(JsonContract jsonContract_0)
{
JsonContainerAttribute attribute = Class139.smethod_0(jsonContract_0.type_0);
if (attribute != null)
{
jsonContract_0.IsReference = attribute.nullable_0;
}
else
{
DataContractAttribute attribute2 = Class139.smethod_5(jsonContract_0.type_0);
if ((attribute2 != null) && attribute2.IsReference)
{
jsonContract_0.IsReference = true;
}
}
jsonContract_0.Converter = this.ResolveContractConverter(jsonContract_0.type_0);
jsonContract_0.JsonConverter_0 = JsonSerializer.smethod_1(ilist_0, jsonContract_0.type_0);
if (Class194.smethod_6(jsonContract_0.CreatedType, true) || jsonContract_0.CreatedType.smethod_12())
{
jsonContract_0.DefaultCreator = this.method_6(jsonContract_0.CreatedType);
jsonContract_0.DefaultCreatorNonPublic = !jsonContract_0.CreatedType.smethod_12() && (Class194.smethod_7(jsonContract_0.CreatedType) == null);
}
this.method_8(jsonContract_0, jsonContract_0.type_0);
}
private void InitializeContract(JsonContract contract)
{
JsonContainerAttribute jsonContainerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.UnderlyingType);
if (jsonContainerAttribute != null)
{
contract.IsReference = jsonContainerAttribute._isReference;
}
else
{
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(contract.UnderlyingType);
if (dataContractAttribute != null && dataContractAttribute.IsReference)
{
contract.IsReference = new bool?(true);
}
}
contract.Converter = this.ResolveContractConverter(contract.UnderlyingType);
contract.InternalConverter = JsonSerializer.GetMatchingConverter(DefaultContractResolver.BuiltInConverters, contract.UnderlyingType);
if (ReflectionUtils.HasDefaultConstructor(contract.CreatedType, true) || contract.CreatedType.IsValueType)
{
contract.DefaultCreator = this.GetDefaultCreator(contract.CreatedType);
contract.DefaultCreatorNonPublic = (!contract.CreatedType.IsValueType && ReflectionUtils.GetDefaultConstructor(contract.CreatedType) == null);
}
this.ResolveCallbackMethods(contract, contract.UnderlyingType);
}
private void InitializeContract(JsonContract contract)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.UnderlyingType);
if (containerAttribute != null)
{
contract.IsReference = containerAttribute._isReference;
}
else
{
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(contract.UnderlyingType);
// doesn't have a null value
if (dataContractAttribute != null && dataContractAttribute.IsReference)
{
contract.IsReference = true;
}
}
contract.Converter = ResolveContractConverter(contract.UnderlyingType);
// then see whether object is compadible with any of the built in converters
contract.InternalConverter = JsonSerializer.GetMatchingConverter(BuiltInConverters, contract.UnderlyingType);
if (ReflectionUtils.HasDefaultConstructor(contract.CreatedType, true) ||
contract.CreatedType.IsValueType)
{
contract.DefaultCreator = GetDefaultCreator(contract.CreatedType);
contract.DefaultCreatorNonPublic = (!contract.CreatedType.IsValueType &&
ReflectionUtils.GetDefaultConstructor(contract.CreatedType) == null);
}
ResolveCallbackMethods(contract, contract.UnderlyingType);
}
public JsonContainerAttributeInternals Internal(JsonContainerAttribute attribute)
{
switch (attribute.Kind)
{
case JsonContainerKind.Array:
{
return(XJsonReflection.Api.ArrayAttributes.Internal((JsonArrayAttribute)attribute));
}
case JsonContainerKind.Dictionary:
{
return(XJsonReflection.Api.DictionaryAttributes.Internal((JsonDictionaryAttribute)attribute));
break;
}
case JsonContainerKind.Object:
{
return(XJsonReflection.Api.ObjectAttributes.Internal((JsonObjectAttribute)attribute));
break;
}
default:
{
throw XExceptions.NotSupported.EnumerationValueIsNotValid();
}
}
}
private string GetTitle(Type type)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(type);
if (containerAttribute != null && !string.IsNullOrEmpty(containerAttribute.Title))
return containerAttribute.Title;
return null;
}
private string GetTitle(Type type)
{
JsonContainerAttribute jsonContainerAttribute = JsonTypeReflector.GetJsonContainerAttribute(type);
if (jsonContainerAttribute != null && !string.IsNullOrEmpty(jsonContainerAttribute.Title))
{
return(jsonContainerAttribute.Title);
}
return(null);
}
private string GetDescription(Type type)
{
JsonContainerAttribute jsonContainerAttribute = JsonTypeReflector.GetJsonContainerAttribute(type);
if (jsonContainerAttribute != null && !string.IsNullOrEmpty(jsonContainerAttribute.Description))
{
return(jsonContainerAttribute.Description);
}
return(ReflectionUtils.GetAttribute <DescriptionAttribute>(type)?.Description);
}
private string method_2(Type type_0)
{
JsonContainerAttribute attribute = Class139.smethod_0(type_0);
if ((attribute != null) && !string.IsNullOrEmpty(attribute.Title))
{
return(attribute.Title);
}
return(null);
}
// Token: 0x0600118B RID: 4491 RVA: 0x00061664 File Offset: 0x0005F864
private string GetTitle(Type type)
{
JsonContainerAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (!StringUtils.IsNullOrEmpty((cachedAttribute != null) ? cachedAttribute.Title : null))
{
return(cachedAttribute.Title);
}
return(null);
}
private string GetTitle(Type type)
{
JsonContainerAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>((object)type);
if (!string.IsNullOrEmpty(cachedAttribute?.Title))
{
return(cachedAttribute.Title);
}
return((string)null);
}
private string GetDescription(Type type)
{
JsonContainerAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>((object)type);
if (!string.IsNullOrEmpty(cachedAttribute?.Description))
{
return(cachedAttribute.Description);
}
return(ReflectionUtils.GetAttribute <DescriptionAttribute>((object)type)?.Description);
}
private string GetTitle(Type type, JsonProperty memberProperty)
{
JsonContainerAttribute containerAttribute = GetAttributeFromTypeOrProperty <JsonContainerAttribute>(type, memberProperty);
if (!string.IsNullOrEmpty(containerAttribute?.Title))
{
return(containerAttribute.Title);
}
return(null);
}
private string GetDescription(Type type)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (containerAttribute != null && !string.IsNullOrEmpty(containerAttribute.Description))
{
return(containerAttribute.Description);
}
return(null);
}
public static NamingStrategy GetContainerNamingStrategy(JsonContainerAttribute containerAttribute)
{
if (containerAttribute.NamingStrategyInstance == null)
{
if (containerAttribute.NamingStrategyType == null)
{
return(null);
}
containerAttribute.NamingStrategyInstance = JsonTypeReflector.CreateNamingStrategyInstance(containerAttribute.NamingStrategyType, containerAttribute.NamingStrategyParameters);
}
return(containerAttribute.NamingStrategyInstance);
}
private string GetDescription(Type type, JsonProperty memberProperty)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (!string.IsNullOrEmpty(containerAttribute?.Description))
{
return(containerAttribute.Description);
}
AttributeHelpers.GetDescription(type, memberProperty, out string description);
return(description);
}
private string GetTitle(Type type, JsonProperty memberProperty)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
if (!string.IsNullOrEmpty(containerAttribute?.Title))
{
return(containerAttribute.Title);
}
AttributeHelpers.GetDisplayName(type, memberProperty, out string displayName);
return(displayName);
}
private void InitializeContract(JsonContract contract)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.UnderlyingType);
if (containerAttribute != null)
{
contract.IsReference = containerAttribute._isReference;
}
#if !PocketPC && !NET20
else
{
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(contract.UnderlyingType);
// doesn't have a null value
if (dataContractAttribute != null && dataContractAttribute.IsReference)
{
contract.IsReference = true;
}
}
#endif
contract.DefaultContstructor =
ReflectionUtils.GetDefaultConstructor(contract.CreatedType, false) ??
ReflectionUtils.GetDefaultConstructor(contract.CreatedType, true);
foreach (MethodInfo method in contract.UnderlyingType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
Type prevAttributeType = null;
ParameterInfo[] parameters = method.GetParameters();
#if !PocketPC && !SILVERLIGHT && !NET20
if (IsValidCallback(method, parameters, typeof(OnSerializingAttribute), contract.OnSerializing, ref prevAttributeType))
{
contract.OnSerializing = method;
}
if (IsValidCallback(method, parameters, typeof(OnSerializedAttribute), contract.OnSerialized, ref prevAttributeType))
{
contract.OnSerialized = method;
}
if (IsValidCallback(method, parameters, typeof(OnDeserializingAttribute), contract.OnDeserializing, ref prevAttributeType))
{
contract.OnDeserializing = method;
}
if (IsValidCallback(method, parameters, typeof(OnDeserializedAttribute), contract.OnDeserialized, ref prevAttributeType))
{
contract.OnDeserialized = method;
}
#endif
if (IsValidCallback(method, parameters, typeof(OnErrorAttribute), contract.OnError, ref prevAttributeType))
{
contract.OnError = method;
}
}
}
// Token: 0x060009FA RID: 2554 RVA: 0x00009542 File Offset: 0x00007742
public static NamingStrategy smethod_8(JsonContainerAttribute jsonContainerAttribute_0)
{
if (jsonContainerAttribute_0.method_0() == null)
{
if (jsonContainerAttribute_0.NamingStrategyType == null)
{
return(null);
}
jsonContainerAttribute_0.method_1(Class124.smethod_7(jsonContainerAttribute_0.NamingStrategyType, jsonContainerAttribute_0.NamingStrategyParameters));
}
return(jsonContainerAttribute_0.method_0());
}
private string GetTitle(Type type)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(type);
if (containerAttribute != null && !string.IsNullOrEmpty(containerAttribute.Title))
{
return(containerAttribute.Title);
}
else
{
return((string)null);
}
}
/// <summary>
/// Returns a table name for a type and accounts for table renaming
/// via the DataContractAttribute, DataTableAttribute and/or the JsonObjectAttribute.
/// </summary>
/// <param name="type">
/// The type for which to return the table name.
/// </param>
/// <returns>
/// The table name.
/// </returns>
public virtual string ResolveTableName(Type type)
{
// Lookup the Mobile Services name of the Type and use that
string name = null;
lock (tableNameCache)
{
if (!this.tableNameCache.TryGetValue(type, out name))
{
// By default, use the type name itself
name = type.Name;
DataContractAttribute dataContractAttribute = type.GetTypeInfo().GetCustomAttributes(typeof(DataContractAttribute), true)
.FirstOrDefault() as DataContractAttribute;
if (dataContractAttribute != null)
{
if (!string.IsNullOrWhiteSpace(dataContractAttribute.Name))
{
name = dataContractAttribute.Name;
}
}
JsonContainerAttribute jsonContainerAttribute = type.GetTypeInfo().GetCustomAttributes(typeof(JsonContainerAttribute), true)
.FirstOrDefault() as JsonContainerAttribute;
if (jsonContainerAttribute != null)
{
if (!string.IsNullOrWhiteSpace(jsonContainerAttribute.Title))
{
name = jsonContainerAttribute.Title;
}
}
DataTableAttribute dataTableAttribute = type.GetTypeInfo().GetCustomAttributes(typeof(DataTableAttribute), true)
.FirstOrDefault() as DataTableAttribute;
if (dataTableAttribute != null)
{
if (!string.IsNullOrEmpty(dataTableAttribute.Name))
{
name = dataTableAttribute.Name;
}
}
this.tableNameCache[type] = name;
// Build the JsonContract now to catch any contract errors early
this.CreateContract(type);
}
}
return(name);
}
public NamingStrategy GetContainerNamingStrategy(JsonContainerAttribute containerAttribute)
{
if (containerAttribute.Internal().NamingStrategyInstance == null)
{
if (containerAttribute.Internal().NamingStrategyType == null)
{
return(null);
}
containerAttribute.Internal().NamingStrategyInstance = CreateNamingStrategyInstance(containerAttribute.Internal().NamingStrategyType, containerAttribute.Internal().NamingStrategyParameters);
}
return(containerAttribute.Internal().NamingStrategyInstance);
}
internal JsonContainerContract(Type underlyingType) : base(underlyingType)
{
JsonContainerAttribute attribute = Class139.smethod_0(underlyingType);
if (attribute != null)
{
if (attribute.ItemConverterType != null)
{
this.ItemConverter = JsonConverterAttribute.smethod_0(attribute.ItemConverterType);
}
this.ItemIsReference = attribute.nullable_1;
this.ItemReferenceLoopHandling = attribute.nullable_2;
this.ItemTypeNameHandling = attribute.nullable_3;
}
}
internal JsonContainerContract(Type underlyingType) : base(underlyingType)
{
JsonContainerAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(underlyingType);
if (cachedAttribute != null)
{
if (cachedAttribute.ItemConverterType != null)
{
this.ItemConverter = JsonTypeReflector.CreateJsonConverterInstance(cachedAttribute.ItemConverterType, cachedAttribute.ItemConverterParameters);
}
this.ItemIsReference = cachedAttribute._itemIsReference;
this.ItemReferenceLoopHandling = cachedAttribute._itemReferenceLoopHandling;
this.ItemTypeNameHandling = cachedAttribute._itemTypeNameHandling;
}
}
private string GetDescription(Type type)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute<JsonContainerAttribute>(type);
if (containerAttribute != null && !string.IsNullOrEmpty(containerAttribute.Description))
return containerAttribute.Description;
#if !(DOTNET || PORTABLE40 || PORTABLE)
DescriptionAttribute descriptionAttribute = ReflectionUtils.GetAttribute<DescriptionAttribute>(type);
if (descriptionAttribute != null)
return descriptionAttribute.Description;
#endif
return null;
}
internal JsonContainerContract(Type underlyingType) : base(underlyingType)
{
JsonContainerAttribute jsonContainerAttribute = JsonTypeReflector.GetJsonContainerAttribute(underlyingType);
if (jsonContainerAttribute != null)
{
if (jsonContainerAttribute.ItemConverterType != null)
{
this.ItemConverter = JsonConverterAttribute.CreateJsonConverterInstance(jsonContainerAttribute.ItemConverterType);
}
this.ItemIsReference = jsonContainerAttribute._itemIsReference;
this.ItemReferenceLoopHandling = jsonContainerAttribute._itemReferenceLoopHandling;
this.ItemTypeNameHandling = jsonContainerAttribute._itemTypeNameHandling;
}
}
private Uri GetTypeId(Type type, bool explicitOnly)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>(type);
Uri typeId;
if (!string.IsNullOrEmpty(containerAttribute?.Id))
{
typeId = new Uri(containerAttribute.Id, UriKind.RelativeOrAbsolute);
}
else
{
if (explicitOnly)
{
return(null);
}
switch (_generator.SchemaIdGenerationHandling)
{
case SchemaIdGenerationHandling.TypeName:
typeId = new Uri(type.Name, UriKind.RelativeOrAbsolute);
break;
case SchemaIdGenerationHandling.FullTypeName:
typeId = new Uri(type.FullName, UriKind.RelativeOrAbsolute);
break;
case SchemaIdGenerationHandling.AssemblyQualifiedName:
typeId = new Uri(type.AssemblyQualifiedName, UriKind.RelativeOrAbsolute);
break;
default:
return(null);
}
}
// avoid id conflicts
Uri resolvedTypeId = typeId;
int i = 1;
while (_typeSchemas.Any(s => s.Schema.Id == resolvedTypeId))
{
resolvedTypeId = new Uri(typeId.OriginalString + "-" + i, UriKind.RelativeOrAbsolute);
i++;
}
return(resolvedTypeId);
}
