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())); } } }