Exemple #1
0
            public IEnumerable <SerializerCodeGenerationResult> Generate(IEnumerable <Type> targetTypes, TConfig configuration)
            {
                if (targetTypes == null)
                {
                    throw new ArgumentNullException("targetTypes");
                }

                if (configuration == null)
                {
                    throw new ArgumentNullException("configuration");
                }

                configuration.Validate();
                var context =
                    new SerializationContext
                {
                    SerializationMethod = configuration.SerializationMethod,
                    SerializerOptions   =
                    {
#if FEATURE_TAP
                        WithAsync       = configuration.WithAsync,
#endif // FEATURE_TAP
                        GeneratorOption = SerializationMethodGeneratorOption.CanDump,
                        EmitterFlavor   = this.EmitterFlavor
                    },
                    EnumSerializationOptions =
                    {
                        SerializationMethod = configuration.EnumSerializationMethod
                    },
                    CompatibilityOptions =
                    {
                        AllowNonCollectionEnumerableTypes = configuration.CompatibilityOptions.AllowNonCollectionEnumerableTypes,
                        IgnorePackabilityForCollection    = configuration.CompatibilityOptions.IgnorePackabilityForCollection,
                        OneBoundDataMemberOrder           = configuration.CompatibilityOptions.OneBoundDataMemberOrder,
                        PackerCompatibilityOptions        = configuration.CompatibilityOptions.PackerCompatibilityOptions
                    }
                };

                IEnumerable <Type> realTargetTypes;

                if (configuration.IsRecursive)
                {
                    realTargetTypes =
                        targetTypes
                        .SelectMany(t => ExtractElementTypes(context, configuration, t));
                }
                else
                {
                    realTargetTypes =
                        targetTypes
                        .Where(t => !SerializationTarget.BuiltInSerializerExists(configuration, t, t.GetCollectionTraits(CollectionTraitOptions.None, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes)));
                }

                var generationContext = this.CreateGenerationContext(context, configuration);
                var generatorFactory  = this.CreateGeneratorFactory(context);

                foreach (var targetType in realTargetTypes.Distinct())
                {
                    var generator = generatorFactory(targetType);

                    var concreteType = default(Type);
                    if (targetType.GetIsInterface() || targetType.GetIsAbstract())
                    {
                        concreteType = context.DefaultCollectionTypes.GetConcreteType(targetType);
                    }

                    generator.BuildSerializerCode(generationContext, concreteType, null);
                }

                Directory.CreateDirectory(configuration.OutputDirectory);

                return(generationContext.Generate());
            }
        internal static MessagePackSerializer <T> CreateReflectionInternal <T>(SerializationContext context, Type concreteType, PolymorphismSchema schema)
        {
            if (concreteType.GetIsAbstract() || concreteType.GetIsInterface())
            {
                // return null for polymoirphic provider.
                return(null);
            }

            var serializer = context.Serializers.Get <T>(context);

            if (serializer != null)
            {
                // For MessagePack.Create compatibility.
                // Required for built-in types.
                return(serializer);
            }

            ValidateType(typeof(T));
            var traits =
#if !UNITY
                typeof(T).GetCollectionTraits(CollectionTraitOptions.WithAddMethod, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#else
                typeof(T).GetCollectionTraits(CollectionTraitOptions.WithAddMethod | CollectionTraitOptions.WithCountPropertyGetter, context.CompatibilityOptions.AllowNonCollectionEnumerableTypes);
#endif
            switch (traits.CollectionType)
            {
            case CollectionKind.Array:
            case CollectionKind.Map:
            {
                return
                    (#if !UNITY
                     ReflectionSerializerHelper.CreateCollectionSerializer <T>(context, concreteType, traits, (schema ?? PolymorphismSchema.Default)));
#else
                     Wrap <T>(
                         context,
                         ReflectionSerializerHelper.CreateCollectionSerializer <T>(context, concreteType, traits, (schema ?? PolymorphismSchema.Default))
                         );
#endif // !UNITY
            }

            default:
            {
                if (typeof(T).GetIsEnum())
                {
                    return(ReflectionSerializerHelper.CreateReflectionEnumMessagePackSerializer <T>(context));
                }
#if !NETFX_35 && !UNITY
                if (TupleItems.IsTuple(typeof(T)))
                {
                    return
                        (new ReflectionTupleMessagePackSerializer <T>(
                             context,
                             (schema ?? PolymorphismSchema.Default).ChildSchemaList
                             ));
                }
#endif // !NETFX_35 && !UNITY

                SerializationTarget.VerifyType(typeof(T));
                var target = SerializationTarget.Prepare(context, typeof(T));
                return(new ReflectionObjectMessagePackSerializer <T>(context, target, target.GetCapabilitiesForObject()));
            }
            }
        }