/// <summary> /// Determines whether this instance can convert the specified object type. /// </summary> /// <param name="objectType">Type of the object.</param> /// <returns> /// <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>. /// </returns> public override bool CanConvert(Type objectType) { if (typeof(IEnumerable).IsAssignableFrom(objectType)) { return(false); } // all fsharp objects have CompilationMappingAttribute // get the fsharp assembly from the attribute and initialize latebound methods var attributes = objectType.GetCustomAttributes(true); var isFSharpType = false; foreach (var attribute in attributes) { var attributeType = attribute.GetType(); if (attributeType.FullName == "Microsoft.FSharp.Core.CompilationMappingAttribute") { FSharpUtils.EnsureInitialized(attributeType.Assembly()); isFSharpType = true; break; } } if (!isFSharpType) { return(false); } return((bool)FSharpUtils.IsUnion(null, objectType, null)); }
// Token: 0x060014A2 RID: 5282 RVA: 0x0006DAB0 File Offset: 0x0006BCB0 public override bool CanConvert(Type objectType) { if (typeof(IEnumerable).IsAssignableFrom(objectType)) { return(false); } object[] customAttributes = objectType.GetCustomAttributes(true); bool flag = false; object[] array = customAttributes; for (int i = 0; i < array.Length; i++) { Type type = array[i].GetType(); if (type.FullName == "Microsoft.FSharp.Core.CompilationMappingAttribute") { FSharpUtils.EnsureInitialized(type.Assembly()); flag = true; break; } } if (!flag) { return(false); } MethodCall <object, object> isUnion = FSharpUtils.Instance.IsUnion; object target = null; object[] array2 = new object[2]; array2[0] = objectType; return((bool)isUnion(target, array2)); }
public override bool CanConvert(Type objectType) { if (typeof(IEnumerable).IsAssignableFrom(objectType)) { return(false); } bool flag = false; object[] customAttributes = objectType.GetCustomAttributes(true); for (int i = 0; i < customAttributes.Length; i++) { Type type = customAttributes[i].GetType(); if (type.FullName == "Microsoft.FSharp.Core.CompilationMappingAttribute") { FSharpUtils.EnsureInitialized(type.Assembly()); flag = true; break; } } if (!flag) { return(false); } object[] args = new object[2]; args[0] = objectType; return((bool)FSharpUtils.IsUnion(null, args)); }
/// <summary> /// Determines whether this instance can convert the specified object type. /// </summary> /// <param name="objectType">Type of the object.</param> /// <returns> /// <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>. /// </returns> public override bool CanConvert(Type objectType) { if (typeof(IEnumerable).IsAssignableFrom(objectType)) { return(false); } // all fsharp objects have CompilationMappingAttribute // get the fsharp assembly from the attribute and initialize latebound methods object[] attributes; #if !(NETFX_CORE || PORTABLE) attributes = objectType.GetCustomAttributes(true); #else attributes = objectType.GetTypeInfo().GetCustomAttributes(true).ToArray(); #endif bool isFSharpType = false; foreach (object attribute in attributes) { Type attributeType = attribute.GetType(); if (attributeType.Name == "CompilationMappingAttribute") { FSharpUtils.EnsureInitialized(attributeType.Assembly()); isFSharpType = true; break; } } if (!isFSharpType) { return(false); } return((bool)FSharpUtils.IsUnion(null, objectType, null)); }
private void StoreFSharpListCreatorIfNecessary(Type underlyingType) { if (!HasParameterizedCreatorInternal && underlyingType.Name == FSharpUtils.FSharpListTypeName) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); _parameterizedCreator = FSharpUtils.CreateSeq(CollectionItemType); } }
private void StoreFSharpListCreatorIfNecessary(Type underlyingType) { if (!this.HasParameterizedCreatorInternal && underlyingType.Name == "FSharpList`1") { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); this._parameterizedCreator = FSharpUtils.Instance.CreateSeq(this.CollectionItemType); } }
public JsonDictionaryContract(Type underlyingType) : base(underlyingType) { Type type; Type type2; base.ContractType = JsonContractType.Dictionary; if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IDictionary <,>), out this._genericCollectionDefinitionType)) { type = this._genericCollectionDefinitionType.GetGenericArguments()[0]; type2 = this._genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(base.UnderlyingType, typeof(IDictionary <,>))) { Type[] typeArguments = new Type[] { type, type2 }; base.CreatedType = typeof(Dictionary <,>).MakeGenericType(typeArguments); } base.IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyDictionary <,>)); } else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IReadOnlyDictionary <,>), out this._genericCollectionDefinitionType)) { type = this._genericCollectionDefinitionType.GetGenericArguments()[0]; type2 = this._genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(base.UnderlyingType, typeof(IReadOnlyDictionary <,>))) { Type[] typeArguments = new Type[] { type, type2 }; base.CreatedType = typeof(ReadOnlyDictionary <,>).MakeGenericType(typeArguments); } base.IsReadOnlyOrFixedSize = true; } else { ReflectionUtils.GetDictionaryKeyValueTypes(base.UnderlyingType, out type, out type2); if (base.UnderlyingType == typeof(IDictionary)) { base.CreatedType = typeof(Dictionary <object, object>); } } if ((type != null) && (type2 != null)) { Type[] typeArguments = new Type[] { type, type2 }; Type[] typeArray4 = new Type[] { type, type2 }; this._parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(base.CreatedType, typeof(KeyValuePair <,>).MakeGenericType(typeArguments), typeof(IDictionary <,>).MakeGenericType(typeArray4)); if (!this.HasParameterizedCreatorInternal && (underlyingType.Name == "FSharpMap`2")) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); this._parameterizedCreator = FSharpUtils.CreateMap(type, type2); } } this.ShouldCreateWrapper = !typeof(IDictionary).IsAssignableFrom(base.CreatedType); this.DictionaryKeyType = type; this.DictionaryValueType = type2; if (ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract(underlyingType, this.DictionaryKeyType, this.DictionaryValueType, out Type type3, out ObjectConstructor <object> constructor)) { base.CreatedType = type3; this._parameterizedCreator = constructor; base.IsReadOnlyOrFixedSize = true; } }
/// <summary> /// Initializes a new instance of the <see cref="JsonDictionaryContract"/> class. /// </summary> /// <param name="underlyingType">The underlying type for the contract.</param> public JsonDictionaryContract(Type underlyingType) : base(underlyingType) { ContractType = JsonContractType.Dictionary; Type keyType; Type valueType; if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IDictionary <,>), out _genericCollectionDefinitionType)) { keyType = _genericCollectionDefinitionType.GetGenericArguments()[0]; valueType = _genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IDictionary <,>))) { CreatedType = typeof(Dictionary <,>).MakeGenericType(keyType, valueType); } } else { ReflectionUtils.GetDictionaryKeyValueTypes(UnderlyingType, out keyType, out valueType); if (UnderlyingType == typeof(IDictionary)) { CreatedType = typeof(Dictionary <object, object>); } } if (keyType != null && valueType != null) { _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, typeof(KeyValuePair <,>).MakeGenericType(keyType, valueType)); if (!HasParametrizedCreator && underlyingType.Name == FSharpUtils.FSharpMapTypeName) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); _parametrizedCreator = FSharpUtils.CreateMap(keyType, valueType); } } ShouldCreateWrapper = !typeof(IDictionary).IsAssignableFrom(CreatedType); DictionaryKeyType = keyType; DictionaryValueType = valueType; }
public override bool CanConvert(Type objectType) { if (typeof(IEnumerable).IsAssignableFrom(objectType)) { return(false); } bool flag = false; object[] customAttributes = objectType.GetCustomAttributes(true); int num = 0; while (true) { if (num < (int)customAttributes.Length) { Type type = customAttributes[num].GetType(); if (type.FullName == "Microsoft.FSharp.Core.CompilationMappingAttribute") { FSharpUtils.EnsureInitialized(type.Assembly()); flag = true; break; } else { num++; } } else { break; } } if (!flag) { return(false); } return((bool)FSharpUtils.IsUnion(null, new object[] { objectType, null })); }
/// <summary> /// Initializes a new instance of the <see cref="JsonDictionaryContract"/> class. /// </summary> /// <param name="underlyingType">The underlying type for the contract.</param> public JsonDictionaryContract(Type underlyingType) : base(underlyingType) { ContractType = JsonContractType.Dictionary; Type keyType; Type valueType; if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IDictionary <,>), out _genericCollectionDefinitionType)) { keyType = _genericCollectionDefinitionType.GetGenericArguments()[0]; valueType = _genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IDictionary <,>))) { CreatedType = typeof(Dictionary <,>).MakeGenericType(keyType, valueType); } #if !(NET40 || NET35 || NET20 || PORTABLE40) IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyDictionary <,>)); #endif } #if !(NET40 || NET35 || NET20 || PORTABLE40) else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IReadOnlyDictionary <,>), out _genericCollectionDefinitionType)) { keyType = _genericCollectionDefinitionType.GetGenericArguments()[0]; valueType = _genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IReadOnlyDictionary <,>))) { CreatedType = typeof(ReadOnlyDictionary <,>).MakeGenericType(keyType, valueType); } IsReadOnlyOrFixedSize = true; } #endif else { ReflectionUtils.GetDictionaryKeyValueTypes(UnderlyingType, out keyType, out valueType); if (UnderlyingType == typeof(IDictionary)) { CreatedType = typeof(Dictionary <object, object>); } } if (keyType != null && valueType != null) { _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, typeof(KeyValuePair <,>).MakeGenericType(keyType, valueType)); #if !(NET35 || NET20) if (!HasParametrizedCreator && underlyingType.Name == FSharpUtils.FSharpMapTypeName) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); _parametrizedCreator = FSharpUtils.CreateMap(keyType, valueType); } #endif } ShouldCreateWrapper = !typeof(IDictionary).IsAssignableFrom(CreatedType); DictionaryKeyType = keyType; DictionaryValueType = valueType; #if (NET20 || NET35) if (DictionaryValueType != null && ReflectionUtils.IsNullableType(DictionaryValueType)) { Type tempDictioanryType; // bug in .NET 2.0 & 3.5 that Dictionary<TKey, Nullable<TValue>> throws an error when adding null via IDictionary[key] = object // wrapper will handle calling Add(T) instead if (ReflectionUtils.InheritsGenericDefinition(CreatedType, typeof(Dictionary <,>), out tempDictioanryType)) { ShouldCreateWrapper = true; } } #endif #if !(NET20 || NET35 || NET40) Type immutableCreatedType; ObjectConstructor <object> immutableParameterizedCreator; if (ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract(underlyingType, DictionaryKeyType, DictionaryValueType, out immutableCreatedType, out immutableParameterizedCreator)) { CreatedType = immutableCreatedType; _parametrizedCreator = immutableParameterizedCreator; IsReadOnlyOrFixedSize = true; } #endif }
/// <summary> /// Initializes a new instance of the <see cref="JsonArrayContract"/> class. /// </summary> /// <param name="underlyingType">The underlying type for the contract.</param> public JsonArrayContract(Type underlyingType) : base(underlyingType) { ContractType = JsonContractType.Array; IsArray = CreatedType.IsArray; bool canDeserialize; Type tempCollectionType; if (IsArray) { CollectionItemType = ReflectionUtils.GetCollectionItemType(UnderlyingType); IsReadOnlyOrFixedSize = true; _genericCollectionDefinitionType = typeof(List <>).MakeGenericType(CollectionItemType); canDeserialize = true; IsMultidimensionalArray = (IsArray && UnderlyingType.GetArrayRank() > 1); } else if (typeof(IList).IsAssignableFrom(underlyingType)) { if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(ICollection <>), out _genericCollectionDefinitionType)) { CollectionItemType = _genericCollectionDefinitionType.GetGenericArguments()[0]; } else { CollectionItemType = ReflectionUtils.GetCollectionItemType(underlyingType); } if (underlyingType == typeof(IList)) { CreatedType = typeof(List <object>); } if (CollectionItemType != null) { _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); } IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyCollection <>)); canDeserialize = true; } else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(ICollection <>), out _genericCollectionDefinitionType)) { CollectionItemType = _genericCollectionDefinitionType.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(ICollection <>)) || ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IList <>))) { CreatedType = typeof(List <>).MakeGenericType(CollectionItemType); } #if !(NET20 || NET35) if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(ISet <>))) { CreatedType = typeof(HashSet <>).MakeGenericType(CollectionItemType); } #endif _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); canDeserialize = true; ShouldCreateWrapper = true; } #if !(NET40 || NET35 || NET20 || PORTABLE40) else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IReadOnlyCollection <>), out tempCollectionType)) { CollectionItemType = tempCollectionType.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IReadOnlyCollection <>)) || ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IReadOnlyList <>))) { CreatedType = typeof(ReadOnlyCollection <>).MakeGenericType(CollectionItemType); } _genericCollectionDefinitionType = typeof(List <>).MakeGenericType(CollectionItemType); _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(CreatedType, CollectionItemType); IsReadOnlyOrFixedSize = true; canDeserialize = HasParameterizedCreatorInternal; } #endif else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IEnumerable <>), out tempCollectionType)) { CollectionItemType = tempCollectionType.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IEnumerable <>))) { CreatedType = typeof(List <>).MakeGenericType(CollectionItemType); } _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); #if !(NET35 || NET20) if (!HasParameterizedCreatorInternal && underlyingType.Name == FSharpUtils.FSharpListTypeName) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); _parameterizedCreator = FSharpUtils.CreateSeq(CollectionItemType); } #endif if (underlyingType.IsGenericType() && underlyingType.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { _genericCollectionDefinitionType = tempCollectionType; IsReadOnlyOrFixedSize = false; ShouldCreateWrapper = false; canDeserialize = true; } else { _genericCollectionDefinitionType = typeof(List <>).MakeGenericType(CollectionItemType); IsReadOnlyOrFixedSize = true; ShouldCreateWrapper = true; canDeserialize = HasParameterizedCreatorInternal; } } else { // types that implement IEnumerable and nothing else canDeserialize = false; ShouldCreateWrapper = true; } CanDeserialize = canDeserialize; #if (NET20 || NET35) if (CollectionItemType != null && ReflectionUtils.IsNullableType(CollectionItemType)) { // bug in .NET 2.0 & 3.5 that List<Nullable<T>> throws an error when adding null via IList.Add(object) // wrapper will handle calling Add(T) instead if (ReflectionUtils.InheritsGenericDefinition(CreatedType, typeof(List <>), out tempCollectionType) || (IsArray && !IsMultidimensionalArray)) { ShouldCreateWrapper = true; } } #endif #if !(NET20 || NET35 || NET40) Type immutableCreatedType; ObjectConstructor <object> immutableParameterizedCreator; if (ImmutableCollectionsUtils.TryBuildImmutableForArrayContract(underlyingType, CollectionItemType, out immutableCreatedType, out immutableParameterizedCreator)) { CreatedType = immutableCreatedType; _parameterizedCreator = immutableParameterizedCreator; IsReadOnlyOrFixedSize = true; CanDeserialize = true; } #endif }
public JsonArrayContract(Type underlyingType) : base(underlyingType) { bool hasParameterizedCreatorInternal; base.ContractType = JsonContractType.Array; this.IsArray = base.CreatedType.IsArray; if (this.IsArray) { this.CollectionItemType = ReflectionUtils.GetCollectionItemType(base.UnderlyingType); base.IsReadOnlyOrFixedSize = true; Type[] typeArguments = new Type[] { this.CollectionItemType }; this._genericCollectionDefinitionType = typeof(List <>).MakeGenericType(typeArguments); hasParameterizedCreatorInternal = true; this.IsMultidimensionalArray = this.IsArray && (base.UnderlyingType.GetArrayRank() > 1); } else if (typeof(IList).IsAssignableFrom(underlyingType)) { if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(ICollection <>), out this._genericCollectionDefinitionType)) { this.CollectionItemType = this._genericCollectionDefinitionType.GetGenericArguments()[0]; } else { this.CollectionItemType = ReflectionUtils.GetCollectionItemType(underlyingType); } if (underlyingType == typeof(IList)) { base.CreatedType = typeof(List <object>); } if (this.CollectionItemType != null) { this._parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, this.CollectionItemType); } base.IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyCollection <>)); hasParameterizedCreatorInternal = true; } else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(ICollection <>), out this._genericCollectionDefinitionType)) { this.CollectionItemType = this._genericCollectionDefinitionType.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(ICollection <>)) || ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IList <>))) { Type[] typeArguments = new Type[] { this.CollectionItemType }; base.CreatedType = typeof(List <>).MakeGenericType(typeArguments); } if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(ISet <>))) { Type[] typeArguments = new Type[] { this.CollectionItemType }; base.CreatedType = typeof(HashSet <>).MakeGenericType(typeArguments); } this._parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, this.CollectionItemType); hasParameterizedCreatorInternal = true; this.ShouldCreateWrapper = true; } else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IReadOnlyCollection <>), out Type type)) { this.CollectionItemType = type.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IReadOnlyCollection <>)) || ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IReadOnlyList <>))) { Type[] typeArray4 = new Type[] { this.CollectionItemType }; base.CreatedType = typeof(ReadOnlyCollection <>).MakeGenericType(typeArray4); } Type[] typeArguments = new Type[] { this.CollectionItemType }; this._genericCollectionDefinitionType = typeof(List <>).MakeGenericType(typeArguments); this._parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(base.CreatedType, this.CollectionItemType); base.IsReadOnlyOrFixedSize = true; hasParameterizedCreatorInternal = this.HasParameterizedCreatorInternal; } else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IEnumerable <>), out type)) { this.CollectionItemType = type.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(base.UnderlyingType, typeof(IEnumerable <>))) { Type[] typeArguments = new Type[] { this.CollectionItemType }; base.CreatedType = typeof(List <>).MakeGenericType(typeArguments); } this._parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, this.CollectionItemType); if (!this.HasParameterizedCreatorInternal && (underlyingType.Name == "FSharpList`1")) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); this._parameterizedCreator = FSharpUtils.CreateSeq(this.CollectionItemType); } if (underlyingType.IsGenericType() && (underlyingType.GetGenericTypeDefinition() == typeof(IEnumerable <>))) { this._genericCollectionDefinitionType = type; base.IsReadOnlyOrFixedSize = false; this.ShouldCreateWrapper = false; hasParameterizedCreatorInternal = true; } else { Type[] typeArguments = new Type[] { this.CollectionItemType }; this._genericCollectionDefinitionType = typeof(List <>).MakeGenericType(typeArguments); base.IsReadOnlyOrFixedSize = true; this.ShouldCreateWrapper = true; hasParameterizedCreatorInternal = this.HasParameterizedCreatorInternal; } } else { hasParameterizedCreatorInternal = false; this.ShouldCreateWrapper = true; } this.CanDeserialize = hasParameterizedCreatorInternal; if (ImmutableCollectionsUtils.TryBuildImmutableForArrayContract(underlyingType, this.CollectionItemType, out Type type2, out ObjectConstructor <object> constructor)) { base.CreatedType = type2; this._parameterizedCreator = constructor; base.IsReadOnlyOrFixedSize = true; this.CanDeserialize = true; } }
/// <summary> /// Initializes a new instance of the <see cref="JsonArrayContract"/> class. /// </summary> /// <param name="underlyingType">The underlying type for the contract.</param> public JsonArrayContract(Type underlyingType) : base(underlyingType) { ContractType = JsonContractType.Array; IsArray = CreatedType.IsArray; bool canDeserialize; Type tempCollectionType; if (IsArray) { CollectionItemType = ReflectionUtils.GetCollectionItemType(UnderlyingType); IsReadOnlyOrFixedSize = true; _genericCollectionDefinitionType = typeof(List <>).MakeGenericType(CollectionItemType); canDeserialize = true; IsMultidimensionalArray = (IsArray && UnderlyingType.GetArrayRank() > 1); } else if (typeof(IList).IsAssignableFrom(underlyingType)) { if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(ICollection <>), out _genericCollectionDefinitionType)) { CollectionItemType = _genericCollectionDefinitionType.GetGenericArguments()[0]; } else { CollectionItemType = ReflectionUtils.GetCollectionItemType(underlyingType); } if (underlyingType == typeof(IList)) { CreatedType = typeof(List <object>); } if (CollectionItemType != null) { _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); } IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyCollection <>)); canDeserialize = true; } else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(ICollection <>), out _genericCollectionDefinitionType)) { CollectionItemType = _genericCollectionDefinitionType.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(ICollection <>)) || ReflectionUtils.IsGenericDefinition(underlyingType, typeof(IList <>))) { CreatedType = typeof(List <>).MakeGenericType(CollectionItemType); } if (ReflectionUtils.IsGenericDefinition(underlyingType, typeof(ISet <>))) { CreatedType = typeof(HashSet <>).MakeGenericType(CollectionItemType); } _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); canDeserialize = true; ShouldCreateWrapper = true; } else if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IEnumerable <>), out tempCollectionType)) { CollectionItemType = tempCollectionType.GetGenericArguments()[0]; if (ReflectionUtils.IsGenericDefinition(UnderlyingType, typeof(IEnumerable <>))) { CreatedType = typeof(List <>).MakeGenericType(CollectionItemType); } _parametrizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(underlyingType, CollectionItemType); #if !(NET35 || NET20 || NETFX_CORE) if (!HasParametrizedCreator && underlyingType.Name == FSharpUtils.FSharpListTypeName) { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); _parametrizedCreator = FSharpUtils.CreateSeq(CollectionItemType); } #endif if (underlyingType.IsGenericType() && underlyingType.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { _genericCollectionDefinitionType = tempCollectionType; IsReadOnlyOrFixedSize = false; ShouldCreateWrapper = false; canDeserialize = true; } else { _genericCollectionDefinitionType = typeof(List <>).MakeGenericType(CollectionItemType); IsReadOnlyOrFixedSize = true; ShouldCreateWrapper = true; canDeserialize = HasParametrizedCreator; } } else { // types that implement IEnumerable and nothing else canDeserialize = false; ShouldCreateWrapper = true; } CanDeserialize = canDeserialize; }
public JsonDictionaryContract(Type underlyingType) { Class6.yDnXvgqzyB5jw(); base(underlyingType); Type genericArguments; Type type; Type type1; ObjectConstructor <object> objectConstructor; this.ContractType = JsonContractType.Dictionary; if (ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IDictionary <,>), out this._genericCollectionDefinitionType)) { genericArguments = this._genericCollectionDefinitionType.GetGenericArguments()[0]; type = this._genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(base.UnderlyingType, typeof(IDictionary <,>))) { base.CreatedType = typeof(Dictionary <,>).MakeGenericType(new Type[] { genericArguments, type }); } else if (underlyingType.IsGenericType() && underlyingType.GetGenericTypeDefinition().FullName == "System.Collections.Concurrent.ConcurrentDictionary`2") { this.ShouldCreateWrapper = true; } this.IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(underlyingType, typeof(ReadOnlyDictionary <,>)); } else if (!ReflectionUtils.ImplementsGenericDefinition(underlyingType, typeof(IReadOnlyDictionary <,>), out this._genericCollectionDefinitionType)) { ReflectionUtils.GetDictionaryKeyValueTypes(base.UnderlyingType, out genericArguments, out type); if (base.UnderlyingType == typeof(IDictionary)) { base.CreatedType = typeof(Dictionary <object, object>); } } else { genericArguments = this._genericCollectionDefinitionType.GetGenericArguments()[0]; type = this._genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(base.UnderlyingType, typeof(IReadOnlyDictionary <,>))) { base.CreatedType = typeof(ReadOnlyDictionary <,>).MakeGenericType(new Type[] { genericArguments, type }); } this.IsReadOnlyOrFixedSize = true; } if (genericArguments != null && type != null) { this._parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor(base.CreatedType, typeof(KeyValuePair <,>).MakeGenericType(new Type[] { genericArguments, type }), typeof(IDictionary <,>).MakeGenericType(new Type[] { genericArguments, type })); if (!this.HasParameterizedCreatorInternal && underlyingType.Name == "FSharpMap`2") { FSharpUtils.EnsureInitialized(underlyingType.Assembly()); this._parameterizedCreator = FSharpUtils.CreateMap(genericArguments, type); } } if (!typeof(IDictionary).IsAssignableFrom(base.CreatedType)) { this.ShouldCreateWrapper = true; } this.DictionaryKeyType = genericArguments; this.DictionaryValueType = type; if (ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract(underlyingType, this.DictionaryKeyType, this.DictionaryValueType, out type1, out objectConstructor)) { base.CreatedType = type1; this._parameterizedCreator = objectConstructor; this.IsReadOnlyOrFixedSize = true; } }
public JsonDictionaryContract(Type underlyingType) : base(underlyingType) { ContractType = JsonContractType.Dictionary; Type?keyType; Type?valueType; if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(IDictionary <,>), out _genericCollectionDefinitionType)) { keyType = _genericCollectionDefinitionType.GetGenericArguments()[0]; valueType = _genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(IDictionary <,>))) { CreatedType = typeof(Dictionary <,>).MakeGenericType(keyType, valueType); } else if (NonNullableUnderlyingType.IsGenericType()) { // ConcurrentDictionary<,> + IDictionary setter + null value = error // wrap to use generic setter // https://github.com/JamesNK/Newtonsoft.Json/issues/1582 var typeDefinition = NonNullableUnderlyingType.GetGenericTypeDefinition(); if (typeDefinition.FullName == JsonTypeReflector.ConcurrentDictionaryTypeName) { ShouldCreateWrapper = true; } } #if HAVE_READ_ONLY_COLLECTIONS IsReadOnlyOrFixedSize = ReflectionUtils.InheritsGenericDefinition(NonNullableUnderlyingType, typeof(ReadOnlyDictionary <,>)); #endif } #if HAVE_READ_ONLY_COLLECTIONS else if (ReflectionUtils.ImplementsGenericDefinition(NonNullableUnderlyingType, typeof(IReadOnlyDictionary <,>), out _genericCollectionDefinitionType)) { keyType = _genericCollectionDefinitionType.GetGenericArguments()[0]; valueType = _genericCollectionDefinitionType.GetGenericArguments()[1]; if (ReflectionUtils.IsGenericDefinition(NonNullableUnderlyingType, typeof(IReadOnlyDictionary <,>))) { CreatedType = typeof(ReadOnlyDictionary <,>).MakeGenericType(keyType, valueType); } IsReadOnlyOrFixedSize = true; } #endif else { ReflectionUtils.GetDictionaryKeyValueTypes(NonNullableUnderlyingType, out keyType, out valueType); if (NonNullableUnderlyingType == typeof(IDictionary)) { CreatedType = typeof(Dictionary <object, object>); } } if (keyType != null && valueType != null) { _parameterizedConstructor = CollectionUtils.ResolveEnumerableCollectionConstructor( CreatedType, typeof(KeyValuePair <,>).MakeGenericType(keyType, valueType), typeof(IDictionary <,>).MakeGenericType(keyType, valueType)); #if HAVE_FSHARP_TYPES if (!HasParameterizedCreatorInternal && NonNullableUnderlyingType.Name == FSharpUtils.FSharpMapTypeName) { FSharpUtils.EnsureInitialized(NonNullableUnderlyingType.Assembly()); _parameterizedCreator = FSharpUtils.Instance.CreateMap(keyType, valueType); } #endif } if (!typeof(IDictionary).IsAssignableFrom(CreatedType)) { ShouldCreateWrapper = true; } DictionaryKeyType = keyType; DictionaryValueType = valueType; #if (NET20 || NET35) if (DictionaryValueType != null && ReflectionUtils.IsNullableType(DictionaryValueType)) { // bug in .NET 2.0 & 3.5 that Dictionary<TKey, Nullable<TValue>> throws an error when adding null via IDictionary[key] = object // wrapper will handle calling Add(T) instead if (ReflectionUtils.InheritsGenericDefinition(CreatedType, typeof(Dictionary <,>), out _)) { ShouldCreateWrapper = true; } } #endif if (DictionaryKeyType != null && DictionaryValueType != null && ImmutableCollectionsUtils.TryBuildImmutableForDictionaryContract( NonNullableUnderlyingType, DictionaryKeyType, DictionaryValueType, out var immutableCreatedType, out var immutableParameterizedCreator)) { CreatedType = immutableCreatedType; _parameterizedCreator = immutableParameterizedCreator; IsReadOnlyOrFixedSize = true; } }