| | | 1 | | using System.Linq.Expressions; |
| | | 2 | | |
| | | 3 | | namespace AsyncResponse; |
| | | 4 | | |
| | | 5 | | /// <summary> |
| | | 6 | | /// Converts strongly-typed lambda expressions into serializable <see cref="ReflectionCallDto"/>s. |
| | | 7 | | /// Literal arguments are evaluated and captured by value; <see cref="Placeholder"/> marker calls |
| | | 8 | | /// become runtime placeholders. This gives compile-time safety (rename-refactoring, type checks) |
| | | 9 | | /// over hand-written reflection descriptors. |
| | | 10 | | /// </summary> |
| | | 11 | | internal static class CallbackExpressionConverter |
| | | 12 | | { |
| | | 13 | | /// <summary>Converts the callback expression to a reflection call descriptor.</summary> |
| | | 14 | | public static ReflectionCallDto ToReflectionCall<TService>(Expression<Action<TService>> expression) |
| | 2 | 15 | | => Build<TService>(expression.Body); |
| | | 16 | | |
| | | 17 | | /// <summary>Converts the callback expression to a reflection call descriptor.</summary> |
| | | 18 | | public static ReflectionCallDto ToReflectionCall<TService>(Expression<Func<TService, Task>> expression) |
| | 3 | 19 | | => Build<TService>(expression.Body); |
| | | 20 | | |
| | | 21 | | /// <summary>Converts the callback expression to a reflection call descriptor.</summary> |
| | | 22 | | public static ReflectionCallDto ToReflectionCall<TService>(Expression<Func<TService, ValueTask>> expression) |
| | 2 | 23 | | => Build<TService>(expression.Body); |
| | | 24 | | |
| | | 25 | | private static ReflectionCallDto Build<TService>(Expression body) |
| | | 26 | | { |
| | 3 | 27 | | if (body is not MethodCallExpression call) |
| | 2 | 28 | | throw new NotSupportedException($"Only direct method calls are supported. Got: {body.NodeType}"); |
| | | 29 | | |
| | | 30 | | // instance call on the lambda parameter (svc => svc.Method(...)) |
| | 3 | 31 | | if (call.Object is not ParameterExpression svcParam || svcParam.Type != typeof(TService)) |
| | 2 | 32 | | throw new NotSupportedException("Lambda must be like: svc => svc.YourMethod(args)"); |
| | | 33 | | |
| | 3 | 34 | | var args = call.Arguments.Select(arg => ConvertArgument(arg, svcParam)).ToArray(); |
| | | 35 | | |
| | 3 | 36 | | return new ReflectionCallDto |
| | 3 | 37 | | { |
| | 3 | 38 | | ServiceInterfaceFullName = typeof(TService).FullName |
| | 3 | 39 | | ?? throw new InvalidOperationException("Service interface must have FullName."), |
| | 3 | 40 | | MethodName = call.Method.Name, |
| | 3 | 41 | | Params = args |
| | 3 | 42 | | }; |
| | | 43 | | } |
| | | 44 | | |
| | | 45 | | private static CallbackParam ConvertArgument(Expression expression, ParameterExpression svcParam) |
| | | 46 | | { |
| | | 47 | | // A generic payload passed to an object parameter is wrapped in an implicit Convert node. |
| | | 48 | | // Strip only that harmless boxing/reference conversion so the marker remains top-level. |
| | 3 | 49 | | if (expression is UnaryExpression { NodeType: ExpressionType.Convert or ExpressionType.ConvertChecked } conversi |
| | 3 | 50 | | && conversion.Method is null |
| | 3 | 51 | | && conversion.Type.IsAssignableFrom(conversion.Operand.Type)) |
| | 3 | 52 | | expression = conversion.Operand; |
| | | 53 | | |
| | | 54 | | // Placeholder.Payload<T>() / Placeholder.Exception() / Placeholder.CorrelationId() |
| | | 55 | | // used directly as an argument become runtime placeholders. |
| | 3 | 56 | | if (expression is MethodCallExpression marker && marker.Method.DeclaringType == typeof(Placeholder)) |
| | | 57 | | { |
| | 3 | 58 | | return marker.Method.Name switch |
| | 3 | 59 | | { |
| | 3 | 60 | | nameof(Placeholder.Payload) => CallbackParam.ForPlaceholder(PlaceholderType.Payload), |
| | 3 | 61 | | nameof(Placeholder.Exception) => CallbackParam.ForPlaceholder(PlaceholderType.Exception), |
| | 3 | 62 | | nameof(Placeholder.CorrelationId) => CallbackParam.ForPlaceholder(PlaceholderType.CorrelationId), |
| | 0 | 63 | | _ => throw new NotSupportedException($"Unknown placeholder marker '{marker.Method.Name}'.") |
| | 3 | 64 | | }; |
| | | 65 | | } |
| | | 66 | | |
| | 3 | 67 | | return CallbackParam.ForValue(EvaluateArgument(expression, svcParam)); |
| | | 68 | | } |
| | | 69 | | |
| | | 70 | | // Evaluate each argument expression as a closed lambda. Disallow: |
| | | 71 | | // - method calls inside args (conservative; placeholders are handled above) |
| | | 72 | | // - any reference to the svc parameter |
| | | 73 | | private static object? EvaluateArgument(Expression expression, ParameterExpression svcParam) |
| | | 74 | | { |
| | 3 | 75 | | if (ContainsMethodCall(expression)) |
| | 2 | 76 | | throw new NotSupportedException( |
| | 2 | 77 | | "Arguments must be constants/new/array/member access, or a top-level Placeholder marker; " + |
| | 2 | 78 | | "other method-call arguments are not allowed."); |
| | | 79 | | |
| | 3 | 80 | | if (ReferencesParameter(expression, svcParam)) |
| | 2 | 81 | | throw new NotSupportedException("Argument must not reference the service parameter (e.g., svc => svc.M(svc.P |
| | | 82 | | |
| | 3 | 83 | | if (expression is ConstantExpression constant) |
| | | 84 | | { |
| | 3 | 85 | | return constant.Value; |
| | | 86 | | } |
| | | 87 | | |
| | | 88 | | // Use the interpreter to avoid JIT'ing lots of tiny dynamic methods, but keep the delegate |
| | | 89 | | // typed so argument capture does not pay DynamicInvoke's reflection dispatch cost. |
| | 3 | 90 | | var boxed = expression.Type == typeof(object) |
| | 3 | 91 | | ? expression |
| | 3 | 92 | | : Expression.Convert(expression, typeof(object)); |
| | 3 | 93 | | var lambda = Expression.Lambda<Func<object?>>(boxed); |
| | 3 | 94 | | return lambda.Compile(preferInterpretation: true)(); |
| | | 95 | | } |
| | | 96 | | |
| | | 97 | | private static bool ContainsMethodCall(Expression expression) |
| | | 98 | | { |
| | 3 | 99 | | var visitor = new MethodCallGuard(); |
| | 3 | 100 | | visitor.Visit(expression); |
| | 3 | 101 | | return visitor.Found; |
| | | 102 | | } |
| | | 103 | | |
| | | 104 | | private static bool ReferencesParameter(Expression expression, ParameterExpression parameter) |
| | | 105 | | { |
| | 3 | 106 | | var visitor = new ParameterGuard(parameter); |
| | 3 | 107 | | visitor.Visit(expression); |
| | 3 | 108 | | return visitor.Found; |
| | | 109 | | } |
| | | 110 | | |
| | | 111 | | private sealed class MethodCallGuard : ExpressionVisitor |
| | | 112 | | { |
| | | 113 | | public bool Found; |
| | | 114 | | |
| | | 115 | | /// <summary>Runs the Visit operation.</summary> |
| | | 116 | | public override Expression? Visit(Expression? node) |
| | | 117 | | { |
| | 3 | 118 | | if (Found || node is null) return node; |
| | 3 | 119 | | if (node.NodeType == ExpressionType.Call) { Found = true; return node; } |
| | 3 | 120 | | return base.Visit(node); |
| | | 121 | | } |
| | | 122 | | } |
| | | 123 | | |
| | 3 | 124 | | private sealed class ParameterGuard(ParameterExpression _parameter) : ExpressionVisitor |
| | | 125 | | { |
| | | 126 | | public bool Found; |
| | | 127 | | |
| | | 128 | | /// <summary>Runs the VisitParameter operation.</summary> |
| | | 129 | | protected override Expression VisitParameter(ParameterExpression node) |
| | | 130 | | { |
| | 2 | 131 | | if (node == _parameter) Found = true; |
| | 2 | 132 | | return base.VisitParameter(node); |
| | | 133 | | } |
| | | 134 | | } |
| | | 135 | | } |