/// <summary> /// Gets the serializer for the specified <see cref="Type"/>. /// </summary> /// <param name="targetType">Type of the serialization target.</param> /// <param name="providerParameter">A provider specific parameter. See remarks section of <see cref="GetSerializer{T}(Object)"/> for details.</param> /// <returns> /// <see cref="MessagePackSerializer"/>. /// If there is exiting one, returns it. /// Else the new instance will be created. /// If the platform supports async/await programming model, return type is <c>IAsyncMessagePackSingleObjectSerializer</c>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="targetType"/> is <c>null</c>. /// </exception> /// <remarks> /// Although <see cref="GetSerializer{T}(Object)"/> is preferred, /// this method can be used from non-generic type or methods. /// </remarks> public MessagePackSerializer GetSerializer( Type targetType, object providerParameter ) { if ( targetType == null ) { throw new ArgumentNullException( "targetType" ); } #if DEBUG Contract.Ensures( Contract.Result<MessagePackSerializer>() != null ); #endif // DEBUG #if UNITY try { #endif // UNITY return SerializerGetter.Instance.Get( this, targetType, providerParameter ); #if UNITY } catch ( Exception ex ) { AotHelper.HandleAotError( targetType, ex ); throw; } #endif // UNITY }
public object Get(SerializationContext context, Type keyType) { object matched; object genericDefinitionMatched; if (!this.Get(keyType, out matched, out genericDefinitionMatched)) { return(null); } if (matched != null) { return(matched); } else { #if DEBUG Contract.Assert(keyType.GetIsGenericType(), "keyType.GetIsGenericType()"); Contract.Assert(!keyType.GetIsGenericTypeDefinition(), "!keyType.GetIsGenericTypeDefinition()"); #endif // DEBUG var type = genericDefinitionMatched as Type; #if DEBUG Contract.Assert(type != null, "type != null"); Contract.Assert(type.GetIsGenericTypeDefinition(), "type.GetIsGenericTypeDefinition()"); #endif // DEBUG #if !UNITY var result = ReflectionExtensions.CreateInstancePreservingExceptionType( type.MakeGenericType(keyType.GetGenericArguments()), context ); #else var resultType = type.IsGenericTypeDefinition ? type.MakeGenericType(keyType.GetGenericArguments()) : type; var constructor2 = resultType.GetConstructor(NonGenericSerializerConstructorParameterTypes); object result; try { result = constructor2 == null ? ReflectionExtensions.CreateInstancePreservingExceptionType(resultType, context) : ReflectionExtensions.CreateInstancePreservingExceptionType(resultType, context, keyType); } catch (Exception ex) { AotHelper.HandleAotError(keyType, ex); throw; } #endif // !UNITY Contract.Assert(result != null, "result != null"); return(result); } }