public bool TryGetMessage <T>(out ConsumeContext <T> message)
where T : class
{
lock (_messageTypes)
{
object existing;
if (_messageTypes.TryGetValue(typeof(T), out existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
if (typeof(T) == typeof(JToken))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, _messageToken as T);
return(true);
}
string typeUrn = new MessageUrn(typeof(T)).ToString();
if (_supportedTypes.Any(typeUrn.Equals))
{
object obj;
Type deserializeType = typeof(T);
if (deserializeType.IsInterface && TypeMetadataCache.IsValidMessageType(deserializeType))
{
deserializeType = TypeMetadataCache.GetImplementationType(deserializeType);
}
using (JsonReader jsonReader = _messageToken.CreateReader())
{
obj = _deserializer.Deserialize(jsonReader, deserializeType);
}
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
public void Should_be_able_to_suck_out_an_interface()
{
Envelope result;
using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(_body), false))
using (var reader = new StreamReader(memoryStream))
using (var jsonReader = new JsonTextReader(reader))
{
result = _deserializer.Deserialize <Envelope>(jsonReader);
}
using (var jsonReader = new JTokenReader(result.Message as JToken))
{
Type proxyType = TypeMetadataCache.GetImplementationType(typeof(MessageA));
var message = (MessageA)Activator.CreateInstance(proxyType);
_serializer.Populate(jsonReader, message);
message.Name.ShouldBe("Joe");
}
}
public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
{
var typeInfo = typeToConvert.GetTypeInfo();
if (_converterFactory.TryGetValue(typeInfo, out Func <JsonConverter> converterFactory))
{
return(converterFactory());
}
if (typeInfo.IsGenericType && !typeInfo.IsGenericTypeDefinition)
{
var interfaceType = typeInfo.GetGenericTypeDefinition();
if (_openTypeFactory.TryGetValue(interfaceType, out var concreteType))
{
Type[] arguments = typeInfo.GetGenericArguments();
if (arguments.Length == 1 && !arguments[0].IsGenericParameter)
{
interfaceType = interfaceType.MakeGenericType(arguments[0]);
concreteType = concreteType.MakeGenericType(arguments[0]);
return((JsonConverter)Activator.CreateInstance(typeof(TypeMappingJsonConverter <,>).MakeGenericType(interfaceType, concreteType)));
}
}
}
if (typeToConvert.IsInterfaceOrConcreteClass() && TypeMetadataCache.IsValidMessageType(typeToConvert) && !typeToConvert.IsValueTypeOrObject())
{
return((JsonConverter)Activator.CreateInstance(
typeof(InterfaceJsonConverter <,>).MakeGenericType(typeToConvert, TypeMetadataCache.GetImplementationType(typeToConvert))));
}
throw new MassTransitException($"Unsupported type for json serialization {TypeMetadataCache.GetShortName(typeInfo)}");
}
