public StreamingHubHandler(Type classType, MethodInfo methodInfo, StreamingHubHandlerOptions handlerOptions, IServiceProvider serviceProvider)
{
var hubInterface = classType.GetInterfaces().First(x => x.GetTypeInfo().IsGenericType&& x.GetGenericTypeDefinition() == typeof(IStreamingHub <,>)).GetGenericArguments()[0];
var interfaceMethod = GetInterfaceMethod(classType, hubInterface, methodInfo.Name);
this.serviceProvider = serviceProvider;
this.HubType = classType;
this.HubName = hubInterface.Name;
this.MethodInfo = methodInfo;
// Validation for Id
if (methodInfo.GetCustomAttribute <MethodIdAttribute>() != null)
{
throw new InvalidOperationException($"Hub Implementation can not add [MethodId], you should add hub `interface`. {classType.Name}/{methodInfo.Name}");
}
this.MethodId = interfaceMethod.GetCustomAttribute <MethodIdAttribute>()?.MethodId ?? FNV1A32.GetHashCode(interfaceMethod.Name);
this.UnwrappedResponseType = UnwrapResponseType(methodInfo);
var resolver = handlerOptions.SerializerOptions.Resolver;
var parameters = methodInfo.GetParameters();
this.RequestType = MagicOnionMarshallers.CreateRequestTypeAndSetResolver(classType.Name + "/" + methodInfo.Name, parameters, ref resolver);
this.serializerOptions = handlerOptions.SerializerOptions.WithResolver(resolver);
this.AttributeLookup = classType.GetCustomAttributes(true)
.Concat(methodInfo.GetCustomAttributes(true))
.Cast <Attribute>()
.ToLookup(x => x.GetType());
this.filters = handlerOptions.GlobalStreamingHubFilters
.OfType <IMagicOnionFilterFactory <StreamingHubFilterAttribute> >()
.Concat(classType.GetCustomAttributes <StreamingHubFilterAttribute>(true).Select(x => new StreamingHubFilterDescriptor(x, x.Order)))
.Concat(classType.GetCustomAttributes(true).OfType <IMagicOnionFilterFactory <StreamingHubFilterAttribute> >())
.Concat(methodInfo.GetCustomAttributes <StreamingHubFilterAttribute>(true).Select(x => new StreamingHubFilterDescriptor(x, x.Order)))
.Concat(methodInfo.GetCustomAttributes(true).OfType <IMagicOnionFilterFactory <StreamingHubFilterAttribute> >())
.OrderBy(x => x.Order)
.ToArray();
// validation filter
if (methodInfo.GetCustomAttribute <MagicOnionFilterAttribute>(true) != null)
{
throw new InvalidOperationException($"StreamingHub method can not add [MagicOnionFilter], you should add [StreamingHubFilter]. {classType.Name}/{methodInfo.Name}");
}
this.toStringCache = HubName + "/" + MethodInfo.Name;
this.getHashCodeCache = HubName.GetHashCode() ^ MethodInfo.Name.GetHashCode() << 2;
// ValueTask (StreamingHubContext context) =>
// {
// T request = LZ4MessagePackSerializer.Deserialize<T>(context.Request, context.FormatterResolver);
// Task<T> result = ((HubType)context.HubInstance).Foo(request);
// return WriteInAsyncLockInTaskWithMessageId(result) || return new ValueTask(result)
// }
try
{
var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var contextArg = Expression.Parameter(typeof(StreamingHubContext), "context");
var requestArg = Expression.Parameter(RequestType, "request");
var getSerializerOptions = Expression.Property(contextArg, typeof(StreamingHubContext).GetProperty("SerializerOptions", flags) !);
var contextRequest = Expression.Property(contextArg, typeof(StreamingHubContext).GetProperty("Request", flags) !);
var noneCancellation = Expression.Default(typeof(CancellationToken));
var getInstanceCast = Expression.Convert(Expression.Property(contextArg, typeof(StreamingHubContext).GetProperty("HubInstance", flags) !), HubType);
var callDeserialize = Expression.Call(messagePackDeserialize.MakeGenericMethod(RequestType), contextRequest, getSerializerOptions, noneCancellation);
var assignRequest = Expression.Assign(requestArg, callDeserialize);
Expression[] arguments = new Expression[parameters.Length];
if (parameters.Length == 1)
{
arguments[0] = requestArg;
}
else
{
for (int i = 0; i < parameters.Length; i++)
{
arguments[i] = Expression.Field(requestArg, "Item" + (i + 1));
}
}
var callBody = Expression.Call(getInstanceCast, methodInfo, arguments);
var finalMethod = (methodInfo.ReturnType.IsGenericType)
? typeof(StreamingHubContext).GetMethod(nameof(StreamingHubContext.WriteResponseMessage), flags) !.MakeGenericMethod(UnwrappedResponseType !)
: typeof(StreamingHubContext).GetMethod(nameof(StreamingHubContext.WriteResponseMessageNil), flags) !;
callBody = Expression.Call(contextArg, finalMethod, callBody);
var body = Expression.Block(new[] { requestArg }, assignRequest, callBody);
var compiledBody = Expression.Lambda(body, contextArg).Compile();
this.MethodBody = BuildMethodBodyWithFilter((Func <StreamingHubContext, ValueTask>)compiledBody);
}
catch (Exception ex)
{
throw new InvalidOperationException($"Can't create handler. Path:{ToString()}", ex);
}
}
public MethodHandler(MagicOnionOptions options, Type classType, MethodInfo methodInfo)
{
this.ServiceType = classType;
this.ServiceName = classType.GetInterfaces().First(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IService <>)).GetGenericArguments()[0].Name;
this.MethodInfo = methodInfo;
MethodType mt;
this.UnwrappedResponseType = UnwrapResponseType(methodInfo, out mt, out responseIsTask, out this.RequestType);
this.MethodType = mt;
this.resolver = options.FormatterResolver;
var parameters = methodInfo.GetParameters();
if (RequestType == null)
{
this.RequestType = MagicOnionMarshallers.CreateRequestTypeAndSetResolver(classType.Name + "/" + methodInfo.Name, parameters, ref resolver);
}
this.AttributeLookup = classType.GetCustomAttributes(true)
.Concat(methodInfo.GetCustomAttributes(true))
.Cast <Attribute>()
.ToLookup(x => x.GetType());
this.filters = options.GlobalFilters
.Concat(classType.GetCustomAttributes <MagicOnionFilterAttribute>(true))
.Concat(methodInfo.GetCustomAttributes <MagicOnionFilterAttribute>(true))
.OrderBy(x => x.Order)
.ToArray();
// options
this.isReturnExceptionStackTraceInErrorDetail = options.IsReturnExceptionStackTraceInErrorDetail;
this.logger = options.MagicOnionLogger;
// prepare lambda parameters
var contextArg = Expression.Parameter(typeof(ServiceContext), "context");
var contextBind = Expression.Bind(classType.GetProperty("Context"), contextArg);
var instance = Expression.MemberInit(Expression.New(classType), contextBind);
switch (MethodType)
{
case MethodType.Unary:
case MethodType.ServerStreaming:
// (ServiceContext context) =>
// {
// var request = LZ4MessagePackSerializer.Deserialize<T>(context.Request, context.Resolver);
// var result = new FooService() { Context = context }.Bar(request.Item1, request.Item2);
// return MethodHandlerResultHelper.SerializeUnaryResult(result, context);
// };
try
{
var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var staticFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
var requestArg = Expression.Parameter(RequestType, "request");
var getResolver = Expression.Property(contextArg, typeof(ServiceContext).GetProperty("FormatterResolver", flags));
var contextRequest = Expression.Property(contextArg, typeof(ServiceContext).GetProperty("Request", flags));
var callDeserialize = Expression.Call(messagePackDeserialize.MakeGenericMethod(RequestType), contextRequest, getResolver);
var assignRequest = Expression.Assign(requestArg, callDeserialize);
Expression[] arguments = new Expression[parameters.Length];
if (parameters.Length == 1)
{
arguments[0] = requestArg;
}
else
{
for (int i = 0; i < parameters.Length; i++)
{
arguments[i] = Expression.Field(requestArg, "Item" + (i + 1));
}
}
var callBody = Expression.Call(instance, methodInfo, arguments);
if (MethodType == MethodType.Unary)
{
var finalMethod = (responseIsTask)
? typeof(MethodHandlerResultHelper).GetMethod("SerializeTaskUnaryResult", staticFlags).MakeGenericMethod(UnwrappedResponseType)
: typeof(MethodHandlerResultHelper).GetMethod("SerializeUnaryResult", staticFlags).MakeGenericMethod(UnwrappedResponseType);
callBody = Expression.Call(finalMethod, callBody, contextArg);
}
else
{
if (!responseIsTask)
{
callBody = Expression.Call(typeof(Task).GetMethod("FromResult").MakeGenericMethod(MethodInfo.ReturnType), callBody);
}
}
var body = Expression.Block(new[] { requestArg }, assignRequest, callBody);
var compiledBody = Expression.Lambda(body, contextArg).Compile();
this.methodBody = BuildMethodBodyWithFilter((Func <ServiceContext, Task>)compiledBody);
}
catch (Exception ex)
{
throw new InvalidOperationException($"Can't create handler. Path:{ToString()}", ex);
}
break;
case MethodType.ClientStreaming:
case MethodType.DuplexStreaming:
if (parameters.Length != 0)
{
throw new InvalidOperationException($"{MethodType} does not support method parameters. If you need to send initial parameter, use header instead. Path:{ToString()}");
}
// (ServiceContext context) => new FooService() { Context = context }.Bar();
try
{
var body = Expression.Call(instance, methodInfo);
if (MethodType == MethodType.ClientStreaming)
{
var staticFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
var finalMethod = (responseIsTask)
? typeof(MethodHandlerResultHelper).GetMethod("SerializeTaskClientStreamingResult", staticFlags).MakeGenericMethod(RequestType, UnwrappedResponseType)
: typeof(MethodHandlerResultHelper).GetMethod("SerializeClientStreamingResult", staticFlags).MakeGenericMethod(RequestType, UnwrappedResponseType);
body = Expression.Call(finalMethod, body, contextArg);
}
else
{
if (!responseIsTask)
{
body = Expression.Call(typeof(Task).GetMethod("FromResult").MakeGenericMethod(MethodInfo.ReturnType), body);
}
}
var compiledBody = Expression.Lambda(body, contextArg).Compile();
this.methodBody = BuildMethodBodyWithFilter((Func <ServiceContext, Task>)compiledBody);
}
catch (Exception ex)
{
throw new InvalidOperationException($"Can't create handler. Path:{ToString()}", ex);
}
break;
default:
throw new InvalidOperationException("Unknown MethodType:" + MethodType + $"Path:{ToString()}");
}
}