public static MemberSerialization GetObjectMemberSerialization(
Type objectType,
bool ignoreSerializableAttribute)
{
JsonObjectAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonObjectAttribute>((object)objectType);
if (cachedAttribute != null)
{
return(cachedAttribute.MemberSerialization);
}
if (JsonTypeReflector.GetDataContractAttribute(objectType) != null)
{
return(MemberSerialization.OptIn);
}
return(!ignoreSerializableAttribute && JsonTypeReflector.GetCachedAttribute <SerializableAttribute>((object)objectType) != null ? MemberSerialization.Fields : MemberSerialization.OptOut);
}
public static T GetAttribute <T>(object provider) where T : Attribute
{
Type type = provider as Type;
if (type != null)
{
return(JsonTypeReflector.GetAttribute <T>(type));
}
MemberInfo memberInfo = provider as MemberInfo;
if (memberInfo != null)
{
return(JsonTypeReflector.GetAttribute <T>(memberInfo));
}
return(ReflectionUtils.GetAttribute <T>(provider, true));
}
private static Type GetAssociateMetadataTypeFromAttribute(Type type)
{
Type metadataTypeAttributeType = JsonTypeReflector.GetMetadataTypeAttributeType();
if (metadataTypeAttributeType == null)
{
return(null);
}
object obj = type.GetCustomAttributes(metadataTypeAttributeType, true).SingleOrDefault <object>();
if (obj == null)
{
return(null);
}
return((new LateBoundMetadataTypeAttribute(obj)).MetadataClassType);
}
public static JsonConverter GetJsonConverter(ICustomAttributeProvider attributeProvider, Type targetConvertedType)
{
Type jsonConverterType = JsonTypeReflector.GetJsonConverterType(attributeProvider);
if (jsonConverterType == null)
{
return(null);
}
JsonConverter jsonConverter = JsonConverterAttribute.CreateJsonConverterInstance(jsonConverterType);
if (!jsonConverter.CanConvert(targetConvertedType))
{
throw new JsonSerializationException("JsonConverter {0} on {1} is not compatible with member type {2}.".FormatWith(CultureInfo.InvariantCulture, new object[] { jsonConverter.GetType().Name, attributeProvider, targetConvertedType.Name }));
}
return(jsonConverter);
}
public static MemberSerialization GetObjectMemberSerialization(Type objectType)
{
JsonObjectAttribute jsonObjectAttribute = JsonTypeReflector.GetJsonObjectAttribute(objectType);
if (jsonObjectAttribute != null)
{
return(jsonObjectAttribute.MemberSerialization);
}
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType);
if (dataContractAttribute != null)
{
return(MemberSerialization.OptIn);
}
return(MemberSerialization.OptOut);
}
/// <summary>
/// Determines which contract type is created for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>A <see cref="JsonContract"/> for the given type.</returns>
protected virtual JsonContract CreateContract(Type objectType)
{
Type t = ReflectionUtils.EnsureNotNullableType(objectType);
if (JsonConvert.IsJsonPrimitiveType(t))
{
return(CreatePrimitiveContract(t));
}
if (JsonTypeReflector.GetJsonObjectAttribute(t) != null)
{
return(CreateObjectContract(t));
}
if (JsonTypeReflector.GetJsonArrayAttribute(t) != null)
{
return(CreateArrayContract(t));
}
if (t == typeof(JToken) || t.IsSubclassOf(typeof(JToken)))
{
return(CreateLinqContract(t));
}
if (CollectionUtils.IsDictionaryType(t))
{
return(CreateDictionaryContract(t));
}
if (typeof(IEnumerable).IsAssignableFrom(t))
{
return(CreateArrayContract(t));
}
if (CanConvertToString(t))
{
return(CreateStringContract(t));
}
#if !((UNITY_WINRT && !UNITY_EDITOR) || (UNITY_WP8 || UNITY_WP_8_1))
if (typeof(ISerializable).IsAssignableFrom(t))
{
return(CreateISerializableContract(t));
}
#endif
return(CreateObjectContract(t));
}
internal JsonContainerContract(Type underlyingType)
{
Class6.yDnXvgqzyB5jw();
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 JsonContract CreateContract(Type objectType)
{
if (JsonTypeReflector.GetJsonObjectAttribute(objectType) != null)
{
return(CreateObjectContract(objectType));
}
if (CollectionUtils.IsDictionaryType(objectType))
{
return(CreateDictionaryContract(objectType));
}
if (typeof(IEnumerable).IsAssignableFrom(objectType))
{
return(CreateArrayContract(objectType));
}
return(CreateObjectContract(objectType));
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonContainerContract"/> class.
/// </summary>
/// <param name="underlyingType">The underlying type for the contract.</param>
internal JsonContainerContract(Type underlyingType)
: base(underlyingType)
{
JsonContainerAttribute jsonContainerAttribute = JsonTypeReflector.GetJsonContainerAttribute(underlyingType);
if (jsonContainerAttribute != null)
{
if (jsonContainerAttribute.ItemConverterType != null)
{
ItemConverter = JsonConverterAttribute.CreateJsonConverterInstance(jsonContainerAttribute.ItemConverterType);
}
ItemIsReference = jsonContainerAttribute._itemIsReference;
ItemReferenceLoopHandling = jsonContainerAttribute._itemReferenceLoopHandling;
ItemTypeNameHandling = jsonContainerAttribute._itemTypeNameHandling;
}
}
private void InitializeContract(JsonContract contract)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.NonNullableUnderlyingType);
if (containerAttribute != null)
{
contract.IsReference = containerAttribute._isReference;
}
contract.Converter = this.ResolveContractConverter(contract.NonNullableUnderlyingType);
contract.InternalConverter = JsonSerializer.GetMatchingConverter(DefaultContractResolver.BuiltInConverters, contract.NonNullableUnderlyingType);
if (ReflectionUtils.HasDefaultConstructor(contract.CreatedType, true) || TypeExtensions.IsValueType(contract.CreatedType))
{
contract.DefaultCreator = this.GetDefaultCreator(contract.CreatedType);
contract.DefaultCreatorNonPublic = !TypeExtensions.IsValueType(contract.CreatedType) && ReflectionUtils.GetDefaultConstructor(contract.CreatedType) == null;
}
this.ResolveCallbackMethods(contract, contract.NonNullableUnderlyingType);
}
/// <summary>
/// Gets the serializable members for the type.
/// </summary>
/// <param name="objectType">The type to get serializable members for.</param>
/// <returns>The serializable members for the type.</returns>
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType)
{
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType);
List <MemberInfo> defaultMembers = ReflectionUtils.GetFieldsAndProperties(objectType, DefaultMembersSearchFlags)
.Where(m => !ReflectionUtils.IsIndexedProperty(m)).ToList();
List <MemberInfo> allMembers = ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static)
.Where(m => !ReflectionUtils.IsIndexedProperty(m)).ToList();
List <MemberInfo> serializableMembers = new List <MemberInfo>();
foreach (MemberInfo member in allMembers)
{
// exclude members that are compiler generated if set
if (SerializeCompilerGeneratedMembers || !member.IsDefined(typeof(CompilerGeneratedAttribute), true))
{
if (defaultMembers.Contains(member))
{
// add all members that are found by default member search
serializableMembers.Add(member);
}
else
{
// add members that are explicitly marked with JsonProperty/DataMember attribute
if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(member) != null)
{
serializableMembers.Add(member);
}
else if (dataContractAttribute != null && JsonTypeReflector.GetAttribute <DataMemberAttribute>(member) != null)
{
serializableMembers.Add(member);
}
}
}
}
Type match;
// don't include EntityKey on entities objects... this is a bit hacky
if (objectType.AssignableToTypeName("System.Data.Objects.DataClasses.EntityObject", out match))
{
serializableMembers = serializableMembers.Where(ShouldSerializeEntityMember).ToList();
}
return(serializableMembers);
}
protected virtual JsonObjectContract CreateObjectContract(Type objectType)
{
JsonObjectContract jsonObjectContract = new JsonObjectContract(objectType);
this.InitializeContract(jsonObjectContract);
bool ignoreSerializableAttribute = this.IgnoreSerializableAttribute;
jsonObjectContract.MemberSerialization = JsonTypeReflector.GetObjectMemberSerialization(jsonObjectContract.NonNullableUnderlyingType, ignoreSerializableAttribute);
jsonObjectContract.Properties.AddRange(this.CreateProperties(jsonObjectContract.NonNullableUnderlyingType, jsonObjectContract.MemberSerialization));
JsonObjectAttribute jsonObjectAttribute = JsonTypeReflector.GetJsonObjectAttribute(jsonObjectContract.NonNullableUnderlyingType);
if (jsonObjectAttribute != null)
{
jsonObjectContract.ItemRequired = jsonObjectAttribute._itemRequired;
}
ConstructorInfo attributeConstructor = this.GetAttributeConstructor(jsonObjectContract.NonNullableUnderlyingType);
if (attributeConstructor != null)
{
jsonObjectContract.OverrideConstructor = attributeConstructor;
jsonObjectContract.ConstructorParameters.AddRange(this.CreateConstructorParameters(attributeConstructor, jsonObjectContract.Properties));
}
else if (jsonObjectContract.MemberSerialization == MemberSerialization.Fields)
{
if (JsonTypeReflector.FullyTrusted)
{
jsonObjectContract.DefaultCreator = new Func <object>(jsonObjectContract.GetUninitializedObject);
}
}
else if (jsonObjectContract.DefaultCreator == null || jsonObjectContract.DefaultCreatorNonPublic)
{
ConstructorInfo parametrizedConstructor = this.GetParametrizedConstructor(jsonObjectContract.NonNullableUnderlyingType);
if (parametrizedConstructor != null)
{
jsonObjectContract.ParametrizedConstructor = parametrizedConstructor;
jsonObjectContract.ConstructorParameters.AddRange(this.CreateConstructorParameters(parametrizedConstructor, jsonObjectContract.Properties));
}
}
MemberInfo extensionDataMemberForType = this.GetExtensionDataMemberForType(jsonObjectContract.NonNullableUnderlyingType);
if (extensionDataMemberForType != null)
{
DefaultContractResolver.SetExtensionDataDelegates(jsonObjectContract, extensionDataMemberForType);
}
return(jsonObjectContract);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Newtonsoft.Json.Serialization.JsonContainerContract" /> class.
/// </summary>
/// <param name="underlyingType">The underlying type for the contract.</param>
internal JsonContainerContract(Type underlyingType)
: base(underlyingType)
{
JsonContainerAttribute cachedAttribute = JsonTypeReflector.GetCachedAttribute <JsonContainerAttribute>((object)underlyingType);
if (cachedAttribute == null)
{
return;
}
if (cachedAttribute.ItemConverterType != null)
{
this.ItemConverter = JsonTypeReflector.CreateJsonConverterInstance(cachedAttribute.ItemConverterType, cachedAttribute.ItemConverterParameters);
}
this.ItemIsReference = cachedAttribute._itemIsReference;
this.ItemReferenceLoopHandling = cachedAttribute._itemReferenceLoopHandling;
this.ItemTypeNameHandling = cachedAttribute._itemTypeNameHandling;
}
/// <summary>
/// Determines which contract type is created for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>A <see cref="JsonContract"/> for the given type.</returns>
protected virtual JsonContract CreateContract(Type objectType)
{
if (JsonConvert.IsJsonPrimitiveType(objectType))
{
return(CreatePrimitiveContract(objectType));
}
if (JsonTypeReflector.GetJsonObjectAttribute(objectType) != null)
{
return(CreateObjectContract(objectType));
}
if (JsonTypeReflector.GetJsonArrayAttribute(objectType) != null)
{
return(CreateArrayContract(objectType));
}
if (objectType.IsSubclassOf(typeof(JToken)))
{
return(CreateLinqContract(objectType));
}
if (CollectionUtils.IsDictionaryType(objectType))
{
return(CreateDictionaryContract(objectType));
}
if (typeof(IEnumerable).IsAssignableFrom(objectType))
{
return(CreateArrayContract(objectType));
}
if (CanConvertToString(objectType))
{
return(CreateStringContract(objectType));
}
#if !SILVERLIGHT && !PocketPC
if (typeof(ISerializable).IsAssignableFrom(objectType))
{
return(CreateISerializableContract(objectType));
}
#endif
return(CreateObjectContract(objectType));
}
protected virtual JsonContract CreateContract(Type objectType)
{
Type type = ReflectionUtils.EnsureNotNullableType(objectType);
if (JsonConvert.IsJsonPrimitiveType(type))
{
return((JsonContract)this.CreatePrimitiveContract(objectType));
}
if (JsonTypeReflector.GetJsonObjectAttribute(type) != null)
{
return((JsonContract)this.CreateObjectContract(objectType));
}
if (JsonTypeReflector.GetJsonArrayAttribute(type) != null)
{
return((JsonContract)this.CreateArrayContract(objectType));
}
if (JsonTypeReflector.GetJsonDictionaryAttribute(type) != null)
{
return((JsonContract)this.CreateDictionaryContract(objectType));
}
if (type == typeof(JToken) || type.IsSubclassOf(typeof(JToken)))
{
return((JsonContract)this.CreateLinqContract(objectType));
}
if (CollectionUtils.IsDictionaryType(type))
{
return((JsonContract)this.CreateDictionaryContract(objectType));
}
if (typeof(IEnumerable).IsAssignableFrom(type))
{
return((JsonContract)this.CreateArrayContract(objectType));
}
if (DefaultContractResolver.CanConvertToString(type))
{
return((JsonContract)this.CreateStringContract(objectType));
}
if (!this.IgnoreSerializableInterface && typeof(ISerializable).IsAssignableFrom(type))
{
return((JsonContract)this.CreateISerializableContract(objectType));
}
else
{
return((JsonContract)this.CreateObjectContract(objectType));
}
}
private static Type GetAssociateMetadataTypeFromAttribute(Type type)
{
Type metadataTypeAttributeType = JsonTypeReflector.GetMetadataTypeAttributeType();
if (metadataTypeAttributeType == null)
{
return(null);
}
object obj = type.GetCustomAttributes(metadataTypeAttributeType, true).SingleOrDefault <object>();
if (obj == null)
{
return(null);
}
IMetadataTypeAttribute metadataTypeAttribute = JsonTypeReflector.DynamicCodeGeneration ? DynamicWrapper.CreateWrapper <IMetadataTypeAttribute>(obj) : new LateBoundMetadataTypeAttribute(obj);
return(metadataTypeAttribute.MetadataClassType);
}
/// <summary>
/// Creates a <see cref="JsonObjectContract"/> for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>A <see cref="JsonObjectContract"/> for the given type.</returns>
protected virtual JsonObjectContract CreateObjectContract(Type objectType)
{
JsonObjectContract contract = new JsonObjectContract(objectType);
InitializeContract(contract);
bool ignoreSerializableAttribute;
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE)
ignoreSerializableAttribute = IgnoreSerializableAttribute;
#else
ignoreSerializableAttribute = true;
#endif
contract.MemberSerialization = JsonTypeReflector.GetObjectMemberSerialization(contract.NonNullableUnderlyingType, ignoreSerializableAttribute);
contract.Properties.AddRange(CreateProperties(contract.NonNullableUnderlyingType, contract.MemberSerialization));
JsonObjectAttribute attribute = JsonTypeReflector.GetJsonObjectAttribute(contract.NonNullableUnderlyingType);
if (attribute != null)
{
contract.ItemRequired = attribute._itemRequired;
}
// check if a JsonConstructorAttribute has been defined and use that
if (contract.NonNullableUnderlyingType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Any(c => c.IsDefined(typeof(JsonConstructorAttribute), true)))
{
ConstructorInfo constructor = GetAttributeConstructor(contract.NonNullableUnderlyingType);
if (constructor != null)
{
contract.OverrideConstructor = constructor;
contract.ConstructorParameters.AddRange(CreateConstructorParameters(constructor, contract.Properties));
}
}
else if (contract.DefaultCreator == null || contract.DefaultCreatorNonPublic)
{
ConstructorInfo constructor = GetParametrizedConstructor(contract.NonNullableUnderlyingType);
if (constructor != null)
{
contract.ParametrizedConstructor = constructor;
contract.ConstructorParameters.AddRange(CreateConstructorParameters(constructor, contract.Properties));
}
}
return(contract);
}
public static T GetAttribute <T>(ICustomAttributeProvider provider)
where T : Attribute
{
Type type = provider as Type;
Type type1 = type;
if (type != null)
{
return(JsonTypeReflector.GetAttribute <T>(type1));
}
MemberInfo memberInfo = provider as MemberInfo;
MemberInfo memberInfo1 = memberInfo;
if (memberInfo != null)
{
return(JsonTypeReflector.GetAttribute <T>(memberInfo1));
}
return(ReflectionUtils.GetAttribute <T>(provider, true));
}
/// <summary>
/// Creates a <see cref="JsonObjectContract"/> for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>A <see cref="JsonObjectContract"/> for the given type.</returns>
protected virtual JsonObjectContract CreateObjectContract(Type objectType)
{
JsonObjectContract contract = new JsonObjectContract(objectType);
InitializeContract(contract);
contract.MemberSerialization = JsonTypeReflector.GetObjectMemberSerialization(objectType);
contract.Properties.AddRange(CreateProperties(contract.UnderlyingType, contract.MemberSerialization));
if (objectType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Any(c => c.IsDefined(typeof(JsonConstructorAttribute), true)))
{
contract.OverrideConstructor = GetAttributeConstructor(objectType);
}
else if (contract.DefaultCreator == null || contract.DefaultCreatorNonPublic)
{
contract.ParametrizedConstructor = GetParametrizedConstructor(objectType);
}
return(contract);
}
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType)
{
Type type;
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType);
List <MemberInfo> list = (
from m in ReflectionUtils.GetFieldsAndProperties(objectType, this.DefaultMembersSearchFlags)
where !ReflectionUtils.IsIndexedProperty(m)
select m).ToList <MemberInfo>();
List <MemberInfo> memberInfos = (
from m in ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
where !ReflectionUtils.IsIndexedProperty(m)
select m).ToList <MemberInfo>();
List <MemberInfo> memberInfos1 = new List <MemberInfo>();
foreach (MemberInfo memberInfo in memberInfos)
{
if (!this.SerializeCompilerGeneratedMembers && memberInfo.IsDefined(typeof(CompilerGeneratedAttribute), true))
{
continue;
}
if (list.Contains(memberInfo))
{
memberInfos1.Add(memberInfo);
}
else if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>((ICustomAttributeProvider)memberInfo) == null)
{
if (dataContractAttribute == null || JsonTypeReflector.GetAttribute <DataMemberAttribute>((ICustomAttributeProvider)memberInfo) == null)
{
continue;
}
memberInfos1.Add(memberInfo);
}
else
{
memberInfos1.Add(memberInfo);
}
}
if (objectType.AssignableToTypeName("System.Data.Objects.DataClasses.EntityObject", out type))
{
memberInfos1 = memberInfos1.Where <MemberInfo>(new Func <MemberInfo, bool>(this.ShouldSerializeEntityMember)).ToList <MemberInfo>();
}
return(memberInfos1);
}
/// <summary>
/// Gets the serializable members for the type.
/// </summary>
/// <param name="objectType">The type to get serializable members for.</param>
/// <returns>The serializable members for the type.</returns>
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType)
{
#if !PocketPC && !NET20
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType);
#endif
List <MemberInfo> defaultMembers = ReflectionUtils.GetFieldsAndProperties(objectType, DefaultMembersSearchFlags);
List <MemberInfo> allMembers = ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
List <MemberInfo> serializableMembers = new List <MemberInfo>();
foreach (MemberInfo member in allMembers)
{
if (defaultMembers.Contains(member))
{
serializableMembers.Add(member);
}
else
{
if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(member) != null)
{
serializableMembers.Add(member);
}
#if !PocketPC && !NET20
else if (dataContractAttribute != null && JsonTypeReflector.GetAttribute <DataMemberAttribute>(member) != null)
{
serializableMembers.Add(member);
}
#endif
}
}
#if !PocketPC && !SILVERLIGHT && !NET20
Type match;
// don't include EntityKey on entities objects... this is a bit hacky
if (objectType.AssignableToTypeName("System.Data.Objects.DataClasses.EntityObject", out match))
{
serializableMembers = serializableMembers.Where(ShouldSerializeEntityMember).ToList();
}
#endif
return(serializableMembers);
}
protected virtual JsonObjectContract CreateObjectContract(Type objectType)
{
JsonObjectContract jsonObjectContract = new JsonObjectContract(objectType);
this.InitializeContract((JsonContract)jsonObjectContract);
bool serializableAttribute = this.IgnoreSerializableAttribute;
jsonObjectContract.MemberSerialization = JsonTypeReflector.GetObjectMemberSerialization(jsonObjectContract.NonNullableUnderlyingType, serializableAttribute);
CollectionUtils.AddRange <JsonProperty>((IList <JsonProperty>)jsonObjectContract.Properties, (IEnumerable <JsonProperty>) this.CreateProperties(jsonObjectContract.NonNullableUnderlyingType, jsonObjectContract.MemberSerialization));
JsonObjectAttribute jsonObjectAttribute = JsonTypeReflector.GetJsonObjectAttribute(jsonObjectContract.NonNullableUnderlyingType);
if (jsonObjectAttribute != null)
{
jsonObjectContract.ItemRequired = jsonObjectAttribute._itemRequired;
}
if (Enumerable.Any <ConstructorInfo>((IEnumerable <ConstructorInfo>)jsonObjectContract.NonNullableUnderlyingType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic), (Func <ConstructorInfo, bool>)(c => c.IsDefined(typeof(JsonConstructorAttribute), true))))
{
ConstructorInfo attributeConstructor = this.GetAttributeConstructor(jsonObjectContract.NonNullableUnderlyingType);
if (attributeConstructor != null)
{
jsonObjectContract.OverrideConstructor = attributeConstructor;
CollectionUtils.AddRange <JsonProperty>((IList <JsonProperty>)jsonObjectContract.ConstructorParameters, (IEnumerable <JsonProperty>) this.CreateConstructorParameters(attributeConstructor, jsonObjectContract.Properties));
}
}
else if (jsonObjectContract.MemberSerialization == MemberSerialization.Fields)
{
if (JsonTypeReflector.FullyTrusted)
{
jsonObjectContract.DefaultCreator = new Func <object>(jsonObjectContract.GetUninitializedObject);
}
}
else if (jsonObjectContract.DefaultCreator == null || jsonObjectContract.DefaultCreatorNonPublic)
{
ConstructorInfo parametrizedConstructor = this.GetParametrizedConstructor(jsonObjectContract.NonNullableUnderlyingType);
if (parametrizedConstructor != null)
{
jsonObjectContract.ParametrizedConstructor = parametrizedConstructor;
CollectionUtils.AddRange <JsonProperty>((IList <JsonProperty>)jsonObjectContract.ConstructorParameters, (IEnumerable <JsonProperty>) this.CreateConstructorParameters(parametrizedConstructor, jsonObjectContract.Properties));
}
}
return(jsonObjectContract);
}
public static T GetAttribute <T>(ICustomAttributeProvider attributeProvider) where T : Attribute
{
object obj = (object)attributeProvider;
Type type = obj as Type;
if (type != null)
{
return(JsonTypeReflector.GetAttribute <T>(type));
}
MemberInfo memberInfo = obj as MemberInfo;
if (memberInfo != null)
{
return(JsonTypeReflector.GetAttribute <T>(memberInfo));
}
else
{
return(ReflectionUtils.GetAttribute <T>(attributeProvider, true));
}
}
private static T GetAttribute <T>(MemberInfo memberInfo)
where T : Attribute
{
T attribute;
Type associatedMetadataType = JsonTypeReflector.GetAssociatedMetadataType(memberInfo.DeclaringType);
if (associatedMetadataType != null)
{
MemberInfo memberInfoFromType = ReflectionUtils.GetMemberInfoFromType(associatedMetadataType, memberInfo);
if (memberInfoFromType != null)
{
attribute = ReflectionUtils.GetAttribute <T>(memberInfoFromType, true);
if (attribute != null)
{
return(attribute);
}
}
}
attribute = ReflectionUtils.GetAttribute <T>(memberInfo, true);
if (attribute != null)
{
return(attribute);
}
if (memberInfo.DeclaringType != null)
{
Type[] interfaces = memberInfo.DeclaringType.GetInterfaces();
for (int i = 0; i < (int)interfaces.Length; i++)
{
MemberInfo memberInfoFromType1 = ReflectionUtils.GetMemberInfoFromType(interfaces[i], memberInfo);
if (memberInfoFromType1 != null)
{
attribute = ReflectionUtils.GetAttribute <T>(memberInfoFromType1, true);
if (attribute != null)
{
return(attribute);
}
}
}
}
return(default(T));
}
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType)
{
bool serializableAttribute = this.IgnoreSerializableAttribute;
MemberSerialization memberSerialization = JsonTypeReflector.GetObjectMemberSerialization(objectType, serializableAttribute);
List <MemberInfo> list1 = Enumerable.ToList <MemberInfo>(Enumerable.Where <MemberInfo>((IEnumerable <MemberInfo>)ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), (Func <MemberInfo, bool>)(m => !ReflectionUtils.IsIndexedProperty(m))));
List <MemberInfo> list2 = new List <MemberInfo>();
if (memberSerialization != MemberSerialization.Fields)
{
List <MemberInfo> list3 = Enumerable.ToList <MemberInfo>(Enumerable.Where <MemberInfo>((IEnumerable <MemberInfo>)ReflectionUtils.GetFieldsAndProperties(objectType, this.DefaultMembersSearchFlags), (Func <MemberInfo, bool>)(m => !ReflectionUtils.IsIndexedProperty(m))));
foreach (MemberInfo memberInfo in list1)
{
if (this.SerializeCompilerGeneratedMembers || !memberInfo.IsDefined(typeof(CompilerGeneratedAttribute), true))
{
if (list3.Contains(memberInfo))
{
list2.Add(memberInfo);
}
else if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(ReflectionUtils.GetCustomAttributeProvider((object)memberInfo)) != null)
{
list2.Add(memberInfo);
}
else if (memberSerialization == MemberSerialization.Fields && TypeExtensions.MemberType(memberInfo) == MemberTypes.Field)
{
list2.Add(memberInfo);
}
}
}
}
else
{
foreach (MemberInfo memberInfo in list1)
{
if (TypeExtensions.MemberType(memberInfo) == MemberTypes.Field)
{
list2.Add(memberInfo);
}
}
}
return(list2);
}
private static T GetAttribute <T>(MemberInfo memberInfo) where T : Attribute
{
Type associatedMetadataType = JsonTypeReflector.GetAssociatedMetadataType(memberInfo.DeclaringType);
if (associatedMetadataType != null)
{
MemberInfo memberInfoFromType = ReflectionUtils.GetMemberInfoFromType(associatedMetadataType, memberInfo);
if (memberInfoFromType != null)
{
T attribute = ReflectionUtils.GetAttribute <T>((object)memberInfoFromType, true);
if ((object)attribute != null)
{
return(attribute);
}
}
}
T attribute1 = ReflectionUtils.GetAttribute <T>((object)memberInfo, true);
if ((object)attribute1 != null)
{
return(attribute1);
}
if (memberInfo.DeclaringType != null)
{
foreach (Type targetType in memberInfo.DeclaringType.GetInterfaces())
{
MemberInfo memberInfoFromType = ReflectionUtils.GetMemberInfoFromType(targetType, memberInfo);
if (memberInfoFromType != null)
{
T attribute2 = ReflectionUtils.GetAttribute <T>((object)memberInfoFromType, true);
if ((object)attribute2 != null)
{
return(attribute2);
}
}
}
}
return(default(T));
}
private void InitializeContract(JsonContract contract)
{
JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.UnderlyingType);
if (containerAttribute != null)
{
contract.IsReference = containerAttribute._isReference;
}
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);
}
private JsonMemberMappingCollection CreateMemberMappings(Type objectType)
{
MemberSerialization memberSerialization = JsonTypeReflector.GetObjectMemberSerialization(objectType);
List <MemberInfo> members = GetSerializableMembers(objectType);
if (members == null)
{
throw new JsonSerializationException("Null collection of seralizable members returned.");
}
JsonMemberMappingCollection memberMappings = new JsonMemberMappingCollection();
foreach (MemberInfo member in members)
{
JsonMemberMapping memberMapping = CreateMemberMapping(memberSerialization, member);
memberMappings.AddMapping(memberMapping);
}
return(memberMappings);
}
private static T GetAttribute <T>(MemberInfo memberInfo) where T : Attribute
{
Type associatedMetadataType = JsonTypeReflector.GetAssociatedMetadataType(memberInfo.get_DeclaringType());
T attribute;
if (associatedMetadataType != null)
{
MemberInfo memberInfoFromType = ReflectionUtils.GetMemberInfoFromType(associatedMetadataType, memberInfo);
if (memberInfoFromType != null)
{
attribute = ReflectionUtils.GetAttribute <T>(memberInfoFromType, true);
if (attribute != null)
{
return(attribute);
}
}
}
attribute = ReflectionUtils.GetAttribute <T>(memberInfo, true);
if (attribute != null)
{
return(attribute);
}
Type[] interfaces = memberInfo.get_DeclaringType().GetInterfaces();
for (int i = 0; i < interfaces.Length; i++)
{
Type targetType = interfaces[i];
MemberInfo memberInfoFromType2 = ReflectionUtils.GetMemberInfoFromType(targetType, memberInfo);
if (memberInfoFromType2 != null)
{
attribute = ReflectionUtils.GetAttribute <T>(memberInfoFromType2, true);
if (attribute != null)
{
return(attribute);
}
}
}
return((T)((object)null));
}
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType)
{
DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType);
List <MemberInfo> list = (from m in ReflectionUtils.GetFieldsAndProperties(objectType, this.DefaultMembersSearchFlags)
where !ReflectionUtils.IsIndexedProperty(m)
select m).ToList <MemberInfo>();
List <MemberInfo> list2 = (from m in ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)
where !ReflectionUtils.IsIndexedProperty(m)
select m).ToList <MemberInfo>();
List <MemberInfo> list3 = new List <MemberInfo>();
foreach (MemberInfo memberInfo in list2)
{
if (this.SerializeCompilerGeneratedMembers || !memberInfo.IsDefined(typeof(CompilerGeneratedAttribute), true))
{
if (list.Contains(memberInfo))
{
list3.Add(memberInfo);
}
else if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(memberInfo) != null)
{
list3.Add(memberInfo);
}
else if (dataContractAttribute != null && JsonTypeReflector.GetAttribute <DataMemberAttribute>(memberInfo) != null)
{
list3.Add(memberInfo);
}
}
}
Type type;
if (objectType.AssignableToTypeName("System.Data.Objects.DataClasses.EntityObject", out type))
{
list3 = list3.Where(new Func <MemberInfo, bool>(this.ShouldSerializeEntityMember)).ToList <MemberInfo>();
}
return(list3);
}
