IsCollectionOrTryCreate()

static bool System.Runtime.Serialization.CollectionDataContract.IsCollectionOrTryCreate ( Type type, bool tryCreate, out DataContract dataContract, out Type itemType, bool constructorRequired )

inlinestaticprivate

Definition at line 1110 of file CollectionDataContract.cs.

    {
        dataContract = null;
        itemType = Globals.TypeOfObject;
        if (DataContract.GetBuiltInDataContract(type) != null)
        {
            return HandleIfInvalidCollection(type, tryCreate, hasCollectionDataContract: false, createContractWithException: false, System.SR.CollectionTypeCannotBeBuiltIn, null, ref dataContract);
        }
        bool hasCollectionDataContract = IsCollectionDataContract(type);
        bool flag = false;
        string deserializationExceptionMessage = null;
        Type baseType = type.BaseType;
        bool createContractWithException = baseType != null && baseType != Globals.TypeOfObject && baseType != Globals.TypeOfValueType && baseType != Globals.TypeOfUri && IsCollection(baseType) && !type.IsSerializable;
        if (type.IsDefined(Globals.TypeOfDataContractAttribute, inherit: false))
        {
            return HandleIfInvalidCollection(type, tryCreate, hasCollectionDataContract, createContractWithException, System.SR.CollectionTypeCannotHaveDataContract, null, ref dataContract);
        }
        if (Globals.TypeOfIXmlSerializable.IsAssignableFrom(type) || IsArraySegment(type))
        {
            return false;
        }
        if (!Globals.TypeOfIEnumerable.IsAssignableFrom(type))
        {
            return HandleIfInvalidCollection(type, tryCreate, hasCollectionDataContract, createContractWithException, System.SR.CollectionTypeIsNotIEnumerable, null, ref dataContract);
        }
        MethodInfo method;
        MethodInfo addMethod;
        if (type.IsInterface)
        {
            Type type2 = (type.IsGenericType ? type.GetGenericTypeDefinition() : type);
            Type[] knownInterfaces = KnownInterfaces;
            for (int i = 0; i < knownInterfaces.Length; i++)
            {
                if (!(knownInterfaces[i] == type2))
                {
                    continue;
                }
                addMethod = null;
                if (type.IsGenericType)
                {
                    Type[] genericArguments = type.GetGenericArguments();
                    if (type2 == Globals.TypeOfIDictionaryGeneric)
                    {
                        itemType = Globals.TypeOfKeyValue.MakeGenericType(genericArguments);
                        addMethod = type.GetMethod("Add");
                        method = Globals.TypeOfIEnumerableGeneric.MakeGenericType(Globals.TypeOfKeyValuePair.MakeGenericType(genericArguments)).GetMethod("GetEnumerator");
                    }
                    else
                    {
                        itemType = genericArguments[0];
                        if (type2 == Globals.TypeOfICollectionGeneric || type2 == Globals.TypeOfIListGeneric)
                        {
                            addMethod = Globals.TypeOfICollectionGeneric.MakeGenericType(itemType).GetMethod("Add");
                        }
                        method = Globals.TypeOfIEnumerableGeneric.MakeGenericType(itemType).GetMethod("GetEnumerator");
                    }
                }
                else
                {
                    if (type2 == Globals.TypeOfIDictionary)
                    {
                        itemType = typeof(KeyValue<object, object>);
                        addMethod = type.GetMethod("Add");
                    }
                    else
                    {
                        itemType = Globals.TypeOfObject;
                        if (type2 == Globals.TypeOfIList)
                        {
                            addMethod = type.GetMethod("Add");
                        }
                    }
                    method = typeof(IEnumerable).GetMethod("GetEnumerator");
                }
                if (tryCreate)
                {
                    dataContract = new CollectionDataContract(type, (CollectionKind)(i + 1), itemType, method, addMethod, null);
                }
                return true;
            }
        }
        ConstructorInfo constructorInfo = null;
        if (!type.IsValueType)
        {
            constructorInfo = type.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, Type.EmptyTypes);
            if (constructorInfo == null && constructorRequired)
            {
                if (type.IsSerializable)
                {
                    return HandleIfInvalidCollection(type, tryCreate, hasCollectionDataContract, createContractWithException, System.SR.CollectionTypeDoesNotHaveDefaultCtor, null, ref dataContract);
                }
                flag = true;
                GetReadOnlyCollectionExceptionMessages(type, System.SR.CollectionTypeDoesNotHaveDefaultCtor, null, out deserializationExceptionMessage);
            }
        }
        Type type3 = null;
        CollectionKind collectionKind = CollectionKind.None;
        bool flag2 = false;
        Type[] interfaces = type.GetInterfaces();
        Type[] array = interfaces;
        foreach (Type type4 in array)
        {
            Type type5 = (type4.IsGenericType ? type4.GetGenericTypeDefinition() : type4);
            Type[] knownInterfaces2 = KnownInterfaces;
            for (int k = 0; k < knownInterfaces2.Length; k++)
            {
                if (knownInterfaces2[k] == type5)
                {
                    CollectionKind collectionKind2 = (CollectionKind)(k + 1);
                    if (collectionKind == CollectionKind.None || (int)collectionKind2 < (int)collectionKind)
                    {
                        collectionKind = collectionKind2;
                        type3 = type4;
                        flag2 = false;
                    }
                    else if ((collectionKind & collectionKind2) == collectionKind2)
                    {
                        flag2 = true;
                    }
                    break;
                }
            }
        }
        switch (collectionKind)
        {
        case CollectionKind.None:
            return HandleIfInvalidCollection(type, tryCreate, hasCollectionDataContract, createContractWithException, System.SR.CollectionTypeIsNotIEnumerable, null, ref dataContract);
        case CollectionKind.GenericEnumerable:
        case CollectionKind.Collection:
        case CollectionKind.Enumerable:
            if (flag2)
            {
                type3 = Globals.TypeOfIEnumerable;
            }
            itemType = (type3.IsGenericType ? type3.GetGenericArguments()[0] : Globals.TypeOfObject);
            GetCollectionMethods(type, type3, new Type[1] { itemType }, addMethodOnInterface: false, out method, out addMethod);
            if (addMethod == null)
            {
                if (type.IsSerializable)
                {
                    return HandleIfInvalidCollection(type, tryCreate, hasCollectionDataContract, createContractWithException, System.SR.CollectionTypeDoesNotHaveAddMethod, DataContract.GetClrTypeFullName(itemType), ref dataContract);
                }
                flag = true;
                GetReadOnlyCollectionExceptionMessages(type, System.SR.CollectionTypeDoesNotHaveAddMethod, DataContract.GetClrTypeFullName(itemType), out deserializationExceptionMessage);
            }
            if (tryCreate)
            {
                dataContract = (flag ? new CollectionDataContract(type, collectionKind, itemType, method, deserializationExceptionMessage) : new CollectionDataContract(type, collectionKind, itemType, method, addMethod, constructorInfo, !constructorRequired));
            }
            break;
        default:
        {
            if (flag2)
            {
                return HandleIfInvalidCollection(type, tryCreate, hasCollectionDataContract, createContractWithException, System.SR.CollectionTypeHasMultipleDefinitionsOfInterface, KnownInterfaces[(uint)(collectionKind - 1)].Name, ref dataContract);
            }
            Type[] array2 = null;
            switch (collectionKind)
            {
            case CollectionKind.GenericDictionary:
            {
                array2 = type3.GetGenericArguments();
                bool flag3 = type3.IsGenericTypeDefinition || (array2[0].IsGenericParameter && array2[1].IsGenericParameter);
                itemType = (flag3 ? Globals.TypeOfKeyValue : Globals.TypeOfKeyValue.MakeGenericType(array2));
                break;
            }
            case CollectionKind.Dictionary:
                array2 = new Type[2]
                {
                    Globals.TypeOfObject,
                    Globals.TypeOfObject
                };
                itemType = Globals.TypeOfKeyValue.MakeGenericType(array2);
                break;
            case CollectionKind.GenericList:
            case CollectionKind.GenericCollection:
                array2 = type3.GetGenericArguments();
                itemType = array2[0];
                break;
            case CollectionKind.List:
                itemType = Globals.TypeOfObject;
                array2 = new Type[1] { itemType };
                break;
            }
            if (tryCreate)
            {
                GetCollectionMethods(type, type3, array2, addMethodOnInterface: true, out method, out addMethod);
                dataContract = (flag ? new CollectionDataContract(type, collectionKind, itemType, method, deserializationExceptionMessage) : new CollectionDataContract(type, collectionKind, itemType, method, addMethod, constructorInfo, !constructorRequired));
            }
            break;
        }
        }
        return true;
    }

References System.Runtime.Serialization.CollectionDataContract.CollectionDataContract(), System.Collections.Generic.Dictionary< TKey, TValue >.Dictionary(), System.array, System.SR.CollectionTypeCannotBeBuiltIn, System.SR.CollectionTypeCannotHaveDataContract, System.SR.CollectionTypeDoesNotHaveAddMethod, System.SR.CollectionTypeDoesNotHaveDefaultCtor, System.SR.CollectionTypeHasMultipleDefinitionsOfInterface, System.SR.CollectionTypeIsNotIEnumerable, System.Runtime.Serialization.Dictionary, System.Type.EmptyTypes, System.Runtime.Serialization.DataContract.GetBuiltInDataContract(), System.Runtime.Serialization.DataContract.GetClrTypeFullName(), System.Runtime.Serialization.CollectionDataContract.GetCollectionMethods(), System.Type.GetInterfaces(), System.Runtime.Serialization.CollectionDataContract.GetReadOnlyCollectionExceptionMessages(), System.Runtime.Serialization.CollectionDataContract.HandleIfInvalidCollection(), System.Runtime.Serialization.CollectionDataContract.IsArraySegment(), System.Runtime.Serialization.CollectionDataContract.IsCollection(), System.Runtime.Serialization.CollectionDataContract.IsCollectionDataContract(), System.Runtime.Serialization.CollectionDataContract.KnownInterfaces, System.type, System.Runtime.Serialization.Globals.TypeOfDataContractAttribute, System.Runtime.Serialization.Globals.TypeOfICollectionGeneric, System.Runtime.Serialization.Globals.TypeOfIDictionary, System.Runtime.Serialization.Globals.TypeOfIDictionaryGeneric, System.Runtime.Serialization.Globals.TypeOfIEnumerable, System.Runtime.Serialization.Globals.TypeOfIEnumerableGeneric, System.Runtime.Serialization.Globals.TypeOfIList, System.Runtime.Serialization.Globals.TypeOfIListGeneric, System.Runtime.Serialization.Globals.TypeOfIXmlSerializable, System.Runtime.Serialization.Globals.TypeOfKeyValue, System.Runtime.Serialization.Globals.TypeOfKeyValuePair, and System.Runtime.Serialization.Globals.TypeOfObject.

Referenced by System.Runtime.Serialization.CollectionDataContract.CreateGetOnlyCollectionDataContract(), System.Runtime.Serialization.CollectionDataContract.IsCollectionHelper(), System.Runtime.Serialization.CollectionDataContract.TryCreate(), and System.Runtime.Serialization.CollectionDataContract.TryCreateGetOnlyCollectionDataContract().